- Fix for SDOCM00108178 in src/tcp3d_drv.c.
[keystone-rtos/tcp3d-lld.git] / example / src / tcp3d_example_main.c
1 /*\r
2  *\r
3  * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/ \r
4  * \r
5  * \r
6  *  Redistribution and use in source and binary forms, with or without \r
7  *  modification, are permitted provided that the following conditions \r
8  *  are met:\r
9  *\r
10  *    Redistributions of source code must retain the above copyright \r
11  *    notice, this list of conditions and the following disclaimer.\r
12  *\r
13  *    Redistributions in binary form must reproduce the above copyright\r
14  *    notice, this list of conditions and the following disclaimer in the \r
15  *    documentation and/or other materials provided with the   \r
16  *    distribution.\r
17  *\r
18  *    Neither the name of Texas Instruments Incorporated nor the names of\r
19  *    its contributors may be used to endorse or promote products derived\r
20  *    from this software without specific prior written permission.\r
21  *\r
22  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
23  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
24  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
25  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
26  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
27  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
28  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
29  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
30  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
31  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
32  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
33  *\r
34 */\r
35 \r
36 \r
37 \r
38 #include <stdio.h>\r
39 #include <time.h>\r
40 #include <string.h>\r
41 \r
42 /* XDC includes */\r
43 #include <xdc/runtime/IHeap.h>\r
44 \r
45 /* BIOS includes */\r
46 #include <ti/sysbios/knl/Task.h>\r
47 #include <ti/sysbios/BIOS.h>\r
48 #include <ti/sysbios/knl/Semaphore.h>\r
49 #include <ti/sysbios/family/c64p/Hwi.h>\r
50 #include <ti/sysbios/family/c64p/EventCombiner.h>\r
51 #include <ti/sysbios/family/c66/tci66xx/CpIntc.h>\r
52 \r
53 /* IPC includes */ \r
54 #include <ti/ipc/GateMP.h>\r
55 #include <ti/ipc/Ipc.h>\r
56 #include <ti/ipc/ListMP.h>\r
57 #include <ti/ipc/SharedRegion.h>\r
58 #include <ti/ipc/MultiProc.h>\r
59 \r
60 /* CSL includes */\r
61 #include <ti/csl/soc.h>\r
62 #include <ti/csl/csl_chipAux.h>\r
63 #include <ti/csl/cslr_tpcc.h>\r
64 #include <ti/csl/cslr_tcp3d_cfg.h>\r
65 #include <ti/csl/cslr_tcp3d_dma.h>\r
66 #include <ti/csl/cslr_tcp3d_dma_offsets.h>\r
67 #include <ti/csl/csl_tsc.h>\r
68 #include <ti/csl/csl_cacheAux.h>\r
69 #include <ti/csl/csl_xmcAux.h>\r
70 #include <ti/csl/csl_pscAux.h>\r
71 \r
72 #include "sample.h"\r
73 #include "tcp3d_drv_sample.h"\r
74 #include "tcp3d_main.h"\r
75 \r
76 /**********************************************************************\r
77  ************************** Test Compile Flags ************************\r
78  **********************************************************************/\r
79 #define DEBUG_VARS                  0   // add debug variables at different places in the code \r
80 \r
81 #define DEBUG_PRINT                 0\r
82 \r
83 #define MY_LOG_PRINT0(x) {\\r
84     if(DEBUG_PRINT)\\r
85     {\\r
86         System_printf(#x"\n");\\r
87     }\\r
88 }\r
89 \r
90 #define MY_LOG_PRINT1(x, val) {\\r
91     if(DEBUG_PRINT)\\r
92     {\\r
93         System_printf(#x" %d\n", val);\\r
94     }\\r
95 }\r
96 \r
97 #define MY_LOG_PRINT2(x, val1, y, val2) {\\r
98     if(DEBUG_PRINT)\\r
99     {\\r
100         System_printf(#x" %d, "#y" %d\n", val1, val2);\\r
101     }\\r
102 }\r
103 \r
104 /**\r
105  * This is used for plotting timing diagram using matlab by collecting the data\r
106  * points from running the code.\r
107  * \r
108  * Requirements:\r
109  *  1) it is required to enable the logging for TCP3D in the Simulator\r
110  *      Configuration file. The decoding and reset times are collected from the\r
111  *      log file (c:\\Tcp3dDebug.log) generated from running the simulator.\r
112  */\r
113 #define TEST_PROFILE_LOG             1 \r
114 \r
115 /**********************************************************************\r
116  ************************** Test Definitions **************************\r
117  **********************************************************************/\r
118 #define START_CMD_PERIOD            1\r
119 \r
120 /**********************************************************************\r
121  ************************** Test Variables ****************************\r
122  **********************************************************************/\r
123 /* Code Block Test Variables */\r
124 #pragma DATA_SECTION(codeBlockSet, ".main_mem")\r
125 cbTestDesc              codeBlockSet;\r
126 \r
127 Char                    *strMode[4] = {"3GPP(0)","LTE(1)","WIMAX(2)","WCDMA Split(3)"};\r
128 Char                    *strDBuf[2] = {"Disable(0)","Enable(1)"};\r
129 Char                    *strInst[2] = {"TCP3D_A(0)","TCP3D_B(1)"};\r
130 \r
131 UInt32                  keepTestVectMem = 0;\r
132 UInt32                  firstTime = 1;\r
133 UInt32                  testMaxCodeBlocks;\r
134 UInt32                  dspCoreID;\r
135 \r
136 /* File Operation Variables */\r
137 UInt32                  testCntr = 0;\r
138 UInt32                  testErrCntr = 0;\r
139 UInt32                  totErrCnt;\r
140 #ifdef  USE_PDK_INSTALL_BASE\r
141 Char                    testvectFolderBase[] = "C:\\ti\\csl_lld_keystone2_1_0_0_2\\packages\\ti\\drv\\tcp3d\\example\\testvectors\\";\r
142 #else\r
143 Char                    testvectFolderBase[] = "..\\..\\testvectors\\";\r
144 #endif\r
145 Char                    folderName[1000] = "";\r
146 Char                    *testFolder[] = { "lte", "wcdma", "wimax", };\r
147 /* Number of test folders computed. Alternately can be set manually as length of *testFolder[] array */\r
148 UInt32                  numTests = sizeof(testFolder)/sizeof(*testFolder);\r
149 \r
150 /* Throughput calculation variables */\r
151 clock_t                 total_clock_end, total_clock_start;\r
152 UInt32                  test_cycles;\r
153 UInt32                  TotalBitsDecoded;\r
154 Float                   ThroughPut;\r
155 \r
156 /* BIOS variables */\r
157 Semaphore_Handle        semRcvDone, semSendBlock, semSendWait, semRcvStart;\r
158 IHeap_Handle            dataHeap = NULL;\r
159 IHeap_Handle            drvHeap = NULL;\r
160 \r
161 /* Driver configuration variables */\r
162 Tcp3d_Result            tcp3dResultSend = TCP3D_DRV_NO_ERR;\r
163 Tcp3d_Instance          *tcp3dDrvInst[2] = {NULL, NULL};\r
164 Tcp3d_Instance          *inst;\r
165 Tcp3d_Ctrl              drvCtrl;\r
166 Tcp3d_Sts               drvStatus;\r
167 \r
168 Int32                   sendBlockCnt;\r
169 Int32                   rcvBlockCnt;\r
170 #if TEST_PREPARE_ONLY_CODEBLOCK_PARAM_DEPENDENT\r
171 UInt32                  tempICRegs[15]; /* to store 15 registers */\r
172 #endif\r
173 \r
174 /**\r
175  * EDMA3 LLD & TCP3D Driver Init/Deinit related variables\r
176  */\r
177 EDMA3_DRV_Handle        hEdma;\r
178 UInt32                  tpccNum;\r
179 UInt32                  tpccRegionUsed;\r
180 EDMA_CONFIG             edmaConfig[2];\r
181 UInt8                   instNum;\r
182 /* Flags used in ISR functions */\r
183 UInt32                  pingComplete, pongComplete;\r
184 UInt32                  pauseIntr = 0, l2pIntr = 0;\r
185 UInt32                  soldoutCntr = 0;\r
186 UInt32                  tcp3dEventCntr = 0;\r
187 UInt32                  tpccEvtCntr = 0;\r
188 UInt32                  rcvStartFlag = 0;\r
189 UInt32                  pauseIntFlag = 0;\r
190 UInt32                  afterIntrSoldout = 0, afterIntrPause = 0;\r
191 UInt32                  pendPauseCntr = 0;\r
192 \r
193 #if DEBUG_VARS\r
194 #include <ti/csl/src/intc/csl_intc.h>\r
195 #include <ti/csl/csl_cpIntcAux.h>\r
196 \r
197 /* To track the RCV task posting */\r
198 volatile Int            semCnt;\r
199 \r
200 /* Register pointers */\r
201 CSL_TpccRegs            *tpcc2Regs = (CSL_TpccRegs *) CSL_EDMA2CC_REGS;\r
202 CSL_CPINTC_RegsOvly     cpintc0Regs = (CSL_CPINTC_RegsOvly) CSL_CP_INTC_0_REGS;\r
203 CSL_IntcRegsOvly        gemIntcRegs = (CSL_IntcRegsOvly)CSL_CGEM0_5_REG_BASE_ADDRESS_REGS;\r
204 #endif\r
205 \r
206 /**********************************************************************\r
207  *********************** Test Local Functions *************************\r
208  **********************************************************************/\r
209 /**\r
210  * Task Functions\r
211  */\r
212 Void testerTaskFunc(Void);\r
213 Void tskHeartBeat(Void);\r
214 Void sndBlockTaskFunc(Void);\r
215 Void rcvBlockTaskFunc(Void);\r
216 \r
217 /**\r
218  * (De)Init Functions\r
219  */\r
220 Void allInit(Void);\r
221 Void allDeInit(Void);\r
222 Void getMemoryStats(Void);\r
223 \r
224 /**\r
225  * EDMA Channel ISR functions\r
226  */\r
227 Void revt0ChCallback(Void);\r
228 Void revt1ChCallback(Void);\r\r
229 \r
230 /**\r
231  * Cache and other IP functions\r
232  */\r
233 static Int32 enable_tcp3d (void);\r
234 void tcp3dBeginMemAccess (void *ptr, uint32_t size);\r
235 void tcp3dEndMemAccess (void *ptr, uint32_t size);\r
236 \r
237 #if USE_LOCAL_CPINTC_DISPATCH\r
238 extern Void CpIntc_dispatchLoc(UInt hostInt);\r
239 #endif\r
240 \r
241 Void soldOutAction(Void)\r
242 {\r
243     /* clear flag */\r
244     pauseIntFlag = 0;\r
245 \r
246 #if SOLDOUT_USE_L2P_INTERRUPT\r
247     /**\r
248      *  1) enable L2P channel interrupt to get notified to try enqueue again\r
249      *  2) also enable REVT channel interrupt for PAUSE detection\r
250      */\r
251     /* Set interrupt flag on PAUSE channel */\r
252     drvCtrl.cmd = TCP3D_DRV_SET_REVT_INT;\r
253     drvCtrl.intrFlag = TEST_INTR_ENABLE;   // enable\r
254     Tcp3d_control(inst, &drvCtrl);\r
255 \r
256     /* Call TCP3D driver control to set interrupt on L2P channel */\r
257     drvCtrl.cmd = TCP3D_DRV_SET_L2P_INT;\r
258     drvCtrl.intrFlag = TEST_INTR_ENABLE;   // enable\r
259     Tcp3d_control(inst, &drvCtrl);\r
260 #else\r
261     /* keep trying until successful */\r
262     Semaphore_post(semSendBlock);\r
263 #endif\r
264 }\r
265 \r
266 Void soldOutActionClear (Void)\r
267 {\r
268 #if SOLDOUT_USE_L2P_INTERRUPT\r
269     if ( pauseIntFlag )\r
270     {\r
271         afterIntrSoldout++;\r
272         \r
273         /**\r
274          *  1) diable L2P channel interrupt to get notified to try enqueue again\r
275          *  2) also disable REVT channel interrupt for PAUSE detection\r
276          */\r
277         /* Call TCP3D driver control to set interrupt on L2P channel */\r
278         drvCtrl.cmd = TCP3D_DRV_SET_L2P_INT;\r
279         drvCtrl.intrFlag = TEST_INTR_DISABLE;   // disable\r
280         Tcp3d_control(inst, &drvCtrl);\r
281 \r
282         /* Set interrupt flag on PAUSE channel */\r
283         drvCtrl.cmd = TCP3D_DRV_SET_REVT_INT;\r
284         drvCtrl.intrFlag = TEST_INTR_DISABLE;   // disable\r
285         Tcp3d_control(inst, &drvCtrl);\r
286     }\r
287 #else\r
288     /* nothing to be done */\r
289 #endif\r
290 }\r
291 \r
292 /*******************************************************************************\r
293  TESTING METHOD 1: Copy test vector folder to workspace\r
294 --------------------------------------------------------------------------------\r
295 1.  In this method, ensure that the entire \93example\testvectors\94 folder is \r
296     placed two levels higher than the unit example project .out file location.\r
297     For example, if the unit example project out file is located under\r
298     \93C:\MyPDKWorkspace\tcp3dExampleProject\Debug\94 folder, then please copy\r
299     the folder \93example\testvectors\94 from the PDK package to \93C:\MyPDKWorkspace\94.\r
300 2.  Ensure that the compile flag USE_PDK_INSTALL_BASE is undefined in\r
301     the project \93tcp3dExampleProject\94 before building.\r
302 3.      Build the project.\r
303 4.      Launch the debug session to load and run the out file.\r
304 \r
305  TESTING METHOD 2: Use the test vector folder from the PDK installation\r
306 --------------------------------------------------------------------------------\r
307 1.  In this method, ensure that the compile flag USE_PDK_INSTALL_BASE is defined\r
308     in the project \93tcp3dExampleProject\94.\r
309 2.      Also, ensure the variable \93testvectFolderBase\94 defined in the tcp3d_example_main.c\r
310     file is set to \93<PDK_INSTALL_DIR>\packages\ti\drv\tcp3d\example\testvectors\94\r
311     when the USE_PDK_INSTALL_BASE flag is defined.\r
312 3.      Build the project.\r
313 4.      Launch the debug session to load and run the out file.\r
314  \r
315 By default, example project is configured to test using "METHOD 1"\r
316  ******************************************************************************/\r
317 /*\r
318  * main()\r
319  */\r
320 Void main(Void)\r
321 {\r
322     Task_Params taskParams;\r
323 \r
324     /* Initialize the heap in shared memory. Using IPC module to do that */ \r
325     Ipc_start();\r
326 \r
327     /* Power on TCP3D peripheral before using it */\r
328     if (enable_tcp3d () < 0)\r
329     {\r
330         System_printf ("Error: TCP3D PSC Initialization Failed\n");\r
331         return;\r
332     }\r
333     \r
334     /* Enable time stamp counter */\r
335     CSL_tscEnable();\r
336 \r
337     /* Enable L1D cache. Disable L2 caching for our tests. */\r
338     CACHE_setL1DSize (CACHE_L1_MAXIM3); /* CACHE_L1_0KCACHE */\r
339     CACHE_setL2Size (CACHE_0KCACHE);\r
340 \r
341     /* Initialize the default Task parameters */\r
342     Task_Params_init(&taskParams);\r
343 \r
344     /* Crete the tester Task using default Task parameters */\r
345     Task_create((Task_FuncPtr)testerTaskFunc, &taskParams, NULL);\r
346 \r
347     BIOS_start();\r
348 }\r
349 \r
350 /*******************************************************************************\r
351  ******************************************************************************/\r
352 Void testerTaskFunc(Void)\r
353 {\r
354     Int                 i;\r
355     Task_Params         taskParams;\r
356     Semaphore_Params    semParams;\r
357 \r
358     /* Set the one-time global test variables */\r
359     testMaxCodeBlocks   = 86; /* max possible used in init */\r
360     dspCoreID           = CSL_chipReadDNUM();\r
361 \r
362     /******** Select the TCP3D Instance Number **********/\r
363 #if 0\r
364     if ( dspCoreID == 0 ) // Core 0\r
365         instNum = CSL_TCP3D_A;\r
366     else\r
367         instNum = CSL_TCP3D_B;\r
368 #else\r
369     instNum = getTcp3dInstNum(dspCoreID);\r
370 #endif\r
371 \r
372     /* Initialize the default Task parameters */\r
373     Task_Params_init(&taskParams);\r
374 \r
375     /* Initialize the default Semaphore parameters */\r
376     Semaphore_Params_init(&semParams);\r
377 \r
378     /* Crete the Binary Semaphore */\r
379     semParams.mode = Semaphore_Mode_BINARY;\r
380     semRcvDone = Semaphore_create(0, &semParams, NULL);\r
381 \r
382     /* Get the Heap handles - used when ever memory allocations are needed */\r
383     //dataHeap = HeapMem_Handle_upCast(tcp3dDataHeap);\r
384     dataHeap = (IHeap_Handle) SharedRegion_getHeap(0);\r
385     drvHeap = HeapMem_Handle_upCast(tcp3dDrvHeap);\r
386 \r
387     while( testCntr < numTests )\r
388     {\r
389 \r
390         /**\r
391          * Create the Binary semaphores each time using the parameters set\r
392          * outside the tester while loop.\r
393          * \r
394          * It was observed that at times the receive semaphore count was\r
395          * non-zero after the first run and receive task was getting triggered\r
396          * before posting from the ISR callback. So, the semaphores are created\r
397          * for each test to work-around with the problem. \r
398          */\r
399         semSendBlock = Semaphore_create(0, &semParams, NULL);\r
400         semSendWait = Semaphore_create(0, &semParams, NULL);\r
401         semRcvStart = Semaphore_create(0, &semParams, NULL);\r
402 #if DEBUG_VARS\r
403         semCnt = Semaphore_getCount(semRcvStart);\r
404 #endif\r
405 \r
406         /**\r
407          * Create the send and receive tasks for each test using the default\r
408          * tak parameters.\r
409          * \r
410          * NOTE: No need to do the Task_delete() as these tasks have exits.\r
411          */\r
412         Task_create((Task_FuncPtr)sndBlockTaskFunc, &taskParams, NULL);\r
413         Task_create((Task_FuncPtr)rcvBlockTaskFunc, &taskParams, NULL);\r
414 \r
415         System_printf("\n******************************************************************\n");\r
416         System_printf("\n----- TEST #%d STARTED ------\n", testCntr);\r
417 \r
418         /**\r
419          * Prepare data for Code Blocks processing (reading test vector files).\r
420          * Allocates Memory as needed from the tcp3dDataHeap\r
421          */\r
422         if ( firstTime )\r
423         {\r
424             System_printf("\nReading test vector files started (including memory allocation)...\n");\r
425             strcpy(folderName, testvectFolderBase);\r
426             strcat(folderName, testFolder[testCntr]);\r
427             getTestSetCB(dataHeap, &codeBlockSet, folderName);\r
428             System_printf("Reading test vector files complete\n");\r
429 #if DEBUG_PRINT\r
430             System_printf("\tPrepared %d code blocks in %s mode\n", codeBlockSet.maxNumCB, strMode[codeBlockSet.mode]);\r
431 #endif\r
432             firstTime = 0;\r
433         }\r
434         else\r
435         {\r
436             System_printf("\nUsing the test vectors read before\n");\r
437         }\r
438 \r
439         System_printf("\n----- TEST INITIALIZATION STARTED -----\n\n");\r
440         allInit();\r
441         getMemoryStats(); /* Heap Stats */\r
442         System_printf("\n----- TEST INITIALIZATION COMPLETE -----\n\n");\r
443 \r
444 #if TEST_PREPARE_ONLY_BETASTATE\r
445         for (i = 0; i < codeBlockSet.maxNumCB ;i++)\r
446         {\r
447             /* Prepare fixed IC registers using the inCfgParams of first block*/\r
448             Tcp3d_prepFixedConfigRegs(codeBlockSet.cbData[i]->inCfgParams, codeBlockSet.cbData[i]->inCfg);\r
449 \r
450             /* Prepare block size dependent params */\r
451             prepareBlockSizeDepICParams(codeBlockSet.cbData[i]);\r
452         }\r
453 #elif TEST_PREPARE_ONLY_CODEBLOCK_PARAM_DEPENDENT\r
454         /* Prepare fixed IC registers using the inCfgParams of first block*/\r
455         Tcp3d_prepFixedConfigRegs(codeBlockSet.cbData[0]->inCfgParams, tempICRegs);\r
456 #endif\r
457 \r
458         /* Start the Send task first */\r
459         Semaphore_post(semSendBlock);\r
460 \r
461         /* Wait for the Receive task to complete */\r
462         Semaphore_pend(semRcvDone, BIOS_WAIT_FOREVER);\r
463 \r
464         /**\r
465          * Test Profile Calculations\r
466          * \r
467          *                              (Total Bits)\r
468          * Throughput (Mbps) = -----------------------------\r
469          *                      (Total Time)*(10^-9)*(10^6)\r
470          * \r
471          */\r
472         TotalBitsDecoded = 0;\r
473         for (i = 0; i < codeBlockSet.maxNumCB; ++i)\r
474         {\r
475             TotalBitsDecoded += codeBlockSet.cbData[i]->blockSize;\r
476         }\r
477 \r
478         test_cycles = (total_clock_end - total_clock_start);\r
479         ThroughPut = TotalBitsDecoded*1.0;\r
480         ThroughPut = (ThroughPut/test_cycles)*1000;\r
481 \r
482         /******** Free code blocks ********/\r
483         if ( keepTestVectMem )\r
484         {\r
485             System_printf("\nNo freeing - Using the test vectors read before\n");\r
486         }\r
487         else\r
488         {\r
489             System_printf("\nTest vectors memory freeing started...\n");\r
490             freeTestSetCB(dataHeap, &codeBlockSet);\r
491             System_printf("Test vectors memory freeing complete\n");\r
492 #if DEBUG_PRINT\r
493             System_printf("\tFreed memory allocated for %d code blocks in %s mode\n", codeBlockSet.maxNumCB, strMode[codeBlockSet.mode]);\r
494 #endif\r
495             firstTime = 1;\r
496         }\r
497 \r
498         System_printf("\n----- TEST DE-INITIALIZATION STARTED -----\n\n");\r
499         allDeInit();\r
500         getMemoryStats(); /* Heap Stats */\r
501         System_printf("\n----- TEST DE-INITIALIZATION COMPLETE -----\n");\r
502     \r
503         if ( totErrCnt > 0 )\r
504         {\r
505             System_printf("\n----- TEST #%d FAILED -----\n", testCntr);\r
506             testErrCntr++;\r
507         }\r
508         else\r
509         {\r
510             System_printf("\n----- TEST #%d PASSED -----\n", testCntr);\r
511         }\r
512         System_printf("\n+++++++++++++++++++++++ TEST #%d SUMMARY +++++++++++++++++++++++++\n", testCntr);\r
513         System_printf("TCP3D Peripheral Configuration\n");\r
514         System_printf("    Instance                     : %s\n", strInst[instNum]);\r
515         System_printf("    Mode Tested                  : %s\n", strMode[codeBlockSet.mode]);\r
516         System_printf("    Double Buffer Mode           : %s\n", strDBuf[codeBlockSet.doubleBuffer]);\r
517         System_printf("Max code blocks (Input Capacity) : %d\n", testMaxCodeBlocks);\r
518         System_printf("Code blocks sent for decoding    : %d\n", codeBlockSet.maxNumCB);\r
519         System_printf("Call back counters               : %d - interrupts\n", pauseIntr);\r
520         System_printf("                          (%d-SOLDOUT, %d-PAUSE, %d-PENDPAUSE)\n", afterIntrSoldout, afterIntrPause, pendPauseCntr);\r
521         System_printf("Total Notification Interrupts    : %d\n", tcp3dEventCntr);\r
522         System_printf("Throughput Calculations\n");\r
523         System_printf("    Total Bits Decoded           : %d\n", TotalBitsDecoded);\r
524         System_printf("    Time Taken (in cycles)       : %d\n", test_cycles);\r
525         System_printf("    Effective Throughput         : %f Mbps\n", ThroughPut);\r
526         System_printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");\r
527 \r
528         System_printf("\n******************************************************************\n");\r
529 \r
530         /* Increment the test counter */\r
531         testCntr++;\r
532 \r
533         /**\r
534          * Delete the semaphores each time, so that there is no left over count.\r
535          * See the explanation at the beginning of this loop where the create\r
536          * semaphore calls are present. \r
537          */\r
538 #if DEBUG_VARS\r
539         semCnt = Semaphore_getCount(semRcvStart);\r
540 #endif\r
541         Semaphore_delete(&semSendWait);\r
542         Semaphore_delete(&semSendBlock);\r
543         Semaphore_delete(&semRcvStart);\r
544     }\r
545 \r
546     /* All test status print */\r
547     if(testErrCntr)\r
548     {\r
549         System_printf("!!! SOME TESTS FAILED !!!\n");\r
550     }\r
551     else\r
552     {\r
553         System_printf("!!! ALL TESTS PASSED !!!\n");\r
554     }\r
555 \r
556     /* Remove all creations - to make graceful system exit */\r
557     Semaphore_delete(&semRcvDone);\r
558 \r
559     System_exit(0);\r
560 }\r
561    \r
562 /*******************************************************************************\r
563  ******************************************************************************/\r
564 Void sndBlockTaskFunc(Void)\r
565 {\r
566     UInt8               notifyFlag;\r
567     cbDataDesc          *cbPtr;\r
568     static UInt32       cookie = 0;\r
569 \r
570     sendBlockCnt = 0;\r
571 \r
572 #if DEBUG_VARS\r
573         semCnt = Semaphore_getCount(semSendBlock);\r
574 #endif\r
575 \r
576     total_clock_start = TSCL;\r
577 \r
578     while(1)\r
579     {\r
580         /* Pending on Semaphore to run the loop */\r
581         Semaphore_pend(semSendBlock, BIOS_WAIT_FOREVER);\r
582 \r
583         /* set TCP3D instance to use */\r
584         inst = tcp3dDrvInst[instNum];\r
585 \r
586         /* Get pointer to the code block data structure */\r
587         cbPtr = codeBlockSet.cbData[sendBlockCnt];\r
588 \r
589         /* Interrupt flag, used in Tcp3d_enqueueCodeBlock function */\r
590         notifyFlag = 0;\r
591         if ( sendBlockCnt >= (codeBlockSet.maxNumCB-2) )\r
592         {\r
593             notifyFlag = 1; /* Set for the last CB in each path (PING & PONG) */\r
594         }\r
595 \r
596         /**\r
597          * Prepare input configuration (IC) registers.\r
598          */\r
599         if ( TCP3D_DRV_INPUT_LIST_FULL == tcp3dResultSend )\r
600         {\r
601             /* IC prepare not required. Just clear soldout actions. */\r
602             soldOutActionClear();\r
603         }\r
604         else\r
605         {\r
606             /* Prepare Input Config Registers */\r
607 #if TEST_PREPARE_ONLY_BETASTATE\r
608         /* Prepare only beta state registers */\r
609         prepareBetaStateICParams(cbPtr, cbPtr->mode);\r
610 #elif TEST_PREPARE_ONLY_CODEBLOCK_PARAM_DEPENDENT \r
611         /* Prepare only registers depend on code block configuration\r
612          * (tempICRegs has the fixed registers prepare outside send loop) */\r
613         prepareIC(cbPtr, tempICRegs, 1);\r
614 #else\r
615         /* Prepare all registers */\r
616         prepareIC(cbPtr, NULL, NULL);\r
617 #endif\r
618         }\r
619 \r
620         checkBetaValues (cbPtr->inCfg);\r
621 \r
622         /* Disabling the global interrupts */\r
623         cookie = Hwi_disable();\r
624 \r
625         tcp3dEndMemAccess(cbPtr->inCfg, cbPtr->sizeCFG);\r
626         tcp3dEndMemAccess(cbPtr->inLLR, cbPtr->sizeLLR);\r
627 \r
628         tcp3dBeginMemAccess(cbPtr->outHD, cbPtr->sizeHD);\r
629         if (cbPtr->sdFlag)\r
630             tcp3dBeginMemAccess(cbPtr->outSD, cbPtr->sizeSD);\r
631         if (cbPtr->stsFlag)\r
632             tcp3dBeginMemAccess(cbPtr->outSts, cbPtr->sizeSTS);\r
633 \r
634         /* Restore interrupts */\r
635         Hwi_restore(cookie);\r
636 \r
637         /**\r
638          * WORKAROUND CODE:\r
639          * This code works in line with the code in the second while loop\r
640          * in the send task where check for completion is done.\r
641          * Here we are setting the last byte in the outHD with some value when\r
642          * the refHD has 0x00. This avoids any false completion of send task.\r
643          */\r
644         if ( sendBlockCnt >= (codeBlockSet.maxNumCB-2) )\r
645         {\r
646             /* Fill the last byte in outHD when refHD last byte is ZERO */\r
647             uint8_t     *bytePtr1, *bytePtr2;\r
648             uint32_t    byteSize;\r
649 \r
650             bytePtr1 = (UInt8 *) cbPtr->refHD;\r
651             bytePtr2 = (UInt8 *) cbPtr->outHD;\r
652             byteSize = (cbPtr->blockSize>>3);\r
653 \r
654             if ( bytePtr1[byteSize-1] == 0 )\r
655             {\r
656                 bytePtr2[byteSize-1] = 0xde;\r
657             }\r
658         }\r
659 \r
660 \r
661         /* Enqueue the Code block */\r
662         tcp3dResultSend = Tcp3d_enqueueCodeBlock ( inst,\r
663                                                     cbPtr->blockSize,\r
664                                                     (UInt32 *)L2GLBMAP(dspCoreID, cbPtr->inCfg),\r
665                                                     (Int8 *)L2GLBMAP(dspCoreID, cbPtr->inLLR),\r
666                                                     cbPtr->llrOffset,\r
667                                                     (UInt32 *)L2GLBMAP(dspCoreID, cbPtr->outHD),\r
668                                                     (Int8 *)L2GLBMAP(dspCoreID, cbPtr->outSD), \r
669                                                     cbPtr->sdOffset,\r
670                                                     (UInt32 *)L2GLBMAP(dspCoreID, cbPtr->outSts),\r
671                                                     notifyFlag); // 1 - GEN EVENT, 0 - NO EVENT\r
672 \r
673 \r
674         /* Check for soldout case */\r
675         if ( TCP3D_DRV_INPUT_LIST_FULL != tcp3dResultSend )\r
676         {\r
677             /* increment the block count */\r
678             sendBlockCnt++;\r
679 \r
680             /* goto next block */\r
681             Semaphore_post(semSendBlock);\r
682         }\r
683         else\r
684         {\r
685             /* increment soldout count */\r
686             soldoutCntr++;\r
687 \r
688             soldOutAction(); /* take action */\r
689         }\r
690 \r
691         /* Start the driver after START_CMD_PERIOD blocks */\r
692         if ( sendBlockCnt == START_CMD_PERIOD )\r
693         {\r
694             if ( TCP3D_DRV_NO_ERR != Tcp3d_start(inst, TCP3D_DRV_START_AUTO) )\r
695             {\r
696                 System_printf("Tcp3d_start function returned error (AUTO)\n");\r
697                 System_exit(0);\r
698             }\r
699         }\r
700 \r
701         /* Check for end of task and exit */\r
702         if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
703         {\r
704             /* set flags first */\r
705             pauseIntFlag = 0;\r
706             l2pIntr = pauseIntr;\r
707             pendPauseCntr = 0;\r
708 \r
709 #if SOLDOUT_USE_L2P_INTERRUPT\r
710             if ( soldoutCntr )\r
711             {\r
712                 /* Call TCP3D driver control to set interrupt on L2P channel */\r
713                 drvCtrl.cmd = TCP3D_DRV_SET_L2P_INT;\r
714                 drvCtrl.intrFlag = TEST_INTR_DISABLE;   // disable\r
715                 Tcp3d_control(inst, &drvCtrl);\r
716             }\r
717 #endif\r
718 \r
719             /* Set interrupt flag PAUSE channel */\r
720             drvCtrl.cmd = TCP3D_DRV_CLR_REVT_INT;\r
721             Tcp3d_control(inst, &drvCtrl);\r
722 \r
723             /* Check to see if restart needed before exit */\r
724             if ( TCP3D_DRV_NO_ERR != Tcp3d_start(inst, TCP3D_DRV_START_AUTO) )\r
725             {\r
726                 System_printf("Tcp3d_start function returned error (AUTO)\n");\r
727                 System_exit(0);\r
728             }\r
729             \r
730             /* Set interrupt flag PAUSE channel */\r
731             drvCtrl.cmd = TCP3D_DRV_SET_REVT_INT;\r
732             drvCtrl.intrFlag = TEST_INTR_ENABLE;   // enable\r
733             Tcp3d_control(inst, &drvCtrl);\r
734 \r
735             /* out of enqueue loop */\r
736             break;\r
737         }\r
738     } /* end of - while(1) */\r
739 \r
740 #if DEBUG_VARS\r
741     semCnt = Semaphore_getCount(semSendWait);\r
742 #endif\r
743 \r
744     /**\r
745      * Check for pending Pauses and waiting for the last block to be decoded \r
746      */\r
747     while ( 1 )\r
748     {\r
749         /* Pending on Semaphore to run the loop */\r
750         Semaphore_pend(semSendWait, BIOS_WAIT_FOREVER);\r
751 \r
752         /* Received both the completion events, so exit send task */\r
753         if ( tcp3dEventCntr >= 2 )\r
754         {\r
755             break;\r
756         } else if ( tcp3dEventCntr == 1 )\r
757         {\r
758             /* one code block test case */\r
759             if ( codeBlockSet.maxNumCB == 1 )\r
760             {\r
761                 break;\r
762             }\r
763             else if ( codeBlockSet.mode == TEST_MODE_SPLIT )\r
764             { /* missing one notificatin event - possible in split mode */\r
765                 /**\r
766                 * WORKAROUND CODE:\r
767                 * This is possibility in case of SPLIT mode, that one event is\r
768                 * lost when both ping and pong channels try to generate system\r
769                 * events at close proximity.\r
770                 * In this test bench we have enabled notification events for\r
771                 * the last two blocks, so checking the outHD & refHD last bytes\r
772                 * to confirm the decoding of these blocks are completed.\r
773                 */\r
774                 \r
775                 /* cbPtr for last two code blocks */\r
776                 cbDataDesc  *cbPtr1 = codeBlockSet.cbData[codeBlockSet.maxNumCB-2];\r
777                 cbDataDesc  *cbPtr2 = codeBlockSet.cbData[codeBlockSet.maxNumCB-1];\r
778                 uint8_t     *bytePtr11, *bytePtr12, *bytePtr21, *bytePtr22;\r
779                 uint32_t    size1, size2;\r
780 \r
781                 bytePtr11 = (UInt8 *) cbPtr1->refHD;\r
782                 bytePtr12 = (UInt8 *) cbPtr1->outHD;\r
783                 bytePtr21 = (UInt8 *) cbPtr2->refHD;\r
784                 bytePtr22 = (UInt8 *) cbPtr2->outHD;\r
785                 size1 = (cbPtr1->blockSize>>3); /* in bytes */\r
786                 size2 = (cbPtr2->blockSize>>3); /* in bytes */\r
787 \r
788                 /* check if last HD byte of last two blocks are completed */\r
789                 if ((bytePtr11[size1-1] == bytePtr12[size1-1]) &&\r
790                     (bytePtr21[size2-1] == bytePtr22[size2-1]) ) \r
791                 {\r
792                     System_printf("Notification event missed (Race Condition)\n");\r
793                     System_printf("Since the last two block decoding completed, completing send task\n");\r
794                     System_printf("Block : %d\n", codeBlockSet.maxNumCB-2);\r
795                     System_printf("\trefHD[%d] = 0x%x\t outHD[%d] = 0x%x\n", size1-1, bytePtr11[size1-1], size1-1, bytePtr12[size1-1]);\r
796                     System_printf("Block : %d\n", codeBlockSet.maxNumCB-1);\r
797                     System_printf("\trefHD[%d] = 0x%x\t outHD[%d] = 0x%x\n", size2-1, bytePtr21[size2-1], size2-1, bytePtr22[size2-1]);\r
798                     break;\r
799                 }\r
800             }\r
801         }\r
802 \r
803         if ( TCP3D_DRV_NO_ERR != Tcp3d_start(inst, TCP3D_DRV_START_AUTO) )\r
804         {\r
805             System_printf("Tcp3d_start function returned error\n");\r
806             System_exit(0);\r
807         }\r
808 \r
809         /* keep trying until finding two end events */\r
810         Semaphore_post(semSendWait);\r
811 \r
812         pendPauseCntr++;\r
813     }\r
814 \r
815     /* Last code block decoded - Start the receive task */\r
816     total_clock_end = TSCL;\r
817     Semaphore_post(semRcvStart);\r
818 }\r
819 \r
820 /*******************************************************************************\r
821  ******************************************************************************/\r
822 Void rcvBlockTaskFunc(Void)\r
823 {\r
824     Int32           errCnt;\r
825 \r
826     cbDataDesc       *cbPtr;\r
827     Int             idx, loopCnt;\r
828     Int             fail = 0;\r
829     UInt8           *ptr1, *ptr2;\r
830    \r
831     rcvBlockCnt = 0;\r
832     totErrCnt = 0;\r
833 \r
834     while(1)\r
835     {\r
836         Semaphore_pend(semRcvStart, BIOS_WAIT_FOREVER);\r
837 \r
838         /* prints for send task are done here */\r
839         if ( tcp3dResultSend == TCP3D_DRV_NO_ERR )\r
840         {\r
841 #if DEBUG_PRINT\r
842             for ( loopCnt = 0; loopCnt < sendBlockCnt; loopCnt++ )\r
843             {\r
844                 cbPtr   = codeBlockSet.cbData[loopCnt];\r
845                 System_printf("Send Task: Enqueued Block %d (Size: %d, SW0: %d)\n",\r
846                                     loopCnt, cbPtr->blockSize,\r
847                                     cbPtr->sw0LengthUsed);\r
848             }\r
849 #endif\r
850             System_printf("Send Task: Enqueued %d Blocks\n\n", sendBlockCnt);\r
851         }\r
852         else\r
853         {\r
854             System_printf("Send Task: Enqueued Blocks failed (tcp3dResultSend : %d)\n\n", tcp3dResultSend);\r
855             System_exit(0);\r
856         }\r
857 \r
858         MY_LOG_PRINT0(Rcv Task: SEM RECEIVED);\r
859 \r
860         while( rcvBlockCnt < codeBlockSet.maxNumCB )\r
861         {\r
862             /* Get the pointer to the Code Block Set */\r
863             cbPtr   = codeBlockSet.cbData[rcvBlockCnt];\r
864  \r
865             /* Step 2: Verify All the outputs */\r
866             fail = 0;\r
867             /* Step 2.1: Hard Decisions Verification */\r
868             ptr1 = (UInt8 *) cbPtr->refHD;\r
869             ptr2 = (UInt8 *) cbPtr->outHD;\r
870 \r
871                 /* Invalidate out HD */\r
872             CACHE_invL1d (cbPtr->outHD, cbPtr->blockSize>>3, CACHE_WAIT);\r
873 \r
874             errCnt = 0;    \r
875             for (idx = 0; idx < (cbPtr->blockSize>>3); ++idx)\r
876             {\r
877                 if ( ptr1[idx] != ptr2[idx] )\r
878                 {\r
879                     errCnt++;\r
880                     System_printf("\tBlock Count %d, HD mismatch byte %d\n", rcvBlockCnt, idx);\r
881                 }\r
882             }\r
883 \r
884             if (errCnt)\r
885             {\r
886                 MY_LOG_PRINT2(Rcv task: HD FAILED, rcvBlockCnt, ERRORS:, errCnt);\r
887                 fail++;\r
888             }\r
889             else\r
890             {\r
891                 MY_LOG_PRINT1(Rcv task: HD PASSED, rcvBlockCnt);\r
892             }\r
893     \r
894             /* Step 2.2: Soft Decisions Verification */\r
895             if (cbPtr->sdFlag)\r
896             {\r
897                 if ( codeBlockSet.mode == TEST_MODE_SPLIT ) /* SPLIT MODE */\r
898                     loopCnt = cbPtr->blockSize;\r
899                 else\r
900                     loopCnt = (3*cbPtr->blockSize);\r
901    \r
902                 /* Invalidate out SD */\r
903                 CACHE_invL1d (cbPtr->outSD, loopCnt, CACHE_WAIT);\r
904 \r
905                 /* NOTE: Assumed that the Soft Decisions are in a single array */\r
906                 errCnt = 0;\r
907                 for (idx = 0; idx < loopCnt; ++idx)\r
908                 {\r
909                     if ( cbPtr->refSD[idx] != cbPtr->outSD[idx] )\r
910                     {\r
911                         errCnt += 1;\r
912                         System_printf("\tBlock Count %d, SD mismatch byte %d\n", rcvBlockCnt, idx);\r
913                     }\r
914                 }\r
915     \r
916                 if (errCnt)\r
917                 {\r
918                     MY_LOG_PRINT2(Rcv task: SD FAILED, rcvBlockCnt, ERRORS:, errCnt);\r
919                     fail++;\r
920                 }\r
921                 else\r
922                 {\r
923                     MY_LOG_PRINT1(Rcv task: SD PASSED, rcvBlockCnt);\r
924                 }\r
925             } /* if (cbPtr->sdFlag) */\r
926     \r
927             /* Step 2.3: errCnt Registers Verification */\r
928             if (cbPtr->stsFlag)\r
929             {\r
930                 /* Invalidate out Sts */\r
931                 CACHE_invL1d (cbPtr->outSts, 12, CACHE_WAIT);\r
932 \r
933                 errCnt = 0;\r
934                 for (idx = 0; idx < 3; ++idx)\r
935                 {\r
936                     if ( cbPtr->refSts[idx] != cbPtr->outSts[idx] )\r
937                     {\r
938                         errCnt += 1;\r
939                         System_printf("\tBlock Count %d, STS mismatch word %d\n", rcvBlockCnt, idx);\r
940                     }\r
941                 }\r
942                 if (errCnt)\r
943                 {\r
944                     MY_LOG_PRINT2(Rcv task: STS FAILED, rcvBlockCnt, ERRORS:, errCnt);\r
945                     fail++;\r
946                 }\r
947                 else\r
948                 {\r
949                     MY_LOG_PRINT1(Rcv task: STS PASSED, rcvBlockCnt);\r
950                 }\r
951             } /* if (cbPtr->stsFlag) */\r
952             if (fail)\r
953             {\r
954                 System_printf("Rcv task: Block %d FAILED\n", rcvBlockCnt);\r
955                 totErrCnt++;\r
956             }\r
957 #if DEBUG_PRINT\r
958             else\r
959             {\r
960                 System_printf("Rcv task: Block %d PASSED\n", rcvBlockCnt);\r
961             }\r
962 #endif\r
963             rcvBlockCnt++;\r
964         }\r
965         if(rcvBlockCnt >= codeBlockSet.maxNumCB)\r
966         {\r
967             break;\r
968         }   \r
969     }\r
970 \r
971     System_printf("Rcv Task: COMPLETE - verified %d blocks\n", rcvBlockCnt);\r
972     \r
973     /* Prepare for next test, set by "tester task" */\r
974     Semaphore_post(semRcvDone);\r
975 }\r
976 \r
977 /*******************************************************************************\r
978  ******************************************************************************/\r
979 Void revt0ChCallback(Void)\r
980 {\r
981     /* Increment the ISR counter */\r
982     pauseIntr++;\r
983     \r
984     pauseIntFlag = 1;\r
985 \r
986     if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
987         Semaphore_post(semSendWait);\r
988     else\r
989         Semaphore_post(semSendBlock);\r
990 }\r
991 \r
992 /*******************************************************************************\r
993  ******************************************************************************/\r
994 Void revt1ChCallback(Void)\r
995 {\r
996     /* Increment the ISR counter */\r
997     pauseIntr++;\r
998     \r
999     pauseIntFlag = 2;\r
1000 \r
1001     if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
1002         Semaphore_post(semSendWait);\r
1003     else\r
1004         Semaphore_post(semSendBlock);\r
1005 }\r
1006 \r
1007 /*******************************************************************************\r
1008  ******************************************************************************/\r
1009 Void tskHeartBeat(Void)\r
1010 {\r
1011     static unsigned int counter = 0u;\r
1012 \r
1013     while (counter < 0x1000000u)\r
1014     {\r
1015         Task_sleep (1000u);\r
1016         System_printf("\n!!! EDMA3 LLD HrtBt %x\n", counter);\r
1017         counter++;\r
1018     }\r
1019 }\r
1020 \r
1021 /*******************************************************************************\r
1022  ******************************************************************************/\r
1023 Void getMemoryStats(Void)\r
1024 {\r
1025     Memory_Stats        memStats;\r
1026 \r
1027     Memory_getStats(drvHeap, &memStats);\r
1028     System_printf("\nHeap Usage/Status\n");\r
1029     System_printf("    tcp3dDrvHeap : %d of %d free\n", memStats.totalFreeSize, memStats.totalSize);\r
1030 \r
1031     Memory_getStats(dataHeap, &memStats);\r
1032     System_printf("    tcp3dDataHeap : %d of %d free\n", memStats.totalFreeSize, memStats.totalSize);\r
1033 }\r
1034 \r
1035 /*******************************************************************************\r
1036  ******************************************************************************/\r
1037 Void tcp3dEventISR(UInt32 testEvtNum)\r
1038 {\r
1039     tcp3dEventCntr++;\r
1040     tpccEvtCntr++;\r
1041 \r
1042     if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
1043         Semaphore_post(semSendWait);\r
1044     else\r
1045         Semaphore_post(semSendBlock);\r
1046 }\r
1047 \r
1048 /*******************************************************************************\r
1049  ******************************************************************************/\r
1050 Void registerTcp3dEvent(Void)\r
1051 {\r
1052     static  UInt32 cookie = 0;\r
1053     Int     eventId = 0;    /* GEM event id */\r
1054     static  UInt32 mapDone = 0;\r
1055     UInt32  testEvt = getNotifyEventNum(instNum);\r
1056     UInt32  hostIntr = getHostIntrNum(dspCoreID);\r
1057 \r
1058     /* Disabling the global interrupts */\r
1059     cookie = Hwi_disable();\r
1060 \r
1061     /* Completion ISR Registration */\r
1062     CpIntc_dispatchPlug(testEvt, tcp3dEventISR, hostIntr, TRUE);\r
1063     if (!mapDone)\r
1064         CpIntc_mapSysIntToHostInt(0, testEvt, hostIntr);\r
1065     CpIntc_enableHostInt(0, hostIntr);\r
1066     eventId = CpIntc_getEventId(hostIntr);\r
1067     EventCombiner_dispatchPlug (eventId,\r
1068 #if USE_LOCAL_CPINTC_DISPATCH\r
1069                                 CpIntc_dispatchLoc,\r
1070 #else\r
1071                                 CpIntc_dispatch,\r
1072 #endif\r
1073                                 hostIntr,\r
1074                                 TRUE);\r
1075 #if DEBUG_PRINT\r
1076     System_printf("\t\t testEvt : %d \n", testEvt);\r
1077     System_printf("\t\t hostIntr : %d \n", hostIntr);\r
1078     System_printf("\t\t eventId : %d \n", eventId);\r
1079 #endif\r
1080 \r
1081     /* enable the 'global' switch */\r
1082     CpIntc_enableAllHostInts(0);\r
1083 \r
1084     mapDone = 1;\r
1085 \r
1086     /* Restore interrupts */\r
1087     Hwi_restore(cookie);\r
1088 }\r
1089 \r
1090 /*******************************************************************************\r
1091  ******************************************************************************/\r
1092 Void unregisterTcp3dEvent(Void)\r
1093 {\r
1094     static UInt32 cookie = 0;\r
1095     Int eventId = 0;    /* GEM event id */\r
1096     UInt32  hostIntr = getHostIntrNum(dspCoreID);\r
1097     \r
1098     /* Disabling the global interrupts */\r
1099     cookie = Hwi_disable();\r
1100 \r
1101     /* Driver Completion ISR */\r
1102     CpIntc_disableHostInt(0, hostIntr);\r
1103     eventId = CpIntc_getEventId(hostIntr);\r
1104     EventCombiner_disableEvent(eventId);\r
1105 \r
1106     /* Restore interrupts */\r
1107     Hwi_restore(cookie);\r
1108 }\r
1109 \r
1110 /*******************************************************************************\r
1111  ******************************************************************************/\r
1112 Void allInit(Void)\r
1113 {\r
1114     Tcp3d_Result        tcp3dResult = TCP3D_DRV_NO_ERR;\r
1115     EDMA3_DRV_Result    edmaResult = EDMA3_DRV_SOK;\r
1116 \r
1117     /* Initialize EDMA3 first */\r
1118     hEdma = NULL;\r
1119     tpccNum = 2;\r
1120     tpccRegionUsed = 3;\r
1121     hEdma = edma3init ( tpccNum,\r
1122                         &edmaResult,\r
1123                         dspCoreID,\r
1124                         tpccRegionUsed);\r
1125     if (edmaResult != EDMA3_DRV_SOK)\r
1126     {\r
1127         System_printf("edma3init() FAILED, error code: %d\n", edmaResult);\r
1128     }\r
1129     else\r
1130     {\r
1131         System_printf("EDMA3 LLD Initialization complete (TPCC #%d, Region #%d)\n", tpccNum, tpccRegionUsed);\r
1132     }\r
1133 \r
1134     /* Allocate all EDMA channels required for TCP3D Driver */\r
1135     System_printf("EDMA3 Channels opening started...\n");\r
1136 \r
1137     /* Open channels for one instance */\r
1138     openEdmaChannels (hEdma, instNum, &edmaConfig[instNum]);\r
1139 \r
1140     /* Register call backs */\r
1141     EDMA3_DRV_registerTccCb(hEdma, edmaConfig[instNum].pingChRes[0].chNo, (EDMA3_RM_TccCallback)&revt0ChCallback, NULL);\r
1142     EDMA3_DRV_registerTccCb(hEdma, edmaConfig[instNum].pongChRes[0].chNo, (EDMA3_RM_TccCallback)&revt1ChCallback, NULL);\r
1143 \r
1144 #if EDMA_LOCAL_COMP_ISR // flag defined in sample.h file\r
1145     /* Fill call back details */\r
1146     edmaConfig[instNum].pingChRes[0].cbFunc  = (EDMA3_RM_TccCallback)&revt0ChCallback;\r
1147     edmaConfig[instNum].pingChRes[0].cbData  = NULL;\r
1148     edmaConfig[instNum].pongChRes[0].cbFunc  = (EDMA3_RM_TccCallback)&revt1ChCallback;\r
1149     edmaConfig[instNum].pongChRes[0].cbData  = NULL;\r
1150 \r
1151     /**\r
1152      * Update the information to use with local EDMA ISR \r
1153      * (NOTE: This function must be called after the channels are opened)\r
1154      */\r
1155     updateAllocatedTccsLoc(&edmaConfig[instNum]);\r
1156 #endif\r
1157 \r
1158     System_printf("EDMA3 Channels opening complete\n");\r
1159 \r
1160     System_printf("TCP3 Decoder Driver Initialization sequence started...\n");\r
1161 \r
1162     /* Initialize the TCP3D first */\r
1163     tcp3dDrvInst[instNum] = tcp3dSampleInit (drvHeap,\r
1164                                     instNum,\r
1165                                     testMaxCodeBlocks,\r
1166                                     codeBlockSet.mode,\r
1167                                     codeBlockSet.doubleBuffer,\r
1168                                     codeBlockSet.lteCrcSel,\r
1169                                     dspCoreID,\r
1170                                     hEdma,\r
1171                                     tpccRegionUsed,\r
1172                                     &edmaConfig[instNum],\r
1173                                     &tcp3dResult);\r
1174 \r
1175     System_printf("TCP3 Decoder Driver Initialization sequence complete\n");\r
1176 \r
1177     /* Register the Notification Event for TCP3D */\r
1178     registerTcp3dEvent();\r
1179 \r
1180     /* Set the global flags to default values */\r
1181     pingComplete = 0;\r
1182     pongComplete = 0;\r
1183     pauseIntr = 0;\r
1184     l2pIntr = 0;\r
1185     tcp3dEventCntr = 0;\r
1186     pauseIntFlag = 0;\r
1187     rcvStartFlag = 0;\r
1188     soldoutCntr = 0;\r
1189     afterIntrSoldout = 0;\r
1190     afterIntrPause = 0;\r
1191     pendPauseCntr = 0;\r
1192 }\r
1193 \r
1194 /*******************************************************************************\r
1195  ******************************************************************************/\r
1196 Void allDeInit(Void)\r
1197 {\r
1198     EDMA3_DRV_Result    edmaResult = EDMA3_DRV_SOK;\r
1199 \r
1200     /* Un-register the Notification Event for TCP3D */\r
1201     unregisterTcp3dEvent();\r
1202 \r
1203     /* Close all EDMA channels allocated for the test */\r
1204     System_printf("EDMA3 Channels freeing started...\n");\r
1205 \r
1206     /* Register call backs */\r
1207     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pingChRes[0].chNo);\r
1208     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pingChRes[1].chNo);\r
1209     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pongChRes[0].chNo);\r
1210     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pongChRes[1].chNo);\r
1211 \r
1212     /* Close channels */\r
1213     closeEdmaChannels(hEdma, instNum, &edmaConfig[instNum]);\r
1214 \r
1215     System_printf("EDMA3 Channels freeing complete\n");\r
1216 \r
1217     /* Deinit for TCP3D driver */\r
1218     System_printf("TCP3 Decoder Driver De-Initialization sequence started...\n");\r
1219 \r
1220     tcp3dSampleDeinit(drvHeap, instNum, tcp3dDrvInst[instNum]);\r
1221 \r
1222     System_printf("TCP3 Decoder Driver De-Initialization sequence complete\n");\r
1223 \r
1224     /* De-init EDMA3 */\r
1225     edmaResult = edma3deinit(tpccNum, hEdma);\r
1226     if (edmaResult != EDMA3_DRV_SOK)\r
1227     {\r
1228         System_printf("edma3deinit() FAILED, error code: %d\n", edmaResult);\r
1229     }\r
1230     else\r
1231     {\r
1232         System_printf("EDMA3 LLD De-Initialization complete\n");\r
1233     }\r
1234 }\r
1235 \r
1236 /**\r
1237  *  @b Description\r
1238  *  @n  \r
1239  *      This function enables the power/clock domains for TCP3D. \r
1240  *\r
1241  *  @retval\r
1242  *      Not Applicable.\r
1243  */\r
1244 static Int32 enable_tcp3d (void)\r
1245 {\r
1246 #ifndef SIMULATOR_SUPPORT\r
1247     /* TCP3D power domain is turned OFF by default.\r
1248      * It needs to be turned on before doing any TCP3D device register access.\r
1249      * This is not required for the simulator. */\r
1250 \r
1251     /* Set TCP3D Power domain to ON */        \r
1252     CSL_PSC_enablePowerDomain (TEST_CSL_PSC_PD_TCP3D);\r
1253 \r
1254     /* Enable the clocks too for TCP3D */\r
1255     CSL_PSC_setModuleNextState (TEST_CSL_PSC_LPSC_TCP3D, PSC_MODSTATE_ENABLE);\r
1256 \r
1257     /* Start the state transition */\r
1258     CSL_PSC_startStateTransition (TEST_CSL_PSC_PD_TCP3D);\r
1259 \r
1260     /* Wait until the state transition process is completed. */\r
1261     while (!CSL_PSC_isStateTransitionDone (TEST_CSL_PSC_PD_TCP3D));\r
1262 \r
1263     /* Return TCP3D PSC status */\r
1264     if ((CSL_PSC_getPowerDomainState(TEST_CSL_PSC_PD_TCP3D) == PSC_PDSTATE_ON) &&\r
1265         (CSL_PSC_getModuleState (TEST_CSL_PSC_LPSC_TCP3D) == PSC_MODSTATE_ENABLE))\r
1266     {\r
1267         /* TCP3D ON. Ready for use */            \r
1268         return 0;\r
1269     }\r
1270     else\r
1271     {\r
1272         /* TCP3D Power on failed. Return error */            \r
1273         return -1;            \r
1274     }\r
1275 #else\r
1276     /* PSC is not supported on simulator. Return success always */\r
1277     return 0;\r
1278 #endif\r
1279 }\r
1280 \r
1281 /**\r
1282  *  @b Description\r
1283  *  @n  \r
1284  *      The function is used to indicate that a block of memory is \r
1285  *      about to be accessed. If the memory block is cached then this \r
1286  *      indicates that the application would need to ensure that the \r
1287  *      cache is updated with the data from the actual memory.\r
1288  *\r
1289  *  @param[in]  ptr\r
1290  *       Address of memory block\r
1291  *\r
1292  *  @param[in]  size\r
1293  *       Size of memory block\r
1294  *\r
1295  *  @retval\r
1296  *      Not Applicable\r
1297  */\r
1298 void tcp3dBeginMemAccess (void *ptr, uint32_t size)\r
1299 {\r
1300     /* Invalidate L1D cache and wait until operation is complete. \r
1301      * Use this approach if L2 cache is not enabled */    \r
1302     CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT);\r
1303 \r
1304     /*  Cleanup the prefectch buffer also. */\r
1305     CSL_XMC_invalidatePrefetchBuffer();    \r
1306 \r
1307     return;\r
1308 }\r
1309 \r
1310 /**\r
1311  *  @b Description\r
1312  *  @n  \r
1313  *      The function is used to indicate that the block of memory has \r
1314  *      finished being accessed. If the memory block is cached then the \r
1315  *      application would need to ensure that the contents of the cache \r
1316  *      are updated immediately to the actual memory. \r
1317  *\r
1318  *  @param[in]  ptr\r
1319  *       Address of memory block\r
1320  *  @param[in]  size\r
1321  *       Size of memory block\r
1322  *\r
1323  *  @retval\r
1324  *      Not Applicable\r
1325  */\r
1326 void tcp3dEndMemAccess (void *ptr, uint32_t size)\r
1327 {\r
1328     /* Writeback L1D cache and wait until operation is complete. \r
1329      * Use this approach if L2 cache is not enabled */    \r
1330     CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);        \r
1331 \r
1332     return;\r
1333 }\r
1334 \r
1335 /* end of file */\r