677e0057b51f7da387dbe8e15d95e266e1350065
[processor-sdk/pdk.git] / packages / ti / drv / cbuff / example / cbuff_manual_testapp / main.c
1 /*
2  *  Copyright (c) Texas Instruments Incorporated 2020
3  *
4  *  Redistribution and use in source and binary forms, with or without
5  *  modification, are permitted provided that the following conditions
6  *  are met:
7  *
8  *    Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  *    Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the
14  *    distribution.
15  *
16  *    Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /*
34  *   @file  main.c
35  *
36  *   @brief
37  *      Unit Test code for the CBUFF MSS and DSS
38  *      Streams a chunk of data to LVDS interface.
39  *      Runs on MSS and DSS.
40  *      User needs to manually verify that data is captured on DCA1000 EVM.
41  *
42  */
44 /* *************** Test definition: ***************************************************
45 1. User needs to configure DCA1000GUI to receive data with default settings.
46 2. MSS/DSS comes out of reset and initializes CBUFF driver.
47 3. CBUFF driver is configured for a SW triggered session.
48 4. MSS/DSS activates the CBUFF Session which triggers data transfer from
49    local RAM to CBUFF FIFO.
50 5. Verify that data is captured on DCA1000.
51 6. It is expected to capture data on DCA1000 EVM. If not the test is considered as
52    FAIL.
53 */
55 /* ========================================================================== */
56 /*                             Include Files                                  */
57 /* ========================================================================== */
58 /* Standard Include Files. */
59 #include <string.h>
60 #include <stdio.h>
62 /* BIOS/XDC Include Files. */
63 #include <xdc/std.h>
64 #include <xdc/runtime/System.h>
65 #include <ti/sysbios/BIOS.h>
66 #include <ti/sysbios/knl/Task.h>
68 #include <ti/osal/TaskP.h>
69 #include <ti/osal/DebugP.h>
70 #include <ti/osal/CacheP.h>
72 #include <ti/board/board.h>
73 #include <ti/csl/cslr.h>
75 #include <ti/drv/edma/soc/edma_soc.h>
77 /* Cbuff Driver: */
78 #include <ti/drv/cbuff/cbuff.h>
79 #include <ti/drv/cbuff/src/cbuff_internal.h>
82 /* ========================================================================== */
83 /*                           Macros & Typedefs                                */
84 /* ========================================================================== */
86 /**
87  * @brief   This is the number of EDMA Channels which have been allocated and can be used
88  * by the CBUFF Driver.
89  */
90 #define TEST_APP_MAX_EDMA_TABLE_ENTRIES             3
92 /**
93  * @brief
94  *  The DCA1000EVM FPGA needs a minimum delay of 12ms between Bit clock starts and
95  *  actual LVDS Data start to lock the LVDS PLL IP. This is documented in the DCA UG
96  */
97 #define HSI_DCA_MIN_DELAY_MSEC                  12U
99 /* ========================================================================== */
100 /*                          Function Declarations                             */
101 /* ========================================================================== */
103 /* None. */
105 /* ========================================================================== */
106 /*                         Structure Declarations                             */
107 /* ========================================================================== */
109 /* None. */
111 /* ========================================================================== */
112 /*                            Global Variables                                */
113 /* ========================================================================== */
115 uint16_t gUserBuffer0[CSL_NEXT_MULTIPLE_OF_POW2(1024,CSL_CACHE_L1D_LINESIZE)] __attribute__ ((aligned(CSL_CACHE_L1D_LINESIZE)));
117 /**
118  * @brief   This is the DSS_A instance of EDMA which have been used by the CBUFF Driver.
119  */
120 volatile int8_t gInstanceId = EDMA_DRV_INST_DSS_A;
122  /**
123   * @brief   Global Variable which is used to test the failure of EDMA Channel allocation
124   */
125  uint8_t gTestEDMAChannelAllocationFailure = 0U;
127  /**
128   * @brief   This is a global variable which tracks the EDMA Channels which have been allocated to the
129   * CBUFF.
130   */
131  uint8_t  gCBUFFEDMAChannelResourceCounter = 0;
133 /* ========================================================================== */
134 /*                          Function Definitions                              */
135 /* ========================================================================== */
138  /**
139   * @brief   Global CBUFF EDMA Channel Resource Table:
140   */
141  static CBUFF_EDMAChannelCfg gCBUFFEDMAChannelResource [TEST_APP_MAX_EDMA_TABLE_ENTRIES] =
142  {
143      /* EDMA Channel Identifier, Shadow Link Channel Identifier */
144      {  EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ0,  65 },
145      {  EDMA_DSS_TPCC_A_EVT_FREE_0,   66 },
146      {  EDMA_DSS_TPCC_A_EVT_FREE_1,   67 }
147  };
150 /**
151  *  @b Description
152  *  @n
153  *      Performs Board Initialization
154  *
155  *  @retval
156  *      Success -   true
157  *  @retval
158  *      Error   -   false
159  */
160 static bool MmwDemo_BoardInit(void)
162     Board_initCfg boardCfg;
163     Board_STATUS  status;
165     boardCfg = BOARD_INIT_PINMUX_CONFIG |
166                BOARD_INIT_MODULE_CLOCK  |
167                BOARD_INIT_UNLOCK_MMR;
169     status = Board_init(boardCfg);
171     if (status != BOARD_SOK)
172     {
173         return false;
174     }
175     else
176     {
177         return true;
178     }
181 /**
182  *  @b Description
183  *  @n
184  *      Registered callback function with the EDMA to be invoked on an error
185  *
186  *  @retval
187  *      Not Applicable.
188  */
189 void Test_edmaErrorCallbackFxn(EDMA_Handle handle, EDMA_errorInfo_t *errorInfo)
191     DebugP_assert(0);
194 /**
195  *  @b Description
196  *  @n
197  *      Registered callback function with the EDMA to be invoked on an error
198  *
199  *  @retval
200  *      Not Applicable.
201  */
202 void Test_edmaTransferControllerErrorCallbackFxn
204     EDMA_Handle                         handle,
205     EDMA_transferControllerErrorInfo_t* errorInfo
208     DebugP_assert(0);
211 /**
212  *  @b Description
213  *  @n
214  *      This is the registered allocation function which is hooked up with the
215  *      CBUFF driver to allocate EDMA Channels
216  *
217  *  @retval
218  *      Success -   0
219  *  @retval
220  *      Error   -   <0
221  */
222 int32_t Test_EDMAAllocateCBUFFChannel (CBUFF_EDMAInfo* ptrEDMAInfo, CBUFF_EDMAChannelCfg* ptrEDMAChannelCfg)
224     /* Are we testing the EDMA allocation failure mode? */
225     if (gTestEDMAChannelAllocationFailure == 0U)
226     {
227         /* NO: Have we allocated all the EDMA channels? */
228         if (gCBUFFEDMAChannelResourceCounter >= TEST_APP_MAX_EDMA_TABLE_ENTRIES)
229         {
230             /* Error: Exceeded the allocated table. Failure */
231             DebugP_assert (0);
232             return -1;
233         }
235         /* Special case handling: First EDMA channel which is being allocated */
236         if (ptrEDMAInfo->isFirstEDMAChannel == true)
237         {
238             switch (ptrEDMAInfo->dmaNum)
239             {
240                 case 0:
241                 {
242                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ0;
243                     ptrEDMAChannelCfg->shadowLinkChannelsId = 65;
244                     break;
245                 }
246                 case 1:
247                 {
248                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ1;
249                     ptrEDMAChannelCfg->shadowLinkChannelsId = 100;
250                     break;
251                 }
252                 case 2:
253                 {
254                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ2;
255                     ptrEDMAChannelCfg->shadowLinkChannelsId = 101;
256                     break;
257                 }
258                 case 3:
259                 {
260                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ3;
261                     ptrEDMAChannelCfg->shadowLinkChannelsId = 102;
262                     break;
263                 }
264                 case 4:
265                 {
266                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ4;
267                     ptrEDMAChannelCfg->shadowLinkChannelsId = 103;
268                     break;
269                 }
270                 case 5:
271                 {
272                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ5;
273                     ptrEDMAChannelCfg->shadowLinkChannelsId = 104;
274                     break;
275                 }
276                 case 6:
277                 {
278                     ptrEDMAChannelCfg->chainChannelsId      = EDMA_DSS_TPCC_A_EVT_CBUFF_DMA_REQ6;
279                     ptrEDMAChannelCfg->shadowLinkChannelsId = 105;
280                     break;
281                 }
282                 default:
283                 {
284                     DebugP_assert (0);
285                     break;
286                 }
287             }
288         }
289         else
290         {
291             /* Copy over the allocated EDMA configuration. */
292             memcpy ((void *)ptrEDMAChannelCfg, (void*)&gCBUFFEDMAChannelResource[gCBUFFEDMAChannelResourceCounter],
293                     sizeof(CBUFF_EDMAChannelCfg));
294         }
296         /* Increment the number of EDMA Channels which have been allocated */
297         gCBUFFEDMAChannelResourceCounter++;
298         return 0;
299     }
300     else
301     {
302         /* YES: Return a failure to indicate that the channel allocation failed. We use this
303          * to ensure that the CBUFF driver correctly reports errors. */
304         return -1;
305     }
308 /**
309  *  @b Description
310  *  @n
311  *      This is the registered free function which is hooked up with the
312  *      CBUFF driver to free the allocated EDMA Channels
313  *
314  *  @retval
315  *      Not applicable
316  */
317 void Test_EDMAFreeCBUFFChannel(CBUFF_EDMAChannelCfg* ptrEDMACfg)
319     /* Debug Message: */
320     gCBUFFEDMAChannelResourceCounter--;
321     return;
324 /**
325  *  @b Description
326  *  @n
327  *      The function is used to test the invalid data size
328  *
329  *  @param[in]  socHandle
330  *      SOC Driver Handle
331  *  @param[in]  edmaHandle
332  *      EDMA Driver Handle
333  *
334  *  @retval
335  *      Success  -   0
336  *  @retval
337  *      Error    -  <0
338  */
339 int32_t Test_Cbuff
341     EDMA_Handle     edmaHandle
344     CBUFF_SessionCfg    sessionCfg;
345     CBUFF_Handle        cbuffHandle;
346     CBUFF_InitCfg       initCfg;
347     int32_t             errCode;
348     CBUFF_SessionHandle sessionHandle;
349     uint32_t i = 0;
351     /* Debug Message: */
352     System_printf ("---------------------------------------------------\n");
353     System_printf ("Debug: Testing CBUFF interface \n");
354     System_printf ("---------------------------------------------------\n");
356     /* Initialize the configuration: */
357     memset ((void*)&initCfg, 0, sizeof(CBUFF_InitCfg));
359     /* Populate the configuration: */
360     initCfg.outputDataFmt            = CBUFF_OutputDataFmt_16bit;
361     initCfg.enableECC                = 0U;
362     initCfg.crcEnable                = 0U;
363     initCfg.enableDebugMode          = false;
364     initCfg.maxSessions              = 2U;
365     initCfg.interface                = CBUFF_Interface_LVDS;
366     initCfg.lvdsCfg.crcEnable      = 0U;
367     initCfg.lvdsCfg.msbFirst       = 1U;
368     initCfg.lvdsCfg.ddrClockMode   = 1U;
369     initCfg.lvdsCfg.ddrClockModeMux= 1U;
371     /* Setup the lanes */
372     initCfg.lvdsCfg.lvdsLaneEnable = 0xFU;
374     /* Initialize the CBUFF Driver: */
375     cbuffHandle = CBUFF_init (&initCfg, &errCode);
376     if (cbuffHandle == NULL)
377     {
378         System_printf ("Error: CBUFF Driver initialization failed [Error code %d]\n", errCode);
379         return -1;
380     }
382     /* Configure LVDS PAD Control registers. */
383     /* Probably this functionality has to be from Board library. */
384     HW_WR_REG32(CSL_MSS_TOPRCM_U_BASE + CSL_MSS_TOPRCM_LVDS_PAD_CTRL0 , 0x0);
386     HW_WR_REG32(CSL_MSS_TOPRCM_U_BASE + CSL_MSS_TOPRCM_LVDS_PAD_CTRL1 , 0x02000000);
388     /*The delay below is needed only if the DCA1000EVM is being used to capture the data traces.
389       This is needed because the DCA1000EVM FPGA needs the delay to lock to the
390       bit clock before they can start capturing the data correctly. */
391     TaskP_sleepInMsecs(HSI_DCA_MIN_DELAY_MSEC);
393     /* Initialize the configuration */
394     memset ((void*)&sessionCfg, 0, sizeof(CBUFF_SessionCfg));
396     /* Initialize the configuration: */
397     for(i = 0; i < (sizeof(gUserBuffer0)/2); i++)
398     {
399         gUserBuffer0[i] = i;
400     }
401     CacheP_wbInv (gUserBuffer0, sizeof(gUserBuffer0));
403     /* Populate the configuration: */
404     sessionCfg.executionMode                      = CBUFF_SessionExecuteMode_SW;
405     sessionCfg.edmaHandle                         = edmaHandle;
406     sessionCfg.allocateEDMAChannelFxn             = Test_EDMAAllocateCBUFFChannel;
407     sessionCfg.freeEDMAChannelFxn                 = Test_EDMAFreeCBUFFChannel;
408     sessionCfg.dataType                           = CBUFF_DataType_COMPLEX;
409     sessionCfg.u.swCfg.userBufferInfo[0].size     = sizeof(gUserBuffer0);
410     sessionCfg.u.swCfg.userBufferInfo[0].address  = (uint32_t)&gUserBuffer0[0];
413     /* Create the SW CBUFF Session: */
414     sessionHandle = CBUFF_open (cbuffHandle, &sessionCfg, &errCode);
415     if (sessionHandle == NULL)
416     {
417         System_printf ("Error: Unable to create the session [Error code %d]\n", errCode);
418         return -1;
419     }
421     /* Debug Message: Display the EDMA Channel Usage for the test. */
422     System_printf ("Debug: EDMA Channel Usage = %d\n", gCBUFFEDMAChannelResourceCounter);
424     /* Activate the session: */
425     if (CBUFF_activateSession (sessionHandle, &errCode) < 0)
426     {
427         System_printf ("Error: Unable to activate the session [Error code %d]\n", errCode);
428         return -1;
429     }
431     /* Deactivate the session: */
432     if (CBUFF_deactivateSession (sessionHandle, &errCode) < 0)
433     {
434         System_printf ("Error: Unable to deactivate the session [Error code %d]\n", errCode);
435         return -1;
436     }
438     /* Delete the session: */
439     if (CBUFF_close (sessionHandle, &errCode) < 0)
440     {
441         System_printf ("Error: Unable to delete the session [Error code %d]\n", errCode);
442         return -1;
443     }
445     /* Sanity Check: Ensure that all the EDMA resources have been cleaned up */
446     if (gCBUFFEDMAChannelResourceCounter != 0)
447     {
448         System_printf ("Error: EDMA Channel Memory leak detected\n");
449         return -1;
450     }
452     return 0;
455 void Test_initTask(UArg arg0, UArg arg1)
457         EDMA_Handle         edmaHandle;
458         int32_t             errCode;
460     EDMA_instanceInfo_t instanceInfo;
462     EDMA3CCInitParams initParam;
463     EDMA_errorConfig_t errorConfig;
465     char instName[25];
466     EDMA_getInstanceName(gInstanceId, &instName[0], sizeof(instName));
467     System_printf("EDMA instance #%d: %s\n", gInstanceId, instName);
469     EDMA3CCInitParams_init(&initParam);
470     initParam.initParamSet = TRUE;
472     /* Initialize the edma instance.  */
473     errCode = EDMA_init(gInstanceId, &initParam);
475     if (errCode == EDMA_NO_ERROR)
476     {
477         /* Open the first edma Instance */
478         edmaHandle = EDMA_open(gInstanceId, &errCode, &instanceInfo);
479         if (edmaHandle == NULL)
480         {
481                 System_printf("Error: Unable to open the edma Instance, erorCode = %d\n", errCode);
482         }
483     }
485     /* Setup the EDMA Error Monitoring: */
486     errorConfig.isConfigAllEventQueues              = true;
487     errorConfig.isConfigAllTransferControllers      = true;
488     errorConfig.isEventQueueThresholdingEnabled     = true;
489     errorConfig.eventQueueThreshold                 = EDMA_EVENT_QUEUE_THRESHOLD_MAX;
490     errorConfig.isEnableAllTransferControllerErrors = true;
491     errorConfig.callbackFxn                         = Test_edmaErrorCallbackFxn;
492     errorConfig.transferControllerCallbackFxn       = Test_edmaTransferControllerErrorCallbackFxn;
493     errCode = EDMA_configErrorMonitoring(edmaHandle, &errorConfig);
494     if (errCode != EDMA_NO_ERROR)
495     {
496         System_printf("Debug: EDMA_configErrorMonitoring() failed with errorCode = %d\n", errCode);
497         return;
498     }
500     /* Test */
501     if (Test_Cbuff (edmaHandle) < 0)
502         return;
504     /* Exit BIOS */
505     BIOS_exit(0);
507     return;
510 int main (void)
512     Task_Params    taskParams;
514     MmwDemo_BoardInit();
516     /* Configure HSI interface Clock */
517     HW_WR_REG32(CSL_MSS_TOPRCM_U_BASE + CSL_MSS_TOPRCM_HSI_CLK_SRC_SEL, 0x444);  //Div by 2
518     HW_WR_REG32(CSL_MSS_TOPRCM_U_BASE + CSL_MSS_TOPRCM_HSI_DIV_VAL, 0x111);
519     HW_WR_REG32(CSL_MSS_TOPRCM_U_BASE + CSL_MSS_TOPRCM_HSI_CLK_GATE , 0x0);
521     /* Select MDO source as CBUFF. By default it is set to AURORA. */
522     /* Probably this functionality has to be from Board library. */
523     HW_WR_REG32(CSL_TOP_CTRL_U_BASE + 4, 0x10);
525     /* Debug Message: */
526     System_printf ("***********************************************\n");
527     System_printf ("************** CBUFF Unit Tests ***************\n");
528     System_printf ("***********************************************\n");
530     /* Initialize the Task Parameters. */
531     Task_Params_init(&taskParams);
532     taskParams.stackSize = 4*1024;
533     Task_create(Test_initTask, &taskParams, NULL);
535     /* Start BIOS */
536     BIOS_start();
537     return 0;