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