c2be5448b0fc9ba22a8002d69297bdc07b160232
[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_0(0)","TCP3D_1(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     instNum = getTcp3dInstNum(dspCoreID);\r
364 \r
365     /* Initialize the default Task parameters */\r
366     Task_Params_init(&taskParams);\r
367 \r
368     /* Initialize the default Semaphore parameters */\r
369     Semaphore_Params_init(&semParams);\r
370 \r
371     /* Crete the Binary Semaphore */\r
372     semParams.mode = Semaphore_Mode_BINARY;\r
373     semRcvDone = Semaphore_create(0, &semParams, NULL);\r
374 \r
375     /* Get the Heap handles - used when ever memory allocations are needed */\r
376     //dataHeap = HeapMem_Handle_upCast(tcp3dDataHeap);\r
377     dataHeap = (IHeap_Handle) SharedRegion_getHeap(0);\r
378     drvHeap = HeapMem_Handle_upCast(tcp3dDrvHeap);\r
379 \r
380     while( testCntr < numTests )\r
381     {\r
382 \r
383         /**\r
384          * Create the Binary semaphores each time using the parameters set\r
385          * outside the tester while loop.\r
386          * \r
387          * It was observed that at times the receive semaphore count was\r
388          * non-zero after the first run and receive task was getting triggered\r
389          * before posting from the ISR callback. So, the semaphores are created\r
390          * for each test to work-around with the problem. \r
391          */\r
392         semSendBlock = Semaphore_create(0, &semParams, NULL);\r
393         semSendWait = Semaphore_create(0, &semParams, NULL);\r
394         semRcvStart = Semaphore_create(0, &semParams, NULL);\r
395 #if DEBUG_VARS\r
396         semCnt = Semaphore_getCount(semRcvStart);\r
397 #endif\r
398 \r
399         /**\r
400          * Create the send and receive tasks for each test using the default\r
401          * tak parameters.\r
402          * \r
403          * NOTE: No need to do the Task_delete() as these tasks have exits.\r
404          */\r
405         Task_create((Task_FuncPtr)sndBlockTaskFunc, &taskParams, NULL);\r
406         Task_create((Task_FuncPtr)rcvBlockTaskFunc, &taskParams, NULL);\r
407 \r
408         System_printf("\n******************************************************************\n");\r
409         System_printf("\n----- TEST #%d STARTED ------\n", testCntr);\r
410 \r
411         /**\r
412          * Prepare data for Code Blocks processing (reading test vector files).\r
413          * Allocates Memory as needed from the tcp3dDataHeap\r
414          */\r
415         if ( firstTime )\r
416         {\r
417             System_printf("\nReading test vector files started (including memory allocation)...\n");\r
418             strcpy(folderName, testvectFolderBase);\r
419             strcat(folderName, testFolder[testCntr]);\r
420             getTestSetCB(dataHeap, &codeBlockSet, folderName);\r
421             System_printf("Reading test vector files complete\n");\r
422 #if DEBUG_PRINT\r
423             System_printf("\tPrepared %d code blocks in %s mode\n", codeBlockSet.maxNumCB, strMode[codeBlockSet.mode]);\r
424 #endif\r
425             firstTime = 0;\r
426         }\r
427         else\r
428         {\r
429             System_printf("\nUsing the test vectors read before\n");\r
430         }\r
431 \r
432         System_printf("\n----- TEST INITIALIZATION STARTED -----\n\n");\r
433         allInit();\r
434         getMemoryStats(); /* Heap Stats */\r
435         System_printf("\n----- TEST INITIALIZATION COMPLETE -----\n\n");\r
436 \r
437 #if TEST_PREPARE_ONLY_BETASTATE\r
438         for (i = 0; i < codeBlockSet.maxNumCB ;i++)\r
439         {\r
440             /* Prepare fixed IC registers using the inCfgParams of first block*/\r
441             Tcp3d_prepFixedConfigRegs(codeBlockSet.cbData[i]->inCfgParams, codeBlockSet.cbData[i]->inCfg);\r
442 \r
443             /* Prepare block size dependent params */\r
444             prepareBlockSizeDepICParams(codeBlockSet.cbData[i]);\r
445         }\r
446 #elif TEST_PREPARE_ONLY_CODEBLOCK_PARAM_DEPENDENT\r
447         /* Prepare fixed IC registers using the inCfgParams of first block*/\r
448         Tcp3d_prepFixedConfigRegs(codeBlockSet.cbData[0]->inCfgParams, tempICRegs);\r
449 #endif\r
450 \r
451         /* Start the Send task first */\r
452         Semaphore_post(semSendBlock);\r
453 \r
454         /* Wait for the Receive task to complete */\r
455         Semaphore_pend(semRcvDone, BIOS_WAIT_FOREVER);\r
456 \r
457         /**\r
458          * Test Profile Calculations\r
459          * \r
460          *                              (Total Bits)\r
461          * Throughput (Mbps) = -----------------------------\r
462          *                      (Total Time)*(10^-9)*(10^6)\r
463          * \r
464          */\r
465         TotalBitsDecoded = 0;\r
466         for (i = 0; i < codeBlockSet.maxNumCB; ++i)\r
467         {\r
468             TotalBitsDecoded += codeBlockSet.cbData[i]->blockSize;\r
469         }\r
470 \r
471         test_cycles = (total_clock_end - total_clock_start);\r
472         ThroughPut = TotalBitsDecoded*1.0;\r
473         ThroughPut = (ThroughPut/test_cycles)*1000;\r
474 \r
475         /******** Free code blocks ********/\r
476         if ( keepTestVectMem )\r
477         {\r
478             System_printf("\nNo freeing - Using the test vectors read before\n");\r
479         }\r
480         else\r
481         {\r
482             System_printf("\nTest vectors memory freeing started...\n");\r
483             freeTestSetCB(dataHeap, &codeBlockSet);\r
484             System_printf("Test vectors memory freeing complete\n");\r
485 #if DEBUG_PRINT\r
486             System_printf("\tFreed memory allocated for %d code blocks in %s mode\n", codeBlockSet.maxNumCB, strMode[codeBlockSet.mode]);\r
487 #endif\r
488             firstTime = 1;\r
489         }\r
490 \r
491         System_printf("\n----- TEST DE-INITIALIZATION STARTED -----\n\n");\r
492         allDeInit();\r
493         getMemoryStats(); /* Heap Stats */\r
494         System_printf("\n----- TEST DE-INITIALIZATION COMPLETE -----\n");\r
495     \r
496         if ( totErrCnt > 0 )\r
497         {\r
498             System_printf("\n----- TEST #%d FAILED -----\n", testCntr);\r
499             testErrCntr++;\r
500         }\r
501         else\r
502         {\r
503             System_printf("\n----- TEST #%d PASSED -----\n", testCntr);\r
504         }\r
505         System_printf("\n+++++++++++++++++++++++ TEST #%d SUMMARY +++++++++++++++++++++++++\n", testCntr);\r
506         System_printf("TCP3D Peripheral Configuration\n");\r
507         System_printf("    Instance                     : %s\n", strInst[instNum]);\r
508         System_printf("    Mode Tested                  : %s\n", strMode[codeBlockSet.mode]);\r
509         System_printf("    Double Buffer Mode           : %s\n", strDBuf[codeBlockSet.doubleBuffer]);\r
510         System_printf("Max code blocks (Input Capacity) : %d\n", testMaxCodeBlocks);\r
511         System_printf("Code blocks sent for decoding    : %d\n", codeBlockSet.maxNumCB);\r
512         System_printf("Call back counters               : %d - interrupts\n", pauseIntr);\r
513         System_printf("                          (%d-SOLDOUT, %d-PAUSE, %d-PENDPAUSE)\n", afterIntrSoldout, afterIntrPause, pendPauseCntr);\r
514         System_printf("Total Notification Interrupts    : %d\n", tcp3dEventCntr);\r
515         System_printf("Throughput Calculations\n");\r
516         System_printf("    Total Bits Decoded           : %d\n", TotalBitsDecoded);\r
517         System_printf("    Time Taken (in cycles)       : %d\n", test_cycles);\r
518         System_printf("    Effective Throughput         : %f Mbps\n", ThroughPut);\r
519         System_printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");\r
520 \r
521         System_printf("\n******************************************************************\n");\r
522 \r
523         /* Increment the test counter */\r
524         testCntr++;\r
525 \r
526         /**\r
527          * Delete the semaphores each time, so that there is no left over count.\r
528          * See the explanation at the beginning of this loop where the create\r
529          * semaphore calls are present. \r
530          */\r
531 #if DEBUG_VARS\r
532         semCnt = Semaphore_getCount(semRcvStart);\r
533 #endif\r
534         Semaphore_delete(&semSendWait);\r
535         Semaphore_delete(&semSendBlock);\r
536         Semaphore_delete(&semRcvStart);\r
537     }\r
538 \r
539     /* All test status print */\r
540     if(testErrCntr)\r
541     {\r
542         System_printf("!!! SOME TESTS FAILED !!!\n");\r
543     }\r
544     else\r
545     {\r
546         System_printf("!!! ALL TESTS PASSED !!!\n");\r
547     }\r
548 \r
549     /* Remove all creations - to make graceful system exit */\r
550     Semaphore_delete(&semRcvDone);\r
551 \r
552     System_exit(0);\r
553 }\r
554    \r
555 /*******************************************************************************\r
556  ******************************************************************************/\r
557 Void sndBlockTaskFunc(Void)\r
558 {\r
559     UInt8               notifyFlag;\r
560     cbDataDesc          *cbPtr;\r
561     static UInt32       cookie = 0;\r
562 \r
563     sendBlockCnt = 0;\r
564 \r
565 #if DEBUG_VARS\r
566         semCnt = Semaphore_getCount(semSendBlock);\r
567 #endif\r
568 \r
569     total_clock_start = TSCL;\r
570 \r
571     while(1)\r
572     {\r
573         /* Pending on Semaphore to run the loop */\r
574         Semaphore_pend(semSendBlock, BIOS_WAIT_FOREVER);\r
575 \r
576         /* set TCP3D instance to use */\r
577         inst = tcp3dDrvInst[instNum];\r
578 \r
579         /* Get pointer to the code block data structure */\r
580         cbPtr = codeBlockSet.cbData[sendBlockCnt];\r
581 \r
582         /* Interrupt flag, used in Tcp3d_enqueueCodeBlock function */\r
583         notifyFlag = 0;\r
584         if ( sendBlockCnt >= (codeBlockSet.maxNumCB-2) )\r
585         {\r
586             notifyFlag = 1; /* Set for the last CB in each path (PING & PONG) */\r
587         }\r
588 \r
589         /**\r
590          * Prepare input configuration (IC) registers.\r
591          */\r
592         if ( TCP3D_DRV_INPUT_LIST_FULL == tcp3dResultSend )\r
593         {\r
594             /* IC prepare not required. Just clear soldout actions. */\r
595             soldOutActionClear();\r
596         }\r
597         else\r
598         {\r
599             /* Prepare Input Config Registers */\r
600 #if TEST_PREPARE_ONLY_BETASTATE\r
601         /* Prepare only beta state registers */\r
602         prepareBetaStateICParams(cbPtr, cbPtr->mode);\r
603 #elif TEST_PREPARE_ONLY_CODEBLOCK_PARAM_DEPENDENT \r
604         /* Prepare only registers depend on code block configuration\r
605          * (tempICRegs has the fixed registers prepare outside send loop) */\r
606         prepareIC(cbPtr, tempICRegs, 1);\r
607 #else\r
608         /* Prepare all registers */\r
609         prepareIC(cbPtr, NULL, NULL);\r
610 #endif\r
611         }\r
612 \r
613         checkBetaValues (cbPtr->inCfg);\r
614 \r
615         /* Disabling the global interrupts */\r
616         cookie = Hwi_disable();\r
617 \r
618         tcp3dEndMemAccess(cbPtr->inCfg, cbPtr->sizeCFG);\r
619         tcp3dEndMemAccess(cbPtr->inLLR, cbPtr->sizeLLR);\r
620 \r
621         tcp3dBeginMemAccess(cbPtr->outHD, cbPtr->sizeHD);\r
622         if (cbPtr->sdFlag)\r
623             tcp3dBeginMemAccess(cbPtr->outSD, cbPtr->sizeSD);\r
624         if (cbPtr->stsFlag)\r
625             tcp3dBeginMemAccess(cbPtr->outSts, cbPtr->sizeSTS);\r
626 \r
627         /* Restore interrupts */\r
628         Hwi_restore(cookie);\r
629 \r
630         /**\r
631          * WORKAROUND CODE:\r
632          * This code works in line with the code in the second while loop\r
633          * in the send task where check for completion is done.\r
634          * Here we are setting the last byte in the outHD with some value when\r
635          * the refHD has 0x00. This avoids any false completion of send task.\r
636          */\r
637         if ( sendBlockCnt >= (codeBlockSet.maxNumCB-2) )\r
638         {\r
639             /* Fill the last byte in outHD when refHD last byte is ZERO */\r
640             uint8_t     *bytePtr1, *bytePtr2;\r
641             uint32_t    byteSize;\r
642 \r
643             bytePtr1 = (UInt8 *) cbPtr->refHD;\r
644             bytePtr2 = (UInt8 *) cbPtr->outHD;\r
645             byteSize = (cbPtr->blockSize>>3);\r
646 \r
647             if ( bytePtr1[byteSize-1] == 0 )\r
648             {\r
649                 bytePtr2[byteSize-1] = 0xde;\r
650             }\r
651         }\r
652 \r
653 \r
654         /* Enqueue the Code block */\r
655         tcp3dResultSend = Tcp3d_enqueueCodeBlock ( inst,\r
656                                                     cbPtr->blockSize,\r
657                                                     (UInt32 *)L2GLBMAP(dspCoreID, cbPtr->inCfg),\r
658                                                     (Int8 *)L2GLBMAP(dspCoreID, cbPtr->inLLR),\r
659                                                     cbPtr->llrOffset,\r
660                                                     (UInt32 *)L2GLBMAP(dspCoreID, cbPtr->outHD),\r
661                                                     (Int8 *)L2GLBMAP(dspCoreID, cbPtr->outSD), \r
662                                                     cbPtr->sdOffset,\r
663                                                     (UInt32 *)L2GLBMAP(dspCoreID, cbPtr->outSts),\r
664                                                     notifyFlag); // 1 - GEN EVENT, 0 - NO EVENT\r
665 \r
666 \r
667         /* Check for soldout case */\r
668         if ( TCP3D_DRV_INPUT_LIST_FULL != tcp3dResultSend )\r
669         {\r
670             /* increment the block count */\r
671             sendBlockCnt++;\r
672 \r
673             /* goto next block */\r
674             Semaphore_post(semSendBlock);\r
675         }\r
676         else\r
677         {\r
678             /* increment soldout count */\r
679             soldoutCntr++;\r
680 \r
681             soldOutAction(); /* take action */\r
682         }\r
683 \r
684         /* Start the driver after START_CMD_PERIOD blocks */\r
685         if ( sendBlockCnt == START_CMD_PERIOD )\r
686         {\r
687             if ( TCP3D_DRV_NO_ERR != Tcp3d_start(inst, TCP3D_DRV_START_AUTO) )\r
688             {\r
689                 System_printf("Tcp3d_start function returned error (AUTO)\n");\r
690                 System_exit(0);\r
691             }\r
692         }\r
693 \r
694         /* Check for end of task and exit */\r
695         if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
696         {\r
697             /* set flags first */\r
698             pauseIntFlag = 0;\r
699             l2pIntr = pauseIntr;\r
700             pendPauseCntr = 0;\r
701 \r
702 #if SOLDOUT_USE_L2P_INTERRUPT\r
703             if ( soldoutCntr )\r
704             {\r
705                 /* Call TCP3D driver control to set interrupt on L2P channel */\r
706                 drvCtrl.cmd = TCP3D_DRV_SET_L2P_INT;\r
707                 drvCtrl.intrFlag = TEST_INTR_DISABLE;   // disable\r
708                 Tcp3d_control(inst, &drvCtrl);\r
709             }\r
710 #endif\r
711 \r
712             /* Set interrupt flag PAUSE channel */\r
713             drvCtrl.cmd = TCP3D_DRV_CLR_REVT_INT;\r
714             Tcp3d_control(inst, &drvCtrl);\r
715 \r
716             /* Check to see if restart needed before exit */\r
717             if ( TCP3D_DRV_NO_ERR != Tcp3d_start(inst, TCP3D_DRV_START_AUTO) )\r
718             {\r
719                 System_printf("Tcp3d_start function returned error (AUTO)\n");\r
720                 System_exit(0);\r
721             }\r
722             \r
723             /* Set interrupt flag PAUSE channel */\r
724             drvCtrl.cmd = TCP3D_DRV_SET_REVT_INT;\r
725             drvCtrl.intrFlag = TEST_INTR_ENABLE;   // enable\r
726             Tcp3d_control(inst, &drvCtrl);\r
727 \r
728             /* out of enqueue loop */\r
729             break;\r
730         }\r
731     } /* end of - while(1) */\r
732 \r
733 #if DEBUG_VARS\r
734     semCnt = Semaphore_getCount(semSendWait);\r
735 #endif\r
736 \r
737     /**\r
738      * Check for pending Pauses and waiting for the last block to be decoded \r
739      */\r
740     while ( 1 )\r
741     {\r
742         /* Pending on Semaphore to run the loop */\r
743         Semaphore_pend(semSendWait, BIOS_WAIT_FOREVER);\r
744 \r
745         /* Received both the completion events, so exit send task */\r
746         if ( tcp3dEventCntr >= 2 )\r
747         {\r
748             break;\r
749         } else if ( tcp3dEventCntr == 1 )\r
750         {\r
751             /* one code block test case */\r
752             if ( codeBlockSet.maxNumCB == 1 )\r
753             {\r
754                 break;\r
755             }\r
756             else if ( codeBlockSet.mode == TEST_MODE_SPLIT )\r
757             { /* missing one notificatin event - possible in split mode */\r
758                 /**\r
759                 * WORKAROUND CODE:\r
760                 * This is possibility in case of SPLIT mode, that one event is\r
761                 * lost when both ping and pong channels try to generate system\r
762                 * events at close proximity.\r
763                 * In this test bench we have enabled notification events for\r
764                 * the last two blocks, so checking the outHD & refHD last bytes\r
765                 * to confirm the decoding of these blocks are completed.\r
766                 */\r
767                 \r
768                 /* cbPtr for last two code blocks */\r
769                 cbDataDesc  *cbPtr1 = codeBlockSet.cbData[codeBlockSet.maxNumCB-2];\r
770                 cbDataDesc  *cbPtr2 = codeBlockSet.cbData[codeBlockSet.maxNumCB-1];\r
771                 uint8_t     *bytePtr11, *bytePtr12, *bytePtr21, *bytePtr22;\r
772                 uint32_t    size1, size2;\r
773 \r
774                 bytePtr11 = (UInt8 *) cbPtr1->refHD;\r
775                 bytePtr12 = (UInt8 *) cbPtr1->outHD;\r
776                 bytePtr21 = (UInt8 *) cbPtr2->refHD;\r
777                 bytePtr22 = (UInt8 *) cbPtr2->outHD;\r
778                 size1 = (cbPtr1->blockSize>>3); /* in bytes */\r
779                 size2 = (cbPtr2->blockSize>>3); /* in bytes */\r
780 \r
781                 /* check if last HD byte of last two blocks are completed */\r
782                 if ((bytePtr11[size1-1] == bytePtr12[size1-1]) &&\r
783                     (bytePtr21[size2-1] == bytePtr22[size2-1]) ) \r
784                 {\r
785                     System_printf("Notification event missed (Race Condition)\n");\r
786                     System_printf("Since the last two block decoding completed, completing send task\n");\r
787                     System_printf("Block : %d\n", codeBlockSet.maxNumCB-2);\r
788                     System_printf("\trefHD[%d] = 0x%x\t outHD[%d] = 0x%x\n", size1-1, bytePtr11[size1-1], size1-1, bytePtr12[size1-1]);\r
789                     System_printf("Block : %d\n", codeBlockSet.maxNumCB-1);\r
790                     System_printf("\trefHD[%d] = 0x%x\t outHD[%d] = 0x%x\n", size2-1, bytePtr21[size2-1], size2-1, bytePtr22[size2-1]);\r
791                     break;\r
792                 }\r
793             }\r
794         }\r
795 \r
796         if ( TCP3D_DRV_NO_ERR != Tcp3d_start(inst, TCP3D_DRV_START_AUTO) )\r
797         {\r
798             System_printf("Tcp3d_start function returned error\n");\r
799             System_exit(0);\r
800         }\r
801 \r
802         /* keep trying until finding two end events */\r
803         Semaphore_post(semSendWait);\r
804 \r
805         pendPauseCntr++;\r
806     }\r
807 \r
808     /* Last code block decoded - Start the receive task */\r
809     total_clock_end = TSCL;\r
810     Semaphore_post(semRcvStart);\r
811 }\r
812 \r
813 /*******************************************************************************\r
814  ******************************************************************************/\r
815 Void rcvBlockTaskFunc(Void)\r
816 {\r
817     Int32           errCnt;\r
818 \r
819     cbDataDesc       *cbPtr;\r
820     Int             idx, loopCnt;\r
821     Int             fail = 0;\r
822     UInt8           *ptr1, *ptr2;\r
823    \r
824     rcvBlockCnt = 0;\r
825     totErrCnt = 0;\r
826 \r
827     while(1)\r
828     {\r
829         Semaphore_pend(semRcvStart, BIOS_WAIT_FOREVER);\r
830 \r
831         /* prints for send task are done here */\r
832         if ( tcp3dResultSend == TCP3D_DRV_NO_ERR )\r
833         {\r
834 #if DEBUG_PRINT\r
835             for ( loopCnt = 0; loopCnt < sendBlockCnt; loopCnt++ )\r
836             {\r
837                 cbPtr   = codeBlockSet.cbData[loopCnt];\r
838                 System_printf("Send Task: Enqueued Block %d (Size: %d, SW0: %d)\n",\r
839                                     loopCnt, cbPtr->blockSize,\r
840                                     cbPtr->sw0LengthUsed);\r
841             }\r
842 #endif\r
843             System_printf("Send Task: Enqueued %d Blocks\n\n", sendBlockCnt);\r
844         }\r
845         else\r
846         {\r
847             System_printf("Send Task: Enqueued Blocks failed (tcp3dResultSend : %d)\n\n", tcp3dResultSend);\r
848             System_exit(0);\r
849         }\r
850 \r
851         MY_LOG_PRINT0(Rcv Task: SEM RECEIVED);\r
852 \r
853         while( rcvBlockCnt < codeBlockSet.maxNumCB )\r
854         {\r
855             /* Get the pointer to the Code Block Set */\r
856             cbPtr   = codeBlockSet.cbData[rcvBlockCnt];\r
857  \r
858             /* Step 2: Verify All the outputs */\r
859             fail = 0;\r
860             /* Step 2.1: Hard Decisions Verification */\r
861             ptr1 = (UInt8 *) cbPtr->refHD;\r
862             ptr2 = (UInt8 *) cbPtr->outHD;\r
863 \r
864                 /* Invalidate out HD */\r
865             CACHE_invL1d (cbPtr->outHD, cbPtr->blockSize>>3, CACHE_WAIT);\r
866 \r
867             errCnt = 0;    \r
868             for (idx = 0; idx < (cbPtr->blockSize>>3); ++idx)\r
869             {\r
870                 if ( ptr1[idx] != ptr2[idx] )\r
871                 {\r
872                     errCnt++;\r
873                     System_printf("\tBlock Count %d, HD mismatch byte %d\n", rcvBlockCnt, idx);\r
874                 }\r
875             }\r
876 \r
877             if (errCnt)\r
878             {\r
879                 MY_LOG_PRINT2(Rcv task: HD FAILED, rcvBlockCnt, ERRORS:, errCnt);\r
880                 fail++;\r
881             }\r
882             else\r
883             {\r
884                 MY_LOG_PRINT1(Rcv task: HD PASSED, rcvBlockCnt);\r
885             }\r
886     \r
887             /* Step 2.2: Soft Decisions Verification */\r
888             if (cbPtr->sdFlag)\r
889             {\r
890                 if ( codeBlockSet.mode == TEST_MODE_SPLIT ) /* SPLIT MODE */\r
891                     loopCnt = cbPtr->blockSize;\r
892                 else\r
893                     loopCnt = (3*cbPtr->blockSize);\r
894    \r
895                 /* Invalidate out SD */\r
896                 CACHE_invL1d (cbPtr->outSD, loopCnt, CACHE_WAIT);\r
897 \r
898                 /* NOTE: Assumed that the Soft Decisions are in a single array */\r
899                 errCnt = 0;\r
900                 for (idx = 0; idx < loopCnt; ++idx)\r
901                 {\r
902                     if ( cbPtr->refSD[idx] != cbPtr->outSD[idx] )\r
903                     {\r
904                         errCnt += 1;\r
905                         System_printf("\tBlock Count %d, SD mismatch byte %d\n", rcvBlockCnt, idx);\r
906                     }\r
907                 }\r
908     \r
909                 if (errCnt)\r
910                 {\r
911                     MY_LOG_PRINT2(Rcv task: SD FAILED, rcvBlockCnt, ERRORS:, errCnt);\r
912                     fail++;\r
913                 }\r
914                 else\r
915                 {\r
916                     MY_LOG_PRINT1(Rcv task: SD PASSED, rcvBlockCnt);\r
917                 }\r
918             } /* if (cbPtr->sdFlag) */\r
919     \r
920             /* Step 2.3: errCnt Registers Verification */\r
921             if (cbPtr->stsFlag)\r
922             {\r
923                 /* Invalidate out Sts */\r
924                 CACHE_invL1d (cbPtr->outSts, 12, CACHE_WAIT);\r
925 \r
926                 errCnt = 0;\r
927                 for (idx = 0; idx < 3; ++idx)\r
928                 {\r
929                     if ( cbPtr->refSts[idx] != cbPtr->outSts[idx] )\r
930                     {\r
931                         errCnt += 1;\r
932                         System_printf("\tBlock Count %d, STS mismatch word %d\n", rcvBlockCnt, idx);\r
933                     }\r
934                 }\r
935                 if (errCnt)\r
936                 {\r
937                     MY_LOG_PRINT2(Rcv task: STS FAILED, rcvBlockCnt, ERRORS:, errCnt);\r
938                     fail++;\r
939                 }\r
940                 else\r
941                 {\r
942                     MY_LOG_PRINT1(Rcv task: STS PASSED, rcvBlockCnt);\r
943                 }\r
944             } /* if (cbPtr->stsFlag) */\r
945             if (fail)\r
946             {\r
947                 System_printf("Rcv task: Block %d FAILED\n", rcvBlockCnt);\r
948                 totErrCnt++;\r
949             }\r
950 #if DEBUG_PRINT\r
951             else\r
952             {\r
953                 System_printf("Rcv task: Block %d PASSED\n", rcvBlockCnt);\r
954             }\r
955 #endif\r
956             rcvBlockCnt++;\r
957         }\r
958         if(rcvBlockCnt >= codeBlockSet.maxNumCB)\r
959         {\r
960             break;\r
961         }   \r
962     }\r
963 \r
964     System_printf("Rcv Task: COMPLETE - verified %d blocks\n", rcvBlockCnt);\r
965     \r
966     /* Prepare for next test, set by "tester task" */\r
967     Semaphore_post(semRcvDone);\r
968 }\r
969 \r
970 /*******************************************************************************\r
971  ******************************************************************************/\r
972 Void revt0ChCallback(Void)\r
973 {\r
974     /* Increment the ISR counter */\r
975     pauseIntr++;\r
976     \r
977     pauseIntFlag = 1;\r
978 \r
979     if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
980         Semaphore_post(semSendWait);\r
981     else\r
982         Semaphore_post(semSendBlock);\r
983 }\r
984 \r
985 /*******************************************************************************\r
986  ******************************************************************************/\r
987 Void revt1ChCallback(Void)\r
988 {\r
989     /* Increment the ISR counter */\r
990     pauseIntr++;\r
991     \r
992     pauseIntFlag = 2;\r
993 \r
994     if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
995         Semaphore_post(semSendWait);\r
996     else\r
997         Semaphore_post(semSendBlock);\r
998 }\r
999 \r
1000 /*******************************************************************************\r
1001  ******************************************************************************/\r
1002 Void tskHeartBeat(Void)\r
1003 {\r
1004     static unsigned int counter = 0u;\r
1005 \r
1006     while (counter < 0x1000000u)\r
1007     {\r
1008         Task_sleep (1000u);\r
1009         System_printf("\n!!! EDMA3 LLD HrtBt %x\n", counter);\r
1010         counter++;\r
1011     }\r
1012 }\r
1013 \r
1014 /*******************************************************************************\r
1015  ******************************************************************************/\r
1016 Void getMemoryStats(Void)\r
1017 {\r
1018     Memory_Stats        memStats;\r
1019 \r
1020     Memory_getStats(drvHeap, &memStats);\r
1021     System_printf("\nHeap Usage/Status\n");\r
1022     System_printf("    tcp3dDrvHeap : %d of %d free\n", memStats.totalFreeSize, memStats.totalSize);\r
1023 \r
1024     Memory_getStats(dataHeap, &memStats);\r
1025     System_printf("    tcp3dDataHeap : %d of %d free\n", memStats.totalFreeSize, memStats.totalSize);\r
1026 }\r
1027 \r
1028 /*******************************************************************************\r
1029  ******************************************************************************/\r
1030 Void tcp3dEventISR(UInt32 testEvtNum)\r
1031 {\r
1032     tcp3dEventCntr++;\r
1033     tpccEvtCntr++;\r
1034 \r
1035     if ( sendBlockCnt >= codeBlockSet.maxNumCB )\r
1036         Semaphore_post(semSendWait);\r
1037     else\r
1038         Semaphore_post(semSendBlock);\r
1039 }\r
1040 \r
1041 /*******************************************************************************\r
1042  ******************************************************************************/\r
1043 Void registerTcp3dEvent(Void)\r
1044 {\r
1045     static  UInt32 cookie = 0;\r
1046     Int     eventId = 0;    /* GEM event id */\r
1047     static  UInt32 mapDone = 0;\r
1048     UInt32  testEvt = getNotifyEventNum(instNum);\r
1049     UInt32  hostIntr = getHostIntrNum(dspCoreID);\r
1050 \r
1051     /* Disabling the global interrupts */\r
1052     cookie = Hwi_disable();\r
1053 \r
1054     /* Completion ISR Registration */\r
1055     CpIntc_dispatchPlug(testEvt, tcp3dEventISR, hostIntr, TRUE);\r
1056     if (!mapDone)\r
1057         CpIntc_mapSysIntToHostInt(0, testEvt, hostIntr);\r
1058     CpIntc_enableHostInt(0, hostIntr);\r
1059     eventId = CpIntc_getEventId(hostIntr);\r
1060     EventCombiner_dispatchPlug (eventId,\r
1061 #if USE_LOCAL_CPINTC_DISPATCH\r
1062                                 CpIntc_dispatchLoc,\r
1063 #else\r
1064                                 CpIntc_dispatch,\r
1065 #endif\r
1066                                 hostIntr,\r
1067                                 TRUE);\r
1068 #if DEBUG_PRINT\r
1069     System_printf("\t\t testEvt : %d \n", testEvt);\r
1070     System_printf("\t\t hostIntr : %d \n", hostIntr);\r
1071     System_printf("\t\t eventId : %d \n", eventId);\r
1072 #endif\r
1073 \r
1074     /* enable the 'global' switch */\r
1075     CpIntc_enableAllHostInts(0);\r
1076 \r
1077     mapDone = 1;\r
1078 \r
1079     /* Restore interrupts */\r
1080     Hwi_restore(cookie);\r
1081 }\r
1082 \r
1083 /*******************************************************************************\r
1084  ******************************************************************************/\r
1085 Void unregisterTcp3dEvent(Void)\r
1086 {\r
1087     static UInt32 cookie = 0;\r
1088     Int eventId = 0;    /* GEM event id */\r
1089     UInt32  hostIntr = getHostIntrNum(dspCoreID);\r
1090     \r
1091     /* Disabling the global interrupts */\r
1092     cookie = Hwi_disable();\r
1093 \r
1094     /* Driver Completion ISR */\r
1095     CpIntc_disableHostInt(0, hostIntr);\r
1096     eventId = CpIntc_getEventId(hostIntr);\r
1097     EventCombiner_disableEvent(eventId);\r
1098 \r
1099     /* Restore interrupts */\r
1100     Hwi_restore(cookie);\r
1101 }\r
1102 \r
1103 /*******************************************************************************\r
1104  ******************************************************************************/\r
1105 Void allInit(Void)\r
1106 {\r
1107     Tcp3d_Result        tcp3dResult = TCP3D_DRV_NO_ERR;\r
1108     EDMA3_DRV_Result    edmaResult = EDMA3_DRV_SOK;\r
1109 \r
1110     /* Initialize EDMA3 first */\r
1111     hEdma = NULL;\r
1112     tpccNum = 2;\r
1113     tpccRegionUsed = 3;\r
1114     hEdma = edma3init ( tpccNum,\r
1115                         &edmaResult,\r
1116                         dspCoreID,\r
1117                         tpccRegionUsed);\r
1118     if (edmaResult != EDMA3_DRV_SOK)\r
1119     {\r
1120         System_printf("edma3init() FAILED, error code: %d\n", edmaResult);\r
1121     }\r
1122     else\r
1123     {\r
1124         System_printf("EDMA3 LLD Initialization complete (TPCC #%d, Region #%d)\n", tpccNum, tpccRegionUsed);\r
1125     }\r
1126 \r
1127     /* Allocate all EDMA channels required for TCP3D Driver */\r
1128     System_printf("EDMA3 Channels opening started...\n");\r
1129 \r
1130     /* Open channels for one instance */\r
1131     openEdmaChannels (hEdma, instNum, &edmaConfig[instNum]);\r
1132 \r
1133     /* Register call backs */\r
1134     EDMA3_DRV_registerTccCb(hEdma, edmaConfig[instNum].pingChRes[0].chNo, (EDMA3_RM_TccCallback)&revt0ChCallback, NULL);\r
1135     EDMA3_DRV_registerTccCb(hEdma, edmaConfig[instNum].pongChRes[0].chNo, (EDMA3_RM_TccCallback)&revt1ChCallback, NULL);\r
1136 \r
1137 #if EDMA_LOCAL_COMP_ISR // flag defined in sample.h file\r
1138     /* Fill call back details */\r
1139     edmaConfig[instNum].pingChRes[0].cbFunc  = (EDMA3_RM_TccCallback)&revt0ChCallback;\r
1140     edmaConfig[instNum].pingChRes[0].cbData  = NULL;\r
1141     edmaConfig[instNum].pongChRes[0].cbFunc  = (EDMA3_RM_TccCallback)&revt1ChCallback;\r
1142     edmaConfig[instNum].pongChRes[0].cbData  = NULL;\r
1143 \r
1144     /**\r
1145      * Update the information to use with local EDMA ISR \r
1146      * (NOTE: This function must be called after the channels are opened)\r
1147      */\r
1148     updateAllocatedTccsLoc(&edmaConfig[instNum]);\r
1149 #endif\r
1150 \r
1151     System_printf("EDMA3 Channels opening complete\n");\r
1152 \r
1153     System_printf("TCP3 Decoder Driver Initialization sequence started...\n");\r
1154 \r
1155     /* Initialize the TCP3D first */\r
1156     tcp3dDrvInst[instNum] = tcp3dSampleInit (drvHeap,\r
1157                                     instNum,\r
1158                                     testMaxCodeBlocks,\r
1159                                     codeBlockSet.mode,\r
1160                                     codeBlockSet.doubleBuffer,\r
1161                                     codeBlockSet.lteCrcSel,\r
1162                                     dspCoreID,\r
1163                                     hEdma,\r
1164                                     tpccRegionUsed,\r
1165                                     &edmaConfig[instNum],\r
1166                                     &tcp3dResult);\r
1167 \r
1168     System_printf("TCP3 Decoder Driver Initialization sequence complete\n");\r
1169 \r
1170     /* Register the Notification Event for TCP3D */\r
1171     registerTcp3dEvent();\r
1172 \r
1173     /* Set the global flags to default values */\r
1174     pingComplete = 0;\r
1175     pongComplete = 0;\r
1176     pauseIntr = 0;\r
1177     l2pIntr = 0;\r
1178     tcp3dEventCntr = 0;\r
1179     pauseIntFlag = 0;\r
1180     rcvStartFlag = 0;\r
1181     soldoutCntr = 0;\r
1182     afterIntrSoldout = 0;\r
1183     afterIntrPause = 0;\r
1184     pendPauseCntr = 0;\r
1185 }\r
1186 \r
1187 /*******************************************************************************\r
1188  ******************************************************************************/\r
1189 Void allDeInit(Void)\r
1190 {\r
1191     EDMA3_DRV_Result    edmaResult = EDMA3_DRV_SOK;\r
1192 \r
1193     /* Un-register the Notification Event for TCP3D */\r
1194     unregisterTcp3dEvent();\r
1195 \r
1196     /* Close all EDMA channels allocated for the test */\r
1197     System_printf("EDMA3 Channels freeing started...\n");\r
1198 \r
1199     /* Register call backs */\r
1200     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pingChRes[0].chNo);\r
1201     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pingChRes[1].chNo);\r
1202     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pongChRes[0].chNo);\r
1203     EDMA3_DRV_unregisterTccCb(hEdma, edmaConfig[instNum].pongChRes[1].chNo);\r
1204 \r
1205     /* Close channels */\r
1206     closeEdmaChannels(hEdma, instNum, &edmaConfig[instNum]);\r
1207 \r
1208     System_printf("EDMA3 Channels freeing complete\n");\r
1209 \r
1210     /* Deinit for TCP3D driver */\r
1211     System_printf("TCP3 Decoder Driver De-Initialization sequence started...\n");\r
1212 \r
1213     tcp3dSampleDeinit(drvHeap, instNum, tcp3dDrvInst[instNum]);\r
1214 \r
1215     System_printf("TCP3 Decoder Driver De-Initialization sequence complete\n");\r
1216 \r
1217     /* De-init EDMA3 */\r
1218     edmaResult = edma3deinit(tpccNum, hEdma);\r
1219     if (edmaResult != EDMA3_DRV_SOK)\r
1220     {\r
1221         System_printf("edma3deinit() FAILED, error code: %d\n", edmaResult);\r
1222     }\r
1223     else\r
1224     {\r
1225         System_printf("EDMA3 LLD De-Initialization complete\n");\r
1226     }\r
1227 }\r
1228 \r
1229 /**\r
1230  *  @b Description\r
1231  *  @n  \r
1232  *      This function enables the power/clock domains for TCP3D. \r
1233  *\r
1234  *  @retval\r
1235  *      Not Applicable.\r
1236  */\r
1237 static Int32 enable_tcp3d (void)\r
1238 {\r
1239 #ifndef SIMULATOR_SUPPORT\r
1240     /* TCP3D power domain is turned OFF by default.\r
1241      * It needs to be turned on before doing any TCP3D device register access.\r
1242      * This is not required for the simulator. */\r
1243 \r
1244     /* Set TCP3D Power domain to ON */        \r
1245     CSL_PSC_enablePowerDomain (TEST_CSL_PSC_PD_TCP3D);\r
1246 \r
1247     /* Enable the clocks too for TCP3D */\r
1248     CSL_PSC_setModuleNextState (TEST_CSL_PSC_LPSC_TCP3D, PSC_MODSTATE_ENABLE);\r
1249 \r
1250     /* Start the state transition */\r
1251     CSL_PSC_startStateTransition (TEST_CSL_PSC_PD_TCP3D);\r
1252 \r
1253     /* Wait until the state transition process is completed. */\r
1254     while (!CSL_PSC_isStateTransitionDone (TEST_CSL_PSC_PD_TCP3D));\r
1255 \r
1256     /* Return TCP3D PSC status */\r
1257     if ((CSL_PSC_getPowerDomainState(TEST_CSL_PSC_PD_TCP3D) == PSC_PDSTATE_ON) &&\r
1258         (CSL_PSC_getModuleState (TEST_CSL_PSC_LPSC_TCP3D) == PSC_MODSTATE_ENABLE))\r
1259     {\r
1260         /* TCP3D ON. Ready for use */            \r
1261         return 0;\r
1262     }\r
1263     else\r
1264     {\r
1265         /* TCP3D Power on failed. Return error */            \r
1266         return -1;            \r
1267     }\r
1268 #else\r
1269     /* PSC is not supported on simulator. Return success always */\r
1270     return 0;\r
1271 #endif\r
1272 }\r
1273 \r
1274 /**\r
1275  *  @b Description\r
1276  *  @n  \r
1277  *      The function is used to indicate that a block of memory is \r
1278  *      about to be accessed. If the memory block is cached then this \r
1279  *      indicates that the application would need to ensure that the \r
1280  *      cache is updated with the data from the actual memory.\r
1281  *\r
1282  *  @param[in]  ptr\r
1283  *       Address of memory block\r
1284  *\r
1285  *  @param[in]  size\r
1286  *       Size of memory block\r
1287  *\r
1288  *  @retval\r
1289  *      Not Applicable\r
1290  */\r
1291 void tcp3dBeginMemAccess (void *ptr, uint32_t size)\r
1292 {\r
1293     /* Invalidate L1D cache and wait until operation is complete. \r
1294      * Use this approach if L2 cache is not enabled */    \r
1295     CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT);\r
1296 \r
1297     /*  Cleanup the prefectch buffer also. */\r
1298     CSL_XMC_invalidatePrefetchBuffer();    \r
1299 \r
1300     return;\r
1301 }\r
1302 \r
1303 /**\r
1304  *  @b Description\r
1305  *  @n  \r
1306  *      The function is used to indicate that the block of memory has \r
1307  *      finished being accessed. If the memory block is cached then the \r
1308  *      application would need to ensure that the contents of the cache \r
1309  *      are updated immediately to the actual memory. \r
1310  *\r
1311  *  @param[in]  ptr\r
1312  *       Address of memory block\r
1313  *  @param[in]  size\r
1314  *       Size of memory block\r
1315  *\r
1316  *  @retval\r
1317  *      Not Applicable\r
1318  */\r
1319 void tcp3dEndMemAccess (void *ptr, uint32_t size)\r
1320 {\r
1321     /* Writeback L1D cache and wait until operation is complete. \r
1322      * Use this approach if L2 cache is not enabled */    \r
1323     CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);        \r
1324 \r
1325     return;\r
1326 }\r
1327 \r
1328 /* end of file */\r