packages/ti/diag/sdr/test/sdtf-test/src/sdtf_test.c

   1 /*
   2  * SDR TEST
   3  *
   4  * Software Diagnostics Reference Test
   5  *
   6  *  Copyright (c) Texas Instruments Incorporated 2018-2020
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions
  10  *  are met:
  11  *
  12  *    Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  *    Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  *    Neither the name of Texas Instruments Incorporated nor the names of
  21  *    its contributors may be used to endorse or promote products derived
  22  *    from this software without specific prior written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #include <sdr_common.h>
  41 #include <sdr_ecc.h>
  42 #include <sdr_esm.h>
  43
  44 #include <ti/drv/uart/src/UART_utils_defs.h>
  45 #include <ti/drv/uart/UART_stdio.h>
  46 #include <ti/drv/uart/UART.h>
  47
  48 #include "sdtf_common.h"
  49 #include "sdtf_esm.h"
  50 #include "sdtf_ecc.h"
  51 #include "sdtf_profile.h"
  52 #include "sdtf_test.h"
  53 #include "sdtf_errortype.h"
  54 #include "sdtf_injecterr.h"
  55 #include "sdtf_wdt.h"
  56 #include "sdtf_rat.h"
  57 #include "sdtf_ccm.h"
  58 #include "sdtf_crc.h"
  59 #include "sdtf_mpu.h"
  60 #include "sdtf_exception.h"
  61
  62 #define SDTF_MAX_PERIODIC_TEST_RUN 10
  63
  64 #define SDTF_PERIODIC_TASK_TRIGGER_OFF (0u)
  65 #define SDTF_PERIODIC_TASK_TRIGGER_ENABLE (1u)
  66
  67 /* Global variables */
  68 static uint32_t SDTF_periodicTaskCount=0;
  69 static uint32_t SDTF_interactiveTaskCount=0;
  70 static uint32_t SDTF_periodicExecutionTimeMin=0xffffffffu, SDTF_periodicExecutionTimeMax=0u;
  71 static uint32_t SDTF_periodicExecutionTime, SDTF_periodicExecutionTimeAvg;
  72 static uint32_t SDTF_periodicExecutionFirstTime=0;
  73
  74 /* Flag to track all tasks ended */
  75 volatile uint32_t SDTF_allTasksEnded=0u;
  76 volatile uint32_t SDTF_periodTaskTrigger = 0u;
  77
  78 #ifdef UNITY_INCLUDE_CONFIG_H
  79 #include <ti/build/unit-test/Unity/src/unity.h>
  80 #include <ti/build/unit-test/config/unity_config.h>
  81 #endif
  82
  83 /*********************************************************************
  84  * @fn      SDTF_oneShotTestAllModules
  85  *
  86   * @brief   Executes all one shot tests
  87  *
  88  * @param   None
  89  *
  90  * @return  0 : Success; < 0 for failures
  91  */
  92
  93 int32_t SDTF_oneShotTestAllModules(void)
  94 {
  95
  96     SDR_ECC_InjectErrorConfig_t injectErrorConfig;
  97     SDR_Result result;
  98
  99     SDTF_printf("\nStarting: One Shot tests");
 100
 101     SDTF_printf("\n Starting: ATCM Double bit error fixed location once test ");
 102
 103     SDTF_profileBegin(SDTF_PROFILE_ONESHOT);
 104     /* -------------- OneShot Tests start ------------------------- */
 105     /* Run one shot test for ATCM 2 bit error */
 106     /* Note the address is relative to start of ram */
 107     injectErrorConfig.pErrMem = (uint32_t *)(0x200u);
 108
 109     injectErrorConfig.flipBitMask = 0x101;
 110     result = SDR_ECC_selfTest(SDR_ECC_MEMTYPE_MCU_R5F0_CORE,
 111                               SDR_ECC_R5F_MEM_SUBTYPE_ATCM0_BANK0_VECTOR_ID,
 112                               SDR_INJECT_ECC_ERROR_FORCING_2BIT_ONCE,
 113                               &injectErrorConfig,
 114                               1000);
 115     SDTF_profileEnd(SDTF_PROFILE_ONESHOT);
 116
 117     if (result != SDR_PASS ) {
 118         SDTF_printf("\n ATCM Double bit error: at pErrMem 0x%p: fixed location once test failed",
 119                     injectErrorConfig.pErrMem);
 120         return -1;
 121     }
 122     SDTF_printf("\n ATCM Double bit error: pErrMem 0x%p fixed location once test complete",
 123                 injectErrorConfig.pErrMem);
 124     SDTF_printf("\n Cycles taken %u", SDTF_profileDelta(SDTF_PROFILE_ONESHOT));
 125
 126     SDTF_printf("\n Starting: ATCM Single bit error test");
 127
 128     SDTF_profileBegin(SDTF_PROFILE_ONESHOT);
 129     /* Note the address is relative to start of ram */
 130     injectErrorConfig.pErrMem = (uint32_t *)(0x00);
 131
 132     /* Run one shot test for ATCM 1 bit error */
 133     injectErrorConfig.flipBitMask = 0x10;
 134     result = SDR_ECC_selfTest(SDR_ECC_MEMTYPE_MCU_R5F0_CORE,
 135                                     SDR_ECC_R5F_MEM_SUBTYPE_ATCM0_BANK0_VECTOR_ID,
 136                                     SDR_INJECT_ECC_ERROR_FORCING_1BIT_ONCE,
 137                                     &injectErrorConfig,
 138                                     100000);
 139     SDTF_profileEnd(SDTF_PROFILE_ONESHOT);
 140     if (result != SDR_PASS ) {
 141         SDTF_printf("\n ATCM Single bit error at pErrMem 0x%p test failed",
 142                     injectErrorConfig.pErrMem);
 143         return -1;
 144     }
 145     SDTF_printf("\n ATCM Single bit error  at pErrMem 0x%p: test complete",
 146                 injectErrorConfig.pErrMem);
 147     SDTF_printf("\n Cycles taken %u", SDTF_profileDelta(SDTF_PROFILE_ONESHOT));
 148
 149     SDTF_printf("\n Starting: ESM test");
 150     SDTF_profileBegin(SDTF_PROFILE_ONESHOT);
 151     /* Run one shot self test of ESM */
 152     result = SDR_ESM_selfTest(SDR_ESM_INSTANCE_MCU, 1000);
 153     SDTF_profileEnd(SDTF_PROFILE_ONESHOT);
 154     if (result != SDR_PASS ) {
 155         SDTF_printf("\n ESM self test failed");
 156         return -1;
 157     }
 158     SDTF_printf("\n ESM Self test complete");
 159     SDTF_printf("\n Cycles taken %u", SDTF_profileDelta(SDTF_PROFILE_ONESHOT));
 160
 161     /* -------------- OneShot Tests end ------------------------- */
 162     SDTF_printf("\nOne shot tests complete");
 163
 164     return 0;
 165 }
 166
 167
 168 /*********************************************************************
 169  * @fn      SDTF_configPeriodicTests
 170  *
 171  * @brief   Execute all the configured periodic tests
 172  *
 173  * @param   periodicConfig - configuration structure for periodic tests
 174  *
 175  * @return  0 : Success; < 0 for failures
 176  */
 177 int32_t SDTF_configPeriodicTests(SDTF_periodic_config_t periodic_config)
 178 {
 179     /* Reset periodic Task count */
 180     SDTF_periodicTaskCount=0;
 181
 182     /* Reset flag for periodic tests */
 183     SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_OFF;
 184
 185     return 0;
 186 }
 187 /*********************************************************************
 188  * @fn      SDTF_triggerPeriodicTests
 189  *
 190  * @brief   Trigger the periodic tests
 191  *
 192  * @param   arg: Input argument
 193 *
 194 * @return  None
 195 */
 196 void SDTF_triggerPeriodicTests(uintptr_t arg)
 197 {
 198     volatile uintptr_t storeArg = arg;
 199
 200     /* Set the flag to trigger periodic tests */
 201     SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_ENABLE;
 202
 203     /* Feed watchdog timer */
 204     SDTF_WDT_feedWatchdogTimer();
 205 }
 206 /*********************************************************************
 207  * @fn      SDTF_runPeriodicTests
 208  *
 209  * @brief   Execute all the configured periodic tests
 210  *
 211  * @param   None
 212 *
 213 * @return  0 : Success; < 0 for failures
 214 */
 215 int32_t SDTF_runPeriodicTests(void)
 216 {
 217     SDR_Result result;
 218
 219     if (( SDTF_periodTaskTrigger == SDTF_PERIODIC_TASK_TRIGGER_ENABLE)
 220         && (SDTF_allTasksEnded != 1u) ) {
 221
 222         /* Increment task count */
 223         SDTF_periodicTaskCount++;
 224
 225         /* If max runs are reached print results */
 226         if (SDTF_periodicTaskCount >= SDTF_MAX_PERIODIC_TEST_RUN) {
 227             /* Mark all tasks_ended */
 228             SDTF_allTasksEnded = 1u;
 229             SDTF_printf("\n Periodic Tests: Cycle measurements");
 230             SDTF_printf("\n Min: %d, Max %d Avg %d Last %d",
 231                         SDTF_periodicExecutionTimeMin, SDTF_periodicExecutionTimeMax,
 232                         SDTF_periodicExecutionTimeAvg, SDTF_periodicExecutionTime);
 233
 234         }
 235
 236         SDTF_profileBegin(SDTF_PROFILE_PERIODIC);
 237         /* -------------- Periodic Test start ------------------------- */
 238         {
 239             /* Run test for ECC */
 240             SDR_ECC_InjectErrorConfig_t injectErrorConfig;
 241
 242             /* Note the address is relative to start of ram */
 243             injectErrorConfig.pErrMem = (uint32_t *)(0x00);
 244
 245             /* Run one shot test for ATCM 1 bit error */
 246             injectErrorConfig.flipBitMask = 0x10;
 247             result = SDR_ECC_selfTest(SDR_ECC_MEMTYPE_MCU_R5F0_CORE,
 248                                            SDR_ECC_R5F_MEM_SUBTYPE_ATCM0_BANK0_VECTOR_ID,
 249                                            SDR_INJECT_ECC_ERROR_FORCING_1BIT_ONCE,
 250                                            &injectErrorConfig,
 251                                            100000);
 252
 253
 254             if (result != SDR_PASS ) {
 255                 SDTF_printf("\n ATCM Single bit error at pErrMem 0x%p test failed",
 256                             injectErrorConfig.pErrMem);
 257                 return -1;
 258              }
 259         }
 260         {
 261              /* Run esm test 1*/
 262              result = SDR_ESM_selfTest(SDR_ESM_INSTANCE_MCU,1000);
 263              if (result != SDR_PASS ) {
 264                  SDTF_printf("\n ESM self test 1 failed");
 265                  return -1;
 266              }
 267         }
 268
 269         /* -------------- Periodic Tests end ------------------------- */
 270         SDTF_profileEnd(SDTF_PROFILE_PERIODIC);
 271
 272         /* Get the time taken for periodic tests */
 273         SDTF_periodicExecutionTime = SDTF_profileDelta(SDTF_PROFILE_PERIODIC);
 274         /* First time initialiaze average data */
 275         if (SDTF_periodicExecutionFirstTime == 0u) {
 276             SDTF_periodicExecutionTimeAvg = SDTF_periodicExecutionFirstTime;
 277             SDTF_periodicExecutionFirstTime = 1u;
 278         }
 279         /* Record the minimum, maximum and average values of time taken */
 280         if (SDTF_periodicExecutionTime < SDTF_periodicExecutionTimeMin) {
 281             SDTF_periodicExecutionTimeMin = SDTF_periodicExecutionTime;
 282         }
 283         if (SDTF_periodicExecutionTime > SDTF_periodicExecutionTimeMax) {
 284             SDTF_periodicExecutionTimeMax = SDTF_periodicExecutionTime;
 285         }
 286         SDTF_periodicExecutionTimeAvg = (SDTF_periodicExecutionTimeAvg + SDTF_periodicExecutionTime) >> 1u;
 287
 288         /* Clear flag which triggered periodic task */
 289         SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_OFF;
 290     }
 291     return 0;
 292 }
 293
 294 /* Maxumum number of special commands
 295  * Should match number of items in the special commands array below
 296  */
 297 #define SDTF_MAX_SPECIAL_COMMANDS (5u)
 298
 299 #ifdef SOC_AM65XX
 300 /* Number of commands run by the "run_all" command
 301  * Note: This should match number of entries in the tables below
 302  */
 303 #define SDTF_NUM_RUNALL_TEST_COMMANDS (41u)
 304
 305 /* Other commands not covered by run_all */
 306 #define SDTF_NUM_OTHER_TEST_COMMANDS (0u)
 307 #endif
 308
 309 #ifdef SOC_J721E
 310 /* Number of commands run by the "run_all" command
 311  * Note: This should match number of entries in the tables below
 312  */
 313 #define SDTF_NUM_RUNALL_TEST_COMMANDS (39u)
 314
 315 /* Other commands not covered by run_all */
 316 #define SDTF_NUM_OTHER_TEST_COMMANDS (0u)
 317 #endif
 318
 319 /* Maxumum number of commands
 320  * Note: This should match maximumum number of entries in the tables below
 321  */
 322 #define SDTF_MAX_COMMANDS (SDTF_NUM_RUNALL_TEST_COMMANDS+SDTF_NUM_OTHER_TEST_COMMANDS)
 323
 324 #define SDTF_MAX_COMMAND_LEN (64u)
 325
 326 /* prototype type for test functions */
 327 typedef int32_t (* SDTF_testFunctionPtr_t) (void);
 328
 329 typedef struct SDTF_commandList_s
 330 {
 331     char commandString[SDTF_MAX_COMMAND_LEN+1];
 332     SDTF_testFunctionPtr_t commandFunction;
 333 }SDTF_commandList_t;
 334
 335 /* Full list of commands */
 336 SDTF_commandList_t SDTF_commandList[SDTF_MAX_COMMANDS] =
 337 {
 338     { "esm_selftest_MCU",            SDTF_runESMSelfTest_MCU},
 339     { "esm_inject_MCU",              SDTF_runESMInject_MCU },
 340     { "esm_apitest_MCU",             SDTF_runESMAPITest },
 341     { "esm_negativetest_MCU",        SDTF_runESMNegativeTest},
 342     { "esm_selftest_WKUP",           SDTF_runESMSelfTest_WKUP},
 343     { "esm_inject_WKUP",             SDTF_runESMInject_WKUP },
 344     { "esm_selftest_MAIN",           SDTF_runESMSelfTest_MAIN},
 345     { "esm_inject_MAIN",             SDTF_runESMInject_MAIN },
 346     { "ecc1_selftest",               SDTF_runECC1BitSelfTest },
 347     { "ecc2_selftest",               SDTF_runECC2BitSelfTest },
 348     { "ecc2_inject",                 SDTF_runECC2BitInjectTest },
 349     { "ecc1_b0tcm0selftest",         SDTF_runECC1BitB0TCM0Bank0SelfTest },
 350     { "ecc2_b0tcm0selftest",         SDTF_runECC2BitB0TCM0Bank0SelfTest },
 351     { "ecc1_b0tcm0_b1selftest",      SDTF_runECC1BitB0TCM0Bank1SelfTest },
 352     { "ecc2_b0tcm0_b1selftest",      SDTF_runECC2BitB0TCM0Bank1SelfTest },
 353     { "ecc1_b1tcm0selftest",         SDTF_runECC1BitB1TCM0Bank0SelfTest },
 354     { "ecc2_b1tcm0selftest",         SDTF_runECC2BitB1TCM0Bank0SelfTest },
 355     { "ecc1_b1tcm0_b1selftest",      SDTF_runECC1BitB1TCM0Bank1SelfTest },
 356     { "ecc2_b1tcm0_b1selftest",      SDTF_runECC2BitB1TCM0Bank1SelfTest },
 357     { "ecc1_vimraminject",           SDTF_runECC1BitVIMRAMInjectTest },
 358     { "ecc2_vimraminject",           SDTF_runECC2BitVIMRAMInjectTest },
 359     { "ecc1_vimramselftest",         SDTF_runECC1BitVIMRAMSelfTest },
 360     { "ecc2_vimramselftest",         SDTF_runECC2BitVIMRAMSelfTest },
 361     { "crc_selftest",                SDTF_runCRCSelfTest },
 362     { "crc_negativetest",            SDTF_runCRCNegativeTest },
 363     { "mpu_selftest",                SDTF_runMPUSelfTest},
 364     { "wdt_selftestendviolation",    SDTF_runWDTSelfTestEndViolation },
 365     { "wdt_selftestwindowviolation", SDTF_runWDTSelfTestWindowViolation },
 366     { "wdt_negativetests",           SDTF_runWDTNegativeTests },
 367     { "RAT_test",                    SDTF_runtestRAT },
 368     { "ecc_runnegativetests",        SDTF_ECC_runNegativeTests },
 369     { "ecc2_programinject",          SDTF_runECC2BitCodeInjectTest },
 370     { "exception_runapitests",       SDTF_runExceptionApiTests },
 371     { "ecc1_inject",                 SDTF_runECC1BitInjectTest },
 372 #ifdef SOC_J721E
 373     { "cbass_1bitinject",            SDTF_runECC1BitCBASSInjectTest },
 374     { "cbass_1bitselftest",          SDTF_runECC1BitCBASSSelfTest },
 375     { "cbass_2bitinject",            SDTF_runECC2BitCBASSInjectTest },
 376     { "cbass_2bitselftest",          SDTF_runECC2BitCBASSSelfTest },
 377 #endif
 378 #ifdef SOC_AM65XX
 379     { "ccm_selftest",                SDTF_runCCMSelfTest },
 380     { "ccm_selftest_polarityinvert", SDTF_runCCMSelfTestErrorForce },
 381     { "ccm_vimselftest",             SDTF_runCCMVIMSelfTest },
 382     { "ccm_inactivityselftest",      SDTF_runCCMInactivitySelfTest },
 383     { "ccm_inject",                  SDTF_runCCMInjectError },
 384     { "ccm_selftest_errorforce",     SDTF_runCCMSelftestPolarityInvert },
 385 #endif
 386     /* This needs to be last as it is destructive */
 387     { "ecc2_vimramdedvector",        SDTF_runECC2BitVIMRAMDEDvector },
 388
 389
 390      /* The following tests are not covered by run all */
 391
 392 };
 393
 394 char SDTF_specialCommands[SDTF_MAX_SPECIAL_COMMANDS][SDTF_MAX_COMMAND_LEN+1] =
 395 {
 396     /* The following are special commands */
 397     "read_reg",
 398     "write_reg",
 399     "debug_test",
 400     "run_all",
 401     "help",
 402 };
 403
 404 /*********************************************************************
 405  * @fn      SDTF_runInteractiveTests
 406  *
 407  * @brief   Execute interactive tests
 408  *
 409  * @param   None
 410  *
 411  * @return  0 : Success; < 0 for failures
 412  */
 413 int32_t SDTF_runInteractiveTests(void)
 414 {
 415     char buffPointer[256];
 416     char echoPrompt[] = "\n Interactive test :Enter a command or Esc to quit >";
 417     char echoPrompt1[] = "Data received is:";
 418     uint32_t endInteractiveTestsFlag=0;
 419     int32_t retVal = 0;
 420     uint32_t i;
 421
 422     SDTF_interactiveTaskCount++;
 423
 424     while(endInteractiveTestsFlag == 0)
 425     {
 426         /* Print prompt to UART port */
 427         UART_printf(echoPrompt);
 428
 429         /* Scan input word from user */
 430         if (UART_scanFmt("%s", &buffPointer) != S_PASS)
 431         {
 432             SDTF_printf("\n ERROR: UART_scanFmt failed");
 433             endInteractiveTestsFlag = 1;
 434             continue;
 435         }
 436
 437         /* Check on word entered here */
 438         /* If needed a command parser can be added here */
 439         switch(buffPointer[0]) {
 440         case '\0': /*Ignore empty string */
 441             break;
 442
 443         case 27: /* Exit on ESC character */
 444             endInteractiveTestsFlag = 1;
 445             break;
 446
 447         default:
 448             /* Display prompt  */
 449             UART_printf(echoPrompt1);
 450             /* Display received word */
 451             UART_printf(buffPointer);
 452             /* Print new line */
 453             UART_printf("\n");
 454             break;
 455         }
 456
 457         /* Help command to display all commands */
 458         if (strncmp(buffPointer, "help", SDTF_MAX_COMMAND_LEN) == 0) {
 459             uint32_t i;
 460
 461             SDTF_printf("\n Here are the commands supported");
 462             for(i=0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
 463                 SDTF_printf("\n %s", SDTF_commandList[i].commandString);
 464             }
 465             SDTF_printf("\n --------------------------------");
 466             SDTF_printf("\n Other commands");
 467             for(; i< SDTF_MAX_COMMANDS; i++) {
 468                 SDTF_printf("\n %s", SDTF_commandList[i].commandString);
 469             }
 470             SDTF_printf("\n --------------------------------");
 471             SDTF_printf("\n Special commands");
 472             for(i=0u; i< SDTF_MAX_SPECIAL_COMMANDS; i++) {
 473                 SDTF_printf("\n %s", SDTF_specialCommands[i]);
 474             }
 475             SDTF_printf("\n --------------------------------");
 476             SDTF_printf("\n [ESC]<enter> to quit");
 477         }
 478
 479
 480         /* Help command to display all commands */
 481         if ((strncmp(buffPointer, "read_reg", SDTF_MAX_COMMAND_LEN) == 0)
 482             || (strncmp(buffPointer, "write_reg", SDTF_MAX_COMMAND_LEN) == 0)) {
 483             char buffPointer2[256];
 484             uintptr_t regAddress;
 485
 486             /* Print prompt to UART port */
 487             UART_printf("Enter address in hex: ");
 488
 489             /* Scan input word from user */
 490             if (UART_scanFmt("%s", &buffPointer2) != S_PASS)
 491             {
 492                 SDTF_printf("\n ERROR: UART_scanFmt failed");
 493                 endInteractiveTestsFlag = 1;
 494                 continue;
 495             }
 496             sscanf(buffPointer2, "%x", &regAddress);
 497
 498             if (strncmp(buffPointer, "read_reg", SDTF_MAX_COMMAND_LEN) == 0) {
 499                 SDTF_printf("\n Read value at 0x%x is 0x%x", regAddress, *((volatile uint32_t *)regAddress));
 500             } else {
 501                 char buffPointer3[256];
 502                 uint32_t regValue;
 503
 504                 /* Print prompt to UART port */
 505                 UART_printf("Enter value: ");
 506
 507                 /* Scan input word from user */
 508                 if (UART_scanFmt("%s", &buffPointer3) != S_PASS)
 509                 {
 510                     SDTF_printf("\n ERROR: UART_scanFmt failed");
 511                     endInteractiveTestsFlag = 1;
 512                     continue;
 513                 }
 514                 sscanf(buffPointer3, "%x", &regValue);
 515                 *((volatile uint32_t *)regAddress) = regValue;
 516                 SDTF_printf("\n Written address 0x%x with value: 0x%x read value 0x%x",
 517                             regAddress, regValue, *((volatile uint32_t *)regAddress));
 518             }
 519
 520         }
 521
 522         /* Command to Run all commands */
 523         if (strncmp(buffPointer, "debug_test", SDTF_MAX_COMMAND_LEN) == 0) {
 524             /* Add any debug test here */
 525
 526         }
 527         /* Command to Run all commands */
 528         if (strncmp(buffPointer, "run_all", SDTF_MAX_COMMAND_LEN) == 0) {
 529
 530             SDTF_printf("\n Running all test commands supported");
 531             for(i=0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
 532                 if (SDTF_commandList[i].commandFunction!= ((void *)(0u))) {
 533                     retVal = (*SDTF_commandList[i].commandFunction)();
 534                     if ( retVal != 0) {
 535                         break;
 536                     }
 537                 }
 538             }
 539         }
 540
 541         /* Search through all commands to execute appropriate functions */
 542         for(i=0u; i< SDTF_MAX_COMMANDS; i++) {
 543             if (strncmp(buffPointer, SDTF_commandList[i].commandString, SDTF_MAX_COMMAND_LEN) == 0) {
 544                 if (SDTF_commandList[i].commandFunction != ((void *)(0u))) {
 545                     retVal = (*SDTF_commandList[i].commandFunction)();
 546                     break;
 547                 }
 548             }
 549         }
 550         if (retVal < 0) {
 551             /* Print error message and check to continue*/
 552             UART_printf("\n Error occurred: Enter \"continue\" command to continue");
 553             /* Scan input word from user */
 554             if (UART_scanFmt("%s", &buffPointer) != S_PASS)
 555             {
 556                 SDTF_printf("\n ERROR: UART_scanFmt failed");
 557                 endInteractiveTestsFlag = 1;
 558                 continue;
 559             }
 560             /* If continue in spite of error */
 561              if (strncmp(buffPointer, "continue", SDTF_MAX_COMMAND_LEN) == 0) {
 562                  /* Reset return value, so that test can continue*/
 563                  retVal = 0;
 564                  continue;
 565              } else {
 566                  /* Else end test */
 567                  endInteractiveTestsFlag = 1;
 568                  continue;
 569              }
 570         }
 571     }
 572
 573     return retVal;
 574 }
 575
 576 /*********************************************************************
 577  * @fn      test_sdr_test
 578  *
 579  * @brief   Execute all sdr tests
 580  *
 581  * @param   None
 582  *
 583  * @return  None
 584  */
 585 void test_sdr_test(void)
 586 {
 587     /* Declarations of variables */
 588     int32_t retVal = 0;
 589     int32_t i;
 590
 591     SDTF_printf("\n Running all sdr test commands supported");
 592     for(i = 0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
 593         if (SDTF_commandList[i].commandFunction!= ((void *)(0u))) {
 594             retVal = (*SDTF_commandList[i].commandFunction)();
 595             if ( retVal != 0) {
 596                 break;
 597             }
 598         }
 599     }
 600
 601     if (retVal == 0)
 602     {
 603         UART_printStatus("\n All tests have passed. \n");
 604     }
 605     else
 606     {
 607         UART_printStatus("\n Few/all tests Failed \n");
 608     }
 609
 610 #if defined (UNITY_INCLUDE_CONFIG_H)
 611     TEST_ASSERT_EQUAL_INT32(0, retVal);
 612 #endif
 613 }