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