[processor-sdk/pdk.git] / packages / ti / drv / udma / unit_test / udma_ut / src / udma_test_parser.c
1 /*
2 * Copyright (c) Texas Instruments Incorporated 2018
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the
14 * distribution.
15 *
16 * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
33 /**
34 * \file udma_test_parser.c
35 *
36 * \brief UDMA test application parser file.
37 *
38 */
40 /* ========================================================================== */
41 /* Include Files */
42 /* ========================================================================== */
44 #include "udma_test.h"
45 #include "udma_testcases.h"
46 #include "udma_testconfig.h"
48 /* ========================================================================== */
49 /* Macros & Typedefs */
50 /* ========================================================================== */
52 /* Test application stack size */
53 #define APP_TSK_STACK_MAIN (16U * 1024U)
55 /* ========================================================================== */
56 /* Structure Declarations */
57 /* ========================================================================== */
59 /* None */
61 /* ========================================================================== */
62 /* Function Declarations */
63 /* ========================================================================== */
65 static int32_t udmaTestInit(UdmaTestObj *testObj);
66 static int32_t udmaTestDeinit(UdmaTestObj *testObj);
68 static int32_t udmaTestRunTc(UdmaTestObj *testObj, UdmaTestParams *testPrms);
69 static int32_t udmaTestCreateTestTasks(UdmaTestObj *testObj, UdmaTestParams *testPrms);
70 static int32_t udmaTestDeleteTestTasks(UdmaTestObj *testObj);
71 static void udmaTestTask(void *arg0, void *arg1);
72 static void udmaTestInitTestObj(UdmaTestObj *testObj, UdmaTestParams *testPrms);
74 static const UdmaTestChPrm *udmaTestGetChPrms(UdmaTestChPrmId chPrmId);
75 static const Udma_ChTxPrms *udmaTestGetTxChPrms(UdmaTestTxChPrmId txChPrmId);
76 static const Udma_ChRxPrms *udmaTestGetRxChPrms(UdmaTestRxChPrmId rxChPrmId);
77 static const Udma_ChUtcPrms *udmaTestGetUtcChPrms(UdmaTestUtcChPrmId utcChPrmId);
78 static const Udma_ChPdmaPrms *udmaTestGetPdmaChPrms(UdmaTestPdmaChPrmId pdmaChPrmId);
79 static const UdmaTestRingPrm *udmaTestGetRingPrms(UdmaTestRingPrmId ringPrmId);
81 static int32_t udmaTestGetTcIdx(uint32_t tcId);
82 static bool udmaTestCheckIfTestToBeSkipped(UdmaTestObj *testObj,
83 UdmaTestParams *testPrms,
84 uint32_t tcType);
86 static int32_t udmaTestDisplayTestInfo(UdmaTestObj *testObj);
87 static int32_t udmaTestGenerateTestReports(UdmaTestObj *testObj);
89 static void udmaTestMenuSettings(UdmaTestObj *testObj);
90 static void udmaTestMenuMainShow(UdmaTestObj *testObj);
91 static void udmaTestMenuSettingsShow(UdmaTestObj *testObj);
92 static void udmaTestMenuCurrentSettingsShow(UdmaTestObj *testObj);
93 static void udmaTestSetDefaultCfg(UdmaTestObj *testObj);
94 static uint32_t udmaTestGetTestId(UdmaTestObj *testObj, uint32_t tcType);
96 /* ========================================================================== */
97 /* Global Variables */
98 /* ========================================================================== */
100 #if !defined (UDMA_UT_BAREMETAL)
101 /* Task stack */
102 static uint8_t gUdmaParserTskStack[UDMA_TEST_MAX_TASKS][APP_TSK_STACK_MAIN] __attribute__((aligned(32)));;
103 #endif
105 /* UDMA UT object. */
106 UdmaTestObj gUdmaTestUtObj =
107 {
108 .lockSem = NULL,
109 };
111 /* Main menu 0 string */
112 static const char gUdmaTestMenuMain0[] =
113 {
114 "\r\n "
115 "\r\n ==============="
116 "\r\n UDMA Test Select"
117 "\r\n ==============="
118 "\r\n "
119 };
121 /* Main menu string */
122 static const char gUdmaTestMenuMain1[] =
123 {
124 "\r\n 1: Manual testing (select specific test case to run)"
125 "\r\n 2: Sanity (BFT) testing"
126 "\r\n 3: Regression testing"
127 "\r\n 4: Full testing"
128 "\r\n 5: Performance testing"
129 "\r\n d: Display test cases"
130 "\r\n g: Generate test report"
131 "\r\n "
132 "\r\n s: System Settings"
133 "\r\n "
134 "\r\n q: Quit "
135 "\r\n "
136 "\r\n Enter Choice: "
137 "\r\n"
138 };
140 static const char gUdmaTestMenuSettings0[] = {
141 "\r\n ==============="
142 "\r\n System Settings"
143 "\r\n ==============="
144 "\r\n "
145 };
147 static const char gUdmaTestMenuSettings1[] = {
148 "\r\n "
149 "\r\n l: Loop Count"
150 "\r\n d: Queue Depth (How many outstanding transfer per channel)"
151 "\r\n r: Runtime Print Enable"
152 "\r\n "
153 "\r\n q: Quit "
154 "\r\n"
155 };
157 /* ========================================================================== */
158 /* Function Definitions */
159 /* ========================================================================== */
161 /**
162 * udmaTestParser
163 */
164 int32_t udmaTestParser(void)
165 {
166 char option;
167 bool done;
168 int32_t retVal = UDMA_SOK, getCharRetVal = UDMA_SOK;
169 int32_t tcIdx, startIdx;
170 uint32_t testCnt, tcType, tcId;
171 uint32_t startTime, elapsedTime, startTime1, elapsedTime1;
172 uint32_t hrs, mins, secs, durationInSecs;
173 UdmaTestObj *testObj;
174 UdmaTestParams *testPrms;
175 uint32_t isValidInput = FALSE;
177 testObj = &gUdmaTestUtObj;
178 udmaTestSetDefaultCfg(testObj);
179 udmaTestResetTestResult();
181 retVal = udmaTestInit(testObj);
182 if(UDMA_SOK != retVal)
183 {
184 return (retVal);
185 }
187 startTime = AppUtils_getCurTimeInMsec();
188 done = FALSE;
189 testObj->skipCount = 0U;
190 testObj->disableCount = 0U;
191 while(!done)
192 {
193 udmaTestMenuMainShow(testObj);
194 if(isValidInput != TRUE)
195 {
196 #if defined (UDMA_UT_ENABLE_MANUAL_ENTRY)
197 getCharRetVal = AppUtils_getCharTimeout(&option, UDMA_TEST_UART_TIMEOUT_MSEC);
198 #else
199 /* Disable user input - do full automation */
200 getCharRetVal = UDMA_EFAIL;
201 #endif
202 if(UDMA_SOK != getCharRetVal)
203 {
204 /* Timeout */
205 GT_0trace(
206 testObj->traceMask, GT_INFO,
207 " UART read timeout (10 sec)!!\r\n");
208 /* Default to full test */
209 GT_0trace(
210 testObj->traceMask, GT_INFO, " Automating FULL test!!\r\n");
211 option = '4';
212 /* Set done flag to end test */
213 done = TRUE;
214 }
215 else
216 {
217 isValidInput = TRUE;
218 }
219 }
220 else
221 {
222 option = AppUtils_getChar();
223 }
224 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
226 tcType = UDMA_TCT_SANITY;
227 switch(option)
228 {
229 case 's':
230 case 'S':
231 udmaTestMenuSettings(testObj);
232 break;
234 case 'q':
235 case 'Q':
236 done = TRUE;
237 break;
239 case '1':
240 GT_0trace(testObj->traceMask, GT_INFO, " Manual testing \r\n");
241 tcId = udmaTestGetTestId(testObj, UDMA_TCT_ALL);
242 /* Find the test case to run */
243 tcIdx = udmaTestGetTcIdx(tcId);
244 if(tcIdx < 0)
245 {
246 GT_0trace(testObj->traceMask, GT_INFO,
247 " Test case ID not found\r\n");
248 }
249 else
250 {
251 testPrms = &gUdmaTestCases[tcIdx];
252 udmaTestRunTc(testObj, testPrms);
253 }
254 break;
256 case '4':
257 tcType |= UDMA_TCT_FULL;
258 case '3':
259 tcType |= UDMA_TCT_REGRESSION;
260 case '2':
261 if(TRUE == done)
262 {
263 /* Auto run, start from 1st test case */
264 tcId = 0U;
265 }
266 else
267 {
268 GT_0trace(
269 testObj->traceMask, GT_INFO,
270 " Enter Start Test Case Id "
271 "(Enter 0 to start from first): \r\n");
272 tcId = udmaTestGetTestId(testObj, tcType);
273 }
274 if(0U == tcId)
275 {
276 startIdx = 0U;
277 }
278 else
279 {
280 startIdx = udmaTestGetTcIdx(tcId);
281 if(startIdx < 0)
282 {
283 GT_0trace(testObj->traceMask, GT_INFO,
284 " Test case ID not found\r\n");
285 continue;
286 }
287 }
289 /* Run all test cases one after the other depending on selected
290 * flag */
291 startTime1 = AppUtils_getCurTimeInMsec();
292 testObj->skipCount = testObj->disableCount = 0U;
294 for(testCnt = startIdx;
295 testCnt < UDMA_TEST_NUM_TESTCASES;
296 testCnt++)
297 {
298 testPrms = &gUdmaTestCases[testCnt];
300 /* Check whether to execute test or not */
301 if(udmaTestCheckIfTestToBeSkipped(testObj, testPrms, tcType))
302 {
303 continue; /* Skip test */
304 }
306 udmaTestRunTc(testObj, testPrms);
307 }
309 /* Print test results */
310 udmaTestPrintTestResult(
311 testObj,
312 testObj->skipCount,
313 testObj->disableCount);
315 elapsedTime1 = AppUtils_getElapsedTimeInMsec(startTime1);
316 durationInSecs = ((elapsedTime1) / 1000U);
317 hrs = durationInSecs / (60U * 60U);
318 mins = (durationInSecs / 60U) - (hrs * 60U);
319 secs = durationInSecs - (hrs * 60U * 60U) - (mins * 60U);
320 GT_3trace(testObj->traceMask, GT_INFO,
321 " |TOTAL TEST DURATION|: %d hrs %d mins %d secs\r\n",
322 hrs, mins, secs);
323 break;
325 case '5':
326 tcType = UDMA_TCT_PERFORMANCE;
327 startIdx = 0U;
329 /* Run all test cases one after the other depending on selected
330 * flag */
331 startTime1 = AppUtils_getCurTimeInMsec();
332 testObj->skipCount = testObj->disableCount = 0U;
333 for(testCnt = startIdx;
334 testCnt < UDMA_TEST_NUM_TESTCASES;
335 testCnt++)
336 {
337 testPrms = &gUdmaTestCases[testCnt];
339 /* Check whether to execute test or not */
340 if(udmaTestCheckIfTestToBeSkipped(testObj, testPrms, tcType))
341 {
342 continue; /* Skip test */
343 }
345 udmaTestRunTc(testObj, testPrms);
346 }
348 /* Print test results */
349 udmaTestPrintTestResult(
350 testObj, testObj->skipCount, testObj->disableCount);
352 elapsedTime1 = AppUtils_getElapsedTimeInMsec(startTime1);
353 durationInSecs = ((elapsedTime1) / 1000U);
354 hrs = durationInSecs / (60U * 60U);
355 mins = (durationInSecs / 60U) - (hrs * 60U);
356 secs = durationInSecs - (hrs * 60U * 60U) - (mins * 60U);
357 GT_3trace(testObj->traceMask, GT_INFO,
358 " |TOTAL TEST DURATION|: %d hrs %d mins %d secs\r\n",
359 hrs, mins, secs);
360 break;
362 case 'd':
363 case 'D':
364 /* Display test info */
365 udmaTestDisplayTestInfo(testObj);
366 break;
368 case 'g':
369 case 'G':
370 /* Generate test report */
371 udmaTestGenerateTestReports(testObj);
372 break;
374 default:
375 GT_0trace(testObj->traceMask, GT_INFO,
376 " Invalid option try again!!\r\n");
377 break;
378 }
379 }
381 udmaTestDisplayTestInfo(testObj);
382 udmaTestGenerateTestReports(testObj);
384 elapsedTime = AppUtils_getElapsedTimeInMsec(startTime);
385 durationInSecs = ((elapsedTime) / 1000U);
386 hrs = durationInSecs / (60U * 60U);
387 mins = (durationInSecs / 60U) - (hrs * 60U);
388 secs = durationInSecs - (hrs * 60U * 60U) - (mins * 60U);
389 GT_3trace(testObj->traceMask, GT_INFO,
390 " |TOTAL UT DURATION|: %d hrs %d mins %d secs\r\n",
391 hrs, mins, secs);
393 /* Check if all testcases passed and accordingly return pass/fail */
394 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
395 {
396 testPrms = &gUdmaTestCases[testCnt];
397 if(TRUE == testPrms->isRun)
398 {
399 if(UDMA_SOK != testPrms->testResult)
400 {
401 retVal = testPrms->testResult;
402 }
403 }
404 }
406 retVal = udmaTestDeinit(testObj);
407 if(UDMA_SOK != retVal)
408 {
409 GT_0trace(testObj->traceMask, GT_ERR, " UDMA deinit failed!!\n");
410 }
412 /* Print test results */
413 udmaTestPrintTestResult(testObj, testObj->skipCount, testObj->disableCount);
415 return (retVal);
416 }
418 /**
419 * udmaTestRunTc
420 */
421 static int32_t udmaTestRunTc(UdmaTestObj *testObj, UdmaTestParams *testPrms)
422 {
423 static char tempString[UDMA_TEST_PRINT_BUFSIZE];
424 int32_t retVal = UDMA_SOK;
425 uint32_t startTime, hrs, mins, secs, msecs;
426 uint32_t durationInMsecs, durationInSecs;
427 static char *enableDisableName[] = {"Disabled", "Enabled"};
429 /* NULL pointer check */
430 GT_assert(testObj->traceMask, (NULL != testPrms));
431 GT_assert(testObj->traceMask, (NULL != testPrms->tcName));
433 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
434 GT_1trace(testObj->traceMask, GT_INFO,
435 " |TEST START|:: %d ::\r\n", testPrms->tcId);
436 GT_1trace(testObj->traceMask, GT_INFO,
437 " |TEST NAME|:: %s ::\r\n", testPrms->tcName);
438 GT_1trace(testObj->traceMask, GT_INFO,
439 " |TEST INFO|:: Num Tasks : %d ::\r\n", testPrms->numTasks);
440 GT_1trace(testObj->traceMask, GT_INFO,
441 " |TEST INFO|:: Data Check : %s ::\r\n", enableDisableName[testPrms->dcEnable]);
442 GT_1trace(testObj->traceMask, GT_INFO,
443 " |TEST INFO|:: Performance : %s ::\r\n", enableDisableName[testPrms->prfEnable]);
444 GT_1trace(testObj->traceMask, GT_INFO,
445 " |TEST INFO|:: Print : %s ::\r\n", enableDisableName[testPrms->printEnable]);
447 udmaTestInitTestObj(testObj, testPrms);
448 /* Start the load calculation */
449 Utils_prfLoadCalcStart();
451 testPrms->isRun = TRUE;
452 startTime = AppUtils_getCurTimeInMsec();
453 retVal = udmaTestCreateTestTasks(testObj, testPrms);
454 durationInMsecs = AppUtils_getElapsedTimeInMsec(startTime);
456 Utils_prfLoadCalcStop();
457 Utils_prfLoadPrintAll(TRUE, testObj->traceMask);
458 Utils_prfLoadCalcReset();
459 retVal += udmaTestDeleteTestTasks(testObj);
461 durationInSecs = (durationInMsecs / 1000U);
462 hrs = durationInSecs / (60U * 60U);
463 mins = (durationInSecs / 60U) - (hrs * 60U);
464 secs = durationInSecs - (hrs * 60U * 60U) - (mins * 60U);
465 msecs = durationInMsecs - ((hrs * 60U * 60U) + (mins * 60U) + secs) * 1000U;
466 GT_4trace(testObj->traceMask, GT_INFO,
467 " |TEST DURATION|:: %d:%0.2d:%0.2d:%0.3d ::\r\n",
468 hrs, mins, secs, msecs);
470 if((TRUE == testPrms->prfEnable) && (testPrms->numTasks > 1U))
471 {
472 /* Total performance applicable only for multi thread.
473 * Incase of multi thread, individual performance doesn't makes sense
474 * Incase of single thread, the thread itself will print the accurate
475 * performance. Total is not very accurate. Hence disable from here */
476 udmaTestCalcTotalPerformance(testObj, durationInMsecs);
477 }
479 GT_assert(testObj->traceMask, (NULL != testPrms->tcName));
480 snprintf(tempString, sizeof (tempString), "%s", testPrms->tcName);
481 udmaTestLogTestResult(testObj, retVal, testPrms->tcId, tempString);
483 if(UDMA_SOK == retVal)
484 {
485 GT_1trace(testObj->traceMask, GT_INFO,
486 " |TEST RESULT|:: UDMA Test Case %d Successful!! ::\r\n", testObj->testPrms->tcId);
487 }
488 else
489 {
490 GT_1trace(testObj->traceMask, GT_INFO,
491 " |TEST RESULT|:: UDMA Test Case %d Failed!! ::\r\n", testObj->testPrms->tcId);
492 }
494 /* Store the test result */
495 testPrms->testResult = retVal;
497 return (retVal);
498 }
499 #if defined (UDMA_UT_BAREMETAL)
500 int32_t udmaTestCreateTestTasks(UdmaTestObj *testObj, UdmaTestParams *testPrms)
501 {
502 int32_t retVal = UDMA_SOK;
503 uint32_t taskCnt;
504 UdmaTestTaskObj *taskObj;
506 for(taskCnt = 0U; taskCnt < testPrms->numTasks; taskCnt++)
507 {
508 taskObj = &testObj->taskObj[taskCnt];
509 udmaTestTask(taskObj, NULL);
510 }
512 for(taskCnt = 0u; taskCnt < testPrms->numTasks; taskCnt++)
513 {
514 retVal += testObj->taskObj[taskCnt].testResult;
515 }
517 return (retVal);
518 }
520 static int32_t udmaTestDeleteTestTasks(UdmaTestObj *testObj)
521 {
522 return UDMA_SOK;
523 }
525 #else
526 int32_t udmaTestCreateTestTasks(UdmaTestObj *testObj, UdmaTestParams *testPrms)
527 {
528 int32_t retVal = UDMA_SOK;
529 uint32_t taskCnt, createdTsk = 0U;
530 TaskP_Params taskPrms;
531 UdmaTestTaskObj *taskObj;
532 SemaphoreP_Params semPrms;
534 SemaphoreP_Params_init(&semPrms);
535 semPrms.mode = SemaphoreP_Mode_COUNTING;
536 testObj->taskCompleteSem = SemaphoreP_create(0U, &semPrms);
537 if(NULL == testObj->taskCompleteSem)
538 {
539 GT_0trace(testObj->traceMask, GT_ERR, " Sem create failed\r\n");
540 retVal = UDMA_EALLOC;
541 }
543 if(UDMA_SOK == retVal)
544 {
545 for(taskCnt = 0U; taskCnt < testPrms->numTasks; taskCnt++)
546 {
547 taskObj = &testObj->taskObj[taskCnt];
549 TaskP_Params_init(&taskPrms);
550 taskPrms.arg0 = taskObj;
551 taskPrms.stack = &gUdmaParserTskStack[taskCnt][0U];
552 taskPrms.stacksize = APP_TSK_STACK_MAIN;
553 taskObj->taskHandle = TaskP_create((void *) &udmaTestTask, &taskPrms);
554 if(NULL == taskObj->taskHandle)
555 {
556 retVal = UDMA_EALLOC;
557 break;
558 }
559 createdTsk++;
561 /* Register the task to the load module for calculating the load */
562 snprintf(taskObj->prfTsName, sizeof (taskObj->prfTsName), "Task%d", taskCnt);
563 Utils_prfLoadRegister(taskObj->taskHandle, taskObj->prfTsName);
564 }
565 }
567 if(UDMA_SOK == retVal)
568 {
569 for(taskCnt = 0U; taskCnt < createdTsk; taskCnt++)
570 {
571 /* Wait for tasks to complete */
572 SemaphoreP_pend(testObj->taskCompleteSem, SemaphoreP_WAIT_FOREVER);
573 }
574 }
576 if(UDMA_SOK == retVal)
577 {
578 for(taskCnt = 0u; taskCnt < createdTsk; taskCnt++)
579 {
580 retVal += testObj->taskObj[taskCnt].testResult;
581 }
582 }
584 if(NULL != testObj->taskCompleteSem)
585 {
586 SemaphoreP_delete(testObj->taskCompleteSem);
587 testObj->taskCompleteSem = NULL;
588 }
590 return (retVal);
591 }
593 static int32_t udmaTestDeleteTestTasks(UdmaTestObj *testObj)
594 {
595 int32_t retVal = UDMA_SOK;
596 uint32_t taskCnt;
597 UdmaTestTaskObj *taskObj;
599 /* Delete all created tasks and semephores */
600 for(taskCnt = 0U; taskCnt < UDMA_TEST_MAX_TASKS; taskCnt++)
601 {
602 taskObj = &testObj->taskObj[taskCnt];
603 if(NULL != taskObj->taskHandle)
604 {
605 Utils_prfLoadUnRegister(taskObj->taskHandle);
606 TaskP_delete(&taskObj->taskHandle);
607 taskObj->taskHandle = NULL;
608 }
609 }
611 return (retVal);
612 }
613 #endif
615 static void udmaTestTask(void *arg0, void *arg1)
616 {
617 int32_t retVal;
618 UdmaTestObj *testObj;
619 UdmaTestTaskObj *taskObj;
621 /* Run the test */
622 taskObj = (UdmaTestTaskObj *) arg0;
623 testObj = taskObj->testObj;
625 /* Run the test */
626 GT_assert(testObj->traceMask, (taskObj->testFxnPtr != NULL));
627 retVal = taskObj->testFxnPtr(taskObj);
629 taskObj->testResult = retVal;
631 #if !defined (UDMA_UT_BAREMETAL)
632 /* Test complete. Signal it */
633 SemaphoreP_post(testObj->taskCompleteSem);
634 #endif
636 return;
637 }
639 static int32_t udmaTestInit(UdmaTestObj *testObj)
640 {
641 int32_t retVal = UDMA_SOK;
642 SemaphoreP_Params semPrms;
643 #if defined (UDMA_UTC_ID_MSMC_DRU0)
644 Udma_DrvHandle drvHandle;
645 uint32_t utcId;
646 uint32_t numQueue, queId;
647 CSL_DruQueueConfig queueCfg;
648 #endif
650 SemaphoreP_Params_init(&semPrms);
651 semPrms.mode = SemaphoreP_Mode_BINARY;
652 testObj->lockSem = SemaphoreP_create(1U, &semPrms);
653 if(NULL == testObj->lockSem)
654 {
655 retVal = UDMA_EALLOC;
656 }
658 retVal += Utils_memInit();
659 retVal += udmaTestInitDriver(testObj);
661 #if defined (UDMA_UTC_ID_MSMC_DRU0)
662 if(UDMA_SOK == retVal)
663 {
664 /* Init all DRU queue */
665 utcId = UDMA_UTC_ID_MSMC_DRU0;
666 drvHandle = &testObj->drvObj[0U];
667 numQueue = Udma_druGetNumQueue(drvHandle, utcId);
668 if(0U == numQueue)
669 {
670 retVal = UDMA_EFAIL;
671 GT_0trace(testObj->traceMask, GT_ERR,
672 " [Error] Invalid queue number!!\n");
673 }
674 UdmaDruQueueConfig_init(&queueCfg);
675 for(queId = CSL_DRU_QUEUE_ID_0; queId < numQueue; queId++)
676 {
677 retVal += Udma_druQueueConfig(drvHandle, utcId, queId, &queueCfg);
678 if(UDMA_SOK != retVal)
679 {
680 GT_0trace(testObj->traceMask, GT_ERR,
681 " [Error] DRU queue config failed!!\n");
682 break;
683 }
684 }
685 }
686 #endif
688 return (retVal);
689 }
691 static int32_t udmaTestDeinit(UdmaTestObj *testObj)
692 {
693 int32_t retVal = UDMA_SOK;
695 /* Deinit the drivers */
696 retVal += udmaTestDeinitDriver(testObj);
697 retVal += Utils_memDeInit();
698 if(NULL != testObj->lockSem)
699 {
700 SemaphoreP_delete(testObj->lockSem);
701 testObj->lockSem = NULL;
702 }
704 return (retVal);
705 }
707 static void udmaTestInitTestObj(UdmaTestObj *testObj, UdmaTestParams *testPrms)
708 {
709 uint32_t taskCnt, chCnt, qCnt, chIdx, totalCh = 0U, cnt, dim;
710 volatile UdmaTestTaskObj *taskObj;
711 const UdmaTestChPrm *chPrms;
712 const Udma_ChTxPrms *txPrms = NULL;
713 const Udma_ChRxPrms *rxPrms = NULL;
714 const Udma_ChUtcPrms *utcPrms = NULL;
715 const Udma_ChPdmaPrms *pdmaPrms = NULL;
716 UdmaTestChObj *chObj;
718 testObj->testPrms = testPrms;
719 testObj->traceMask = (GT_INFO1 | GT_TraceState_Enable);
720 if(FALSE == testPrms->printEnable)
721 {
722 /* Restrict the number of prints when print is disabled */
723 testObj->traceMask = (GT_INFO | GT_TraceState_Enable);
724 }
725 testObj->taskCompleteSem = NULL;
727 GT_assert(testObj->traceMask, (testPrms->numTasks <= UDMA_TEST_MAX_TASKS));
728 for(taskCnt = 0U; taskCnt < testPrms->numTasks; taskCnt++)
729 {
730 taskObj = &testObj->taskObj[taskCnt];
731 taskObj->testPrms = testPrms;
732 taskObj->testType = testPrms->testType[taskCnt];
733 taskObj->testFxnPtr = testPrms->testFxnPtr[taskCnt];
734 GT_assert(testObj->traceMask, (taskObj->testFxnPtr != NULL));
735 GT_assert(testObj->traceMask, (testPrms->numCh[taskCnt] <= UDMA_TEST_MAX_CH));
736 GT_assert(testObj->traceMask, (testPrms->numCh[taskCnt] != 0U));
737 taskObj->pacingTime = testPrms->pacingTime[taskCnt];
738 taskObj->numCh = testPrms->numCh[taskCnt];
739 taskObj->traceMask = testObj->traceMask;
740 taskObj->testResult = UDMA_SOK;
741 taskObj->totalTransfer = 0U;
742 taskObj->durationMs = 1U;
743 taskObj->mps = 0U;
744 taskObj->testObj = testObj;
745 taskObj->taskId = taskCnt;
746 taskObj->taskHandle = NULL;
747 taskObj->prfTsHandle = NULL;
748 taskObj->loopCnt = testPrms->loopCnt;
749 if(USE_DEF_LP_CNT == taskObj->loopCnt)
750 {
751 taskObj->loopCnt = testObj->sysCtrl.loopCnt;
752 }
754 taskObj->ringPrms = udmaTestGetRingPrms(testPrms->ringPrmId);
755 for(chCnt = totalCh; chCnt < (taskObj->numCh + totalCh); chCnt++)
756 {
757 chIdx = chCnt - totalCh;
758 chObj = &testObj->chObjs[chCnt];
759 taskObj->chObj[chIdx] = chObj;
761 chObj->chIdx = chIdx;
762 chObj->chHandle = NULL;
763 chObj->cqEventHandle = NULL;
764 chObj->tdCqEventHandle = NULL;
765 chObj->drvHandle = &testObj->drvObj[testPrms->instId[chCnt]];
766 chObj->instId = testPrms->instId[chCnt];
767 chObj->transferDoneSem = NULL;
768 chObj->queueCnt = 0U;
769 chObj->dequeueCnt = 0U;
770 chObj->fqRingMem = NULL;
771 chObj->cqRingMem = NULL;
772 chObj->tdCqRingMem = NULL;
773 chObj->srcBuf = NULL;
774 for(qCnt = 0U; qCnt < UDMA_TEST_MAX_QDEPTH; qCnt++)
775 {
776 chObj->trpdMem[qCnt] = NULL;
777 chObj->destBuf[qCnt] = NULL;
778 }
780 chPrms = udmaTestGetChPrms(testPrms->chPrmId[chCnt]);
781 GT_assert(testObj->traceMask, (chPrms != NULL));
782 chObj->chPrms = chPrms;
783 if(NULL != chPrms)
784 {
785 txPrms = udmaTestGetTxChPrms(chPrms->txPrmId);
786 rxPrms = udmaTestGetRxChPrms(chPrms->rxPrmId);
787 utcPrms = udmaTestGetUtcChPrms(chPrms->utcPrmId);
788 pdmaPrms = udmaTestGetPdmaChPrms(chPrms->pdmaPrmId);
789 }
790 chObj->txPrms = txPrms;
791 chObj->rxPrms = rxPrms;
792 chObj->utcPrms = utcPrms;
793 chObj->pdmaPrms = pdmaPrms;
795 chObj->qdepth = testPrms->qdepth[chCnt];
796 if(USE_DEF_QDEPTH == chObj->qdepth)
797 {
798 chObj->qdepth = testObj->sysCtrl.qdepth;
799 }
800 GT_assert(testObj->traceMask, (chObj->qdepth <= UDMA_TEST_MAX_QDEPTH));
801 for(cnt = 0U; cnt < UDMA_TEST_MAX_ICNT; cnt++)
802 {
803 chObj->icnt[cnt] = testPrms->icnt[chCnt][cnt];
804 chObj->dicnt[cnt] = testPrms->dicnt[chCnt][cnt];
805 }
806 for(dim = 0U; dim < UDMA_TEST_MAX_DIM; dim++)
807 {
808 chObj->dim[dim] = testPrms->dim[chCnt][dim];
809 chObj->ddim[dim] = testPrms->ddim[chCnt][dim];
810 }
811 chObj->heapIdSrc = testPrms->heapIdSrc[chCnt];
812 chObj->heapIdDest = testPrms->heapIdDest[chCnt];
813 chObj->srcBufSize = testPrms->srcBufSize[chCnt];
814 chObj->destBufSize = testPrms->destBufSize[chCnt];
815 chObj->ringMemSize = 0U;
816 chObj->trpdSize = 0U;
817 }
818 totalCh += taskObj->numCh;
819 GT_assert(testObj->traceMask, (totalCh <= UDMA_TEST_MAX_CH));
820 }
822 return;
823 }
825 static const UdmaTestChPrm *udmaTestGetChPrms(UdmaTestChPrmId chPrmId)
826 {
827 uint32_t index;
828 const UdmaTestChPrm *chPrms = NULL;
830 /* Search in channel table */
831 for(index = 0U; index < UDMA_TEST_NUM_CH_PRM; index++)
832 {
833 if(gUdmaTestChPrm[index].chPrmId == chPrmId)
834 {
835 chPrms = &gUdmaTestChPrm[index];
836 break;
837 }
838 }
840 return (chPrms);
841 }
843 static const Udma_ChTxPrms *udmaTestGetTxChPrms(UdmaTestTxChPrmId txChPrmId)
844 {
845 uint32_t index;
846 const Udma_ChTxPrms *txPrms = NULL;
848 /* Search in channel table */
849 for(index = 0U; index < UDMA_TEST_NUM_TX_CH_PRM; index++)
850 {
851 if(gUdmaTestTxChPrm[index].txChPrmId == txChPrmId)
852 {
853 txPrms = &gUdmaTestTxChPrm[index].txPrms;
854 break;
855 }
856 }
858 return (txPrms);
859 }
861 static const Udma_ChRxPrms *udmaTestGetRxChPrms(UdmaTestRxChPrmId rxChPrmId)
862 {
863 uint32_t index;
864 const Udma_ChRxPrms *rxPrms = NULL;
866 /* Search in channel table */
867 for(index = 0U; index < UDMA_TEST_NUM_RX_CH_PRM; index++)
868 {
869 if(gUdmaTestRxChPrm[index].rxChPrmId == rxChPrmId)
870 {
871 rxPrms = &gUdmaTestRxChPrm[index].rxPrms;
872 break;
873 }
874 }
876 return (rxPrms);
877 }
879 static const Udma_ChUtcPrms *udmaTestGetUtcChPrms(UdmaTestUtcChPrmId utcChPrmId)
880 {
881 uint32_t index;
882 const Udma_ChUtcPrms *utcPrms = NULL;
884 /* Search in channel table */
885 for(index = 0U; index < UDMA_TEST_NUM_UTC_CH_PRM; index++)
886 {
887 if(gUdmaTestUtcChPrm[index].utcChPrmId == utcChPrmId)
888 {
889 utcPrms = &gUdmaTestUtcChPrm[index].utcPrms;
890 break;
891 }
892 }
894 return (utcPrms);
895 }
897 static const Udma_ChPdmaPrms *udmaTestGetPdmaChPrms(UdmaTestPdmaChPrmId pdmaChPrmId)
898 {
899 uint32_t index;
900 const Udma_ChPdmaPrms *pdmaPrms = NULL;
902 /* Search in channel table */
903 for(index = 0U; index < UDMA_TEST_NUM_PDMA_CH_PRM; index++)
904 {
905 if(gUdmaTestPdmaChPrm[index].pdmaChPrmId == pdmaChPrmId)
906 {
907 pdmaPrms = &gUdmaTestPdmaChPrm[index].pdmaPrms;
908 break;
909 }
910 }
912 return (pdmaPrms);
913 }
915 static const UdmaTestRingPrm *udmaTestGetRingPrms(UdmaTestRingPrmId ringPrmId)
916 {
917 uint32_t index;
918 const UdmaTestRingPrm *ringPrms = NULL;
920 /* Search in ring table */
921 for(index = 0U; index < UDMA_TEST_NUM_RING_PRM; index++)
922 {
923 if(gUdmaTestRingPrm[index].ringPrmId == ringPrmId)
924 {
925 ringPrms = &gUdmaTestRingPrm[index];
926 break;
927 }
928 }
930 return (ringPrms);
931 }
933 /**
934 * udmaTestGetTcIdx
935 */
936 static int32_t udmaTestGetTcIdx(uint32_t tcId)
937 {
938 int32_t tcIdx = -1;
939 uint32_t testCnt;
940 UdmaTestParams *testPrms;
942 testPrms = &gUdmaTestCases[0U];
943 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
944 {
945 if(testPrms->tcId == tcId)
946 {
947 tcIdx = testCnt;
948 break;
949 }
950 testPrms++;
951 }
953 return (tcIdx);
954 }
956 /**
957 * udmaTestCheckIfTestToBeSkipped
958 */
959 static bool udmaTestCheckIfTestToBeSkipped(UdmaTestObj *testObj,
960 UdmaTestParams *testPrms,
961 uint32_t tcType)
962 {
963 bool skipTest = FALSE;
965 /* Check whether test case is disabled */
966 if(FALSE == testPrms->enableTest)
967 {
968 GT_assert(testObj->traceMask, (NULL != testPrms->tcName));
969 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
970 GT_1trace(testObj->traceMask, GT_INFO,
971 " |TEST DISABLED|:: %d ::\r\n", testPrms->tcId);
972 GT_1trace(testObj->traceMask, GT_INFO,
973 " |TEST PARAM|:: %s ::\r\n", testPrms->tcName);
974 if(NULL != testPrms->disableInfo)
975 {
976 GT_1trace(testObj->traceMask, GT_INFO,
977 " |TEST DISABLE REASON|:: %s ::\r\n",
978 testPrms->disableInfo);
979 }
980 else
981 {
982 GT_0trace(testObj->traceMask, GT_INFO,
983 " |TEST DISABLE REASON|:: Not Provided!! ::\r\n");
984 }
986 testObj->disableCount++;
987 skipTest = TRUE; /* Skip test */
988 }
990 /* Ignore test case depending on test flag and selected option */
991 if((FALSE == skipTest) && (UDMA_TCT_MISC != testPrms->tcType))
992 {
993 if(!(tcType & testPrms->tcType))
994 {
995 testObj->skipCount++;
996 skipTest = TRUE; /* Skip test */
997 }
998 }
1000 /* Ignore test case depending on run flag */
1001 if(FALSE == skipTest)
1002 {
1003 if((testObj->runFlag & testPrms->runFlag) != testObj->runFlag)
1004 {
1005 testObj->skipCount++;
1006 skipTest = TRUE; /* Skip test */
1007 }
1008 }
1010 return (skipTest);
1011 }
1013 /**
1014 * udmaTestDisplayTestInfo
1015 */
1016 static int32_t udmaTestDisplayTestInfo(UdmaTestObj *testObj)
1017 {
1018 uint32_t sCnt, testCnt;
1019 char *runStatus;
1020 UdmaTestParams *testPrms;
1021 static char *enableDisableName[] = {"Disabled", "Enabled"};
1022 static char printBuf[UDMA_TEST_PRINT_BUFSIZE];
1024 /* Display test info */
1025 sCnt = 1;
1026 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
1027 GT_0trace(
1028 testObj->traceMask, GT_INFO,
1029 " S.No ID Description "
1030 " Status Auto Run\r\n");
1031 GT_0trace(
1032 testObj->traceMask, GT_INFO,
1033 " ---------------------------------------------------------------------"
1034 "------------------------------------------------\r\n");
1035 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
1036 {
1037 testPrms = &gUdmaTestCases[testCnt];
1039 runStatus = "NRY";
1040 if(FALSE == testPrms->isRun)
1041 {
1042 if(FALSE == testPrms->enableTest)
1043 {
1044 runStatus = "NRQ";
1045 }
1046 if((testObj->runFlag & testPrms->runFlag) != testObj->runFlag)
1047 {
1048 runStatus = "NA";
1049 }
1050 }
1051 else
1052 {
1053 if(UDMA_SOK == testPrms->testResult)
1054 {
1055 runStatus = "PASS";
1056 }
1057 else
1058 {
1059 runStatus = "FAIL";
1060 }
1061 }
1063 GT_assert(testObj->traceMask, (NULL != testPrms->tcName));
1064 snprintf(printBuf, sizeof (printBuf),
1065 " %3d PDK-%-4d %-75.75s %-8.8s %-8.8s",
1066 sCnt,
1067 testPrms->tcId,
1068 testPrms->tcName,
1069 runStatus,
1070 enableDisableName[testPrms->enableTest]);
1071 GT_1trace(testObj->traceMask, GT_INFO, "%s\r\n", printBuf);
1073 sCnt++;
1074 }
1075 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
1077 return (UDMA_SOK);
1078 }
1080 /**
1081 * udmaTestGenerateTestReports
1082 */
1083 static int32_t udmaTestGenerateTestReports(UdmaTestObj *testObj)
1084 {
1085 uint32_t sCnt, testCnt;
1086 char *runStatus, *category, *adequacy;
1087 UdmaTestParams *testPrms;
1088 static char printBuf[UDMA_TEST_PRINT_BUFSIZE];
1090 sCnt = 1;
1091 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
1092 GT_0trace(
1093 testObj->traceMask, GT_INFO,
1094 "S.No;ID;Requirement Mapping;Description;Pass Fail Criteria;"
1095 "IR;Category;Test Adequacy;Test Result;\r\n");
1096 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
1097 {
1098 testPrms = &gUdmaTestCases[testCnt];
1100 runStatus = "NRY";
1101 if(FALSE == testPrms->isRun)
1102 {
1103 if(FALSE == testPrms->enableTest)
1104 {
1105 runStatus = "NRQ";
1106 }
1107 if((testObj->runFlag & testPrms->runFlag) != testObj->runFlag)
1108 {
1109 runStatus = "NA";
1110 }
1111 }
1112 else
1113 {
1114 if(UDMA_SOK == testPrms->testResult)
1115 {
1116 runStatus = "PASS";
1117 }
1118 else
1119 {
1120 runStatus = "FAIL";
1121 }
1122 }
1124 if(testPrms->tcType & UDMA_TCT_FULL)
1125 {
1126 category = "Full";
1127 }
1128 else if(testPrms->tcType & UDMA_TCT_REGRESSION)
1129 {
1130 category = "Regression";
1131 }
1132 else
1133 {
1134 category = "Sanity";
1135 }
1137 if(testPrms->tcType & UDMA_TCT_STRESS)
1138 {
1139 adequacy = "Stress";
1140 }
1141 else if(testPrms->tcType & UDMA_TCT_NEGATIVE)
1142 {
1143 adequacy = "Negative";
1144 }
1145 else if(testPrms->tcType & UDMA_TCT_PERFORMANCE)
1146 {
1147 adequacy = "Performance";
1148 }
1149 else if(testPrms->tcType & UDMA_TCT_MISC)
1150 {
1151 adequacy = "Misc";
1152 }
1153 else if(testPrms->tcType & UDMA_TCT_API)
1154 {
1155 adequacy = "Api";
1156 }
1157 else
1158 {
1159 adequacy = "Functional";
1160 }
1162 GT_assert(testObj->traceMask, (NULL != testPrms->tcName));
1163 snprintf(printBuf, sizeof (printBuf),
1164 "%d;PDK-%d;%s;;%s;%s;%s",
1165 sCnt,
1166 testPrms->tcId,
1167 testPrms->tcName,
1168 category,
1169 adequacy,
1170 runStatus);
1171 GT_1trace(testObj->traceMask, GT_INFO, "%s\r\n", printBuf);
1172 sCnt++;
1173 }
1174 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
1176 return (UDMA_SOK);
1177 }
1179 /**
1180 * udmaTestMenuSettings
1181 */
1182 static void udmaTestMenuSettings(UdmaTestObj *testObj)
1183 {
1184 char option;
1185 bool done = FALSE;
1186 int32_t value;
1187 UdmaTestSystemCtrl *sysCtrl = &testObj->sysCtrl;
1189 udmaTestMenuSettingsShow(testObj);
1191 while(!done)
1192 {
1193 GT_0trace(testObj->traceMask, GT_INFO, " Enter Choice: \r\n");
1194 option = AppUtils_getChar();
1196 switch(option)
1197 {
1198 case 'd':
1199 case 'D':
1200 GT_0trace(testObj->traceMask, GT_INFO,
1201 " Queue count: \r\n");
1202 value = AppUtils_getNum();
1204 if(value != USE_DEF_QDEPTH)
1205 {
1206 sysCtrl->qdepth = value;
1207 }
1208 else
1209 {
1210 GT_0trace(
1211 testObj->traceMask, GT_INFO,
1212 " This matches with default flag, give another value\r\n");
1213 }
1214 break;
1216 case 'l':
1217 case 'L':
1218 GT_0trace(testObj->traceMask, GT_INFO,
1219 " Loop count: \r\n");
1220 value = AppUtils_getNum();
1222 if(value != USE_DEF_LP_CNT)
1223 {
1224 sysCtrl->loopCnt = value;
1225 }
1226 else
1227 {
1228 GT_0trace(
1229 testObj->traceMask, GT_INFO,
1230 " This matches with default flag, give another value\r\n");
1231 }
1232 break;
1234 case 'r':
1235 case 'R':
1236 GT_0trace(testObj->traceMask, GT_INFO,
1237 " Runtime Print Enable [0: Disable, 1: Enable]: \r\n");
1238 value = AppUtils_getNum();
1240 sysCtrl->rtPrintEnable = FALSE;
1241 if(1 == value)
1242 {
1243 sysCtrl->rtPrintEnable = TRUE;
1244 }
1245 break;
1247 case 'q':
1248 case 'Q':
1249 done = TRUE;
1250 break;
1251 }
1252 fflush(stdin);
1253 }
1255 return;
1256 }
1258 /**
1259 * udmaTestMenuMainShow
1260 */
1261 static void udmaTestMenuMainShow(UdmaTestObj *testObj)
1262 {
1263 GT_0trace(testObj->traceMask, GT_INFO, gUdmaTestMenuMain0);
1264 udmaTestMenuCurrentSettingsShow(testObj);
1265 GT_0trace(testObj->traceMask, GT_INFO, gUdmaTestMenuMain1);
1267 return;
1268 }
1270 /**
1271 * udmaTestMenuSettingsShow
1272 */
1273 static void udmaTestMenuSettingsShow(UdmaTestObj *testObj)
1274 {
1275 GT_0trace(testObj->traceMask, GT_INFO, gUdmaTestMenuSettings0);
1276 udmaTestMenuCurrentSettingsShow(testObj);
1277 GT_0trace(testObj->traceMask, GT_INFO, gUdmaTestMenuSettings1);
1279 return;
1280 }
1282 /**
1283 * udmaTestMenuCurrentSettingsShow
1284 */
1285 static void udmaTestMenuCurrentSettingsShow(UdmaTestObj *testObj)
1286 {
1287 static char *enableDisableName[] = {"OFF", "ON"};
1288 UdmaTestSystemCtrl *sysCtrl = &testObj->sysCtrl;
1290 GT_0trace(testObj->traceMask, GT_INFO, "\r\n Current System Settings:");
1291 GT_0trace(testObj->traceMask, GT_INFO, "\r\n ------------------------");
1293 GT_1trace(testObj->traceMask, GT_INFO,
1294 "\r\n Loop Count : %d", sysCtrl->loopCnt);
1295 GT_1trace(testObj->traceMask, GT_INFO,
1296 "\r\n Queue Depth : %d", sysCtrl->qdepth);
1297 GT_1trace(testObj->traceMask, GT_INFO,
1298 "\r\n Runtime Print : %s",
1299 enableDisableName[sysCtrl->rtPrintEnable]);
1300 GT_0trace(testObj->traceMask, GT_INFO, "\r\n ");
1302 return;
1303 }
1305 /**
1306 * udmaTestSetDefaultCfg
1307 */
1308 static void udmaTestSetDefaultCfg(UdmaTestObj *testObj)
1309 {
1310 uint32_t testCnt;
1311 UdmaTestParams *testPrms;
1313 memset(testObj, 0, sizeof(UdmaTestObj));
1314 testObj->traceMask = (GT_INFO1 | GT_TraceState_Enable);
1315 testObj->sysCtrl.loopCnt = UDMA_TEST_DEF_LOOP_CNT;
1316 testObj->sysCtrl.qdepth = UDMA_TEST_DEF_QDEPTH;
1317 #if defined (UDMA_UT_DYNAMIC_ANALYSIS)
1318 testObj->sysCtrl.loopCnt = 1U;
1319 testObj->sysCtrl.qdepth = 1U;
1320 #endif
1321 testObj->sysCtrl.rtPrintEnable = FALSE;
1323 /* Set run flag */
1324 testObj->runFlag = 0U;
1325 testObj->runFlag |= UDMA_TEST_RF_SOC;
1326 testObj->runFlag |= UDMA_TEST_RF_CORE;
1327 testObj->runFlag |= UDMA_TEST_RF_CFG_DEF;
1328 #if defined (UDMA_UT_DYNAMIC_ANALYSIS)
1329 testObj->runFlag |= UDMA_TEST_RF_CFG_DYN;
1330 #endif
1332 /* Mark all test cases as not run and set result to PASS */
1333 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
1334 {
1335 testPrms = &gUdmaTestCases[testCnt];
1336 testPrms->isRun = FALSE;
1337 testPrms->testResult = UDMA_SOK;
1338 }
1340 return;
1341 }
1343 /**
1344 * \brief Return the test ID to run.
1345 */
1346 static uint32_t udmaTestGetTestId(UdmaTestObj *testObj, uint32_t tcType)
1347 {
1348 uint32_t testCnt;
1349 static int32_t testId = 0U;
1350 UdmaTestParams *testPrms;
1352 GT_0trace(testObj->traceMask, GT_INFO, "\r\n");
1353 GT_0trace(testObj->traceMask, GT_INFO,
1354 " --------------------------------------\n");
1355 GT_0trace(testObj->traceMask, GT_INFO,
1356 " Select test to run as per below table:\n");
1357 GT_0trace(testObj->traceMask, GT_INFO,
1358 " --------------------------------------\n");
1359 GT_0trace(testObj->traceMask, GT_INFO, " \n");
1360 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
1361 {
1362 testPrms = &gUdmaTestCases[testCnt];
1363 if(FALSE != testPrms->enableTest && (tcType & testPrms->tcType))
1364 {
1365 GT_assert(testObj->traceMask, (NULL != testPrms->tcName));
1366 GT_2trace(testObj->traceMask, GT_INFO,
1367 "%5d: %s\n", gUdmaTestCases[testCnt].tcId,
1368 gUdmaTestCases[testCnt].tcName);
1369 }
1370 }
1371 GT_0trace(testObj->traceMask, GT_INFO, " \n");
1372 GT_0trace(testObj->traceMask, GT_INFO,
1373 " Enter Test to Run (Use UART1 console for all cores or MCU_UART1 console for MCU) \n");
1375 while(1U)
1376 {
1377 testId = AppUtils_getNum();
1378 GT_1trace(testObj->traceMask, GT_INFO, "%d\n", testId);
1379 for(testCnt = 0U; testCnt < UDMA_TEST_NUM_TESTCASES; testCnt++)
1380 {
1381 if((tcType & UDMA_TCT_FULL) && (tcType != UDMA_TCT_ALL))
1382 {
1383 if(0U == testId)
1384 {
1385 break;
1386 }
1387 }
1388 if(testId == gUdmaTestCases[testCnt].tcId)
1389 {
1390 break;
1391 }
1392 }
1394 if(testCnt == UDMA_TEST_NUM_TESTCASES)
1395 {
1396 GT_0trace(testObj->traceMask, GT_INFO,
1397 "Invalid Test ID. Enter Again!!\n");
1398 }
1399 else
1400 {
1401 break;
1402 }
1403 }
1405 return (testId);
1406 }
1408 void udmaDrvPrint(const char *str)
1409 {
1410 udmaTestPrint(str);
1412 return;
1413 }
1415 void udmaTestPrint(const char *str, ...)
1416 {
1417 if(NULL != gUdmaTestUtObj.lockSem)
1418 {
1419 SemaphoreP_pend(gUdmaTestUtObj.lockSem, SemaphoreP_WAIT_FOREVER);
1420 }
1422 UART_printf("%s", str);
1424 if(TRUE == Udma_appIsPrintSupported())
1425 {
1426 printf("%s", str);
1427 }
1429 if(NULL != gUdmaTestUtObj.lockSem)
1430 {
1431 SemaphoreP_post(gUdmaTestUtObj.lockSem);
1432 }
1434 return;
1435 }