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