CCM test fail leading to sdr test failure
[processor-sdk/pdk.git] / 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>
40 #include <sdr_common.h>
41 #include <sdr_ecc.h>
42 #include <sdr_esm.h>
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>
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"
62 #define SDTF_MAX_PERIODIC_TEST_RUN 10
64 #define SDTF_PERIODIC_TASK_TRIGGER_OFF (0u)
65 #define SDTF_PERIODIC_TASK_TRIGGER_ENABLE (1u)
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;
74 /* Flag to track all tasks ended */
75 volatile uint32_t SDTF_allTasksEnded=0u;
76 volatile uint32_t SDTF_periodTaskTrigger = 0u;
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
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  */
93 int32_t SDTF_oneShotTestAllModules(void)
94 {
96     SDR_ECC_InjectErrorConfig_t injectErrorConfig;
97     SDR_Result result;
99     SDTF_printf("\nStarting: One Shot tests");
101     SDTF_printf("\n Starting: ATCM Double bit error fixed location once test ");
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);
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);
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));
126     SDTF_printf("\n Starting: ATCM Single bit error test");
128     SDTF_profileBegin(SDTF_PROFILE_ONESHOT);
129     /* Note the address is relative to start of ram */
130     injectErrorConfig.pErrMem = (uint32_t *)(0x00);
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));
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));
161     /* -------------- OneShot Tests end ------------------------- */
162     SDTF_printf("\nOne shot tests complete");
164     return 0; 
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)
179     /* Reset periodic Task count */
180     SDTF_periodicTaskCount=0;
182     /* Reset flag for periodic tests */
183     SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_OFF;
185     return 0; 
187 /*********************************************************************
188  * @fn      SDTF_triggerPeriodicTests
189  *
190  * @brief   Trigger the periodic tests
191  *
192  * @param   arg: Input argument
194 * @return  None
195 */
196 void SDTF_triggerPeriodicTests(uintptr_t arg)
198     volatile uintptr_t storeArg = arg;
200     /* Set the flag to trigger periodic tests */
201     SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_ENABLE;
203     /* Feed watchdog timer */
204     SDTF_WDT_feedWatchdogTimer();
206 /*********************************************************************
207  * @fn      SDTF_runPeriodicTests
208  *
209  * @brief   Execute all the configured periodic tests
210  *
211  * @param   None
213 * @return  0 : Success; < 0 for failures
214 */
215 int32_t SDTF_runPeriodicTests(void)
217     SDR_Result result;
219     if (( SDTF_periodTaskTrigger == SDTF_PERIODIC_TASK_TRIGGER_ENABLE)
220         && (SDTF_allTasksEnded != 1u) ) {
222         /* Increment task count */
223         SDTF_periodicTaskCount++;
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);
234         }
236         SDTF_profileBegin(SDTF_PROFILE_PERIODIC);
237         /* -------------- Periodic Test start ------------------------- */
239         /* Run test for ECC */
240         SDR_ECC_InjectErrorConfig_t injectErrorConfig;
242             /* Note the address is relative to start of ram */
243         injectErrorConfig.pErrMem = (uint32_t *)(0x00);
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);
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         }
260         /* Run esm test 1*/
261         result = SDR_ESM_selfTest(SDR_ESM_INSTANCE_MCU,1000);
262         if (result != SDR_PASS ) {
263             SDTF_printf("\n ESM self test 1 failed");
264             return -1;
265         }
267         /* -------------- Periodic Tests end ------------------------- */
268         SDTF_profileEnd(SDTF_PROFILE_PERIODIC);
270         /* Get the time taken for periodic tests */
271         SDTF_periodicExecutionTime = SDTF_profileDelta(SDTF_PROFILE_PERIODIC);
272         /* First time initialiaze average data */
273         if (SDTF_periodicExecutionFirstTime == 0u) {
274             SDTF_periodicExecutionTimeAvg = SDTF_periodicExecutionFirstTime;
275             SDTF_periodicExecutionFirstTime = 1u;
276         }
277         /* Record the minimum, maximum and average values of time taken */
278         if (SDTF_periodicExecutionTime < SDTF_periodicExecutionTimeMin) {
279             SDTF_periodicExecutionTimeMin = SDTF_periodicExecutionTime;
280         }
281         if (SDTF_periodicExecutionTime > SDTF_periodicExecutionTimeMax) {
282             SDTF_periodicExecutionTimeMax = SDTF_periodicExecutionTime;
283         }
284         SDTF_periodicExecutionTimeAvg = (SDTF_periodicExecutionTimeAvg + SDTF_periodicExecutionTime) >> 1u;
286         /* Clear flag which triggered periodic task */
287         SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_OFF;
288     }
289     return 0; 
292 /* Maxumum number of special commands
293  * Should match number of items in the special commands array below
294  */
295 #define SDTF_MAX_SPECIAL_COMMANDS (5u)
297 #ifdef SOC_AM65XX
298 /* Number of commands run by the "run_all" command
299  * Note: This should match number of entries in the tables below
300  */
301 #define SDTF_NUM_RUNALL_TEST_COMMANDS (36u)
303 /* Other commands not covered by run_all */
304 #define SDTF_NUM_OTHER_TEST_COMMANDS (0u)
305 #endif
307 #ifdef SOC_J721E
308 /* Number of commands run by the "run_all" command
309  * Note: This should match number of entries in the tables below
310  */
311 #define SDTF_NUM_RUNALL_TEST_COMMANDS (39u)
313 /* Other commands not covered by run_all */
314 #define SDTF_NUM_OTHER_TEST_COMMANDS (0u)
315 #endif
317 /* Maxumum number of commands
318  * Note: This should match maximumum number of entries in the tables below
319  */
320 #define SDTF_MAX_COMMANDS (SDTF_NUM_RUNALL_TEST_COMMANDS+SDTF_NUM_OTHER_TEST_COMMANDS)
322 #define SDTF_MAX_COMMAND_LEN (64u)
324 /* prototype type for test functions */
325 typedef int32_t (* SDTF_testFunctionPtr_t) (void);
327 typedef struct SDTF_commandList_s
329     char commandString[SDTF_MAX_COMMAND_LEN+1];
330     SDTF_testFunctionPtr_t commandFunction;
331 }SDTF_commandList_t;
333 /* Full list of commands */
334 SDTF_commandList_t SDTF_commandList[SDTF_MAX_COMMANDS] =
336     { "esm_selftest_MCU",            SDTF_runESMSelfTest_MCU},
337     { "esm_inject_MCU",              SDTF_runESMInject_MCU },
338     { "esm_apitest_MCU",             SDTF_runESMAPITest },
339     { "esm_negativetest_MCU",        SDTF_runESMNegativeTest},
340     { "esm_selftest_WKUP",           SDTF_runESMSelfTest_WKUP},
341     { "esm_inject_WKUP",             SDTF_runESMInject_WKUP },
342     { "esm_selftest_MAIN",           SDTF_runESMSelfTest_MAIN},
343     { "esm_inject_MAIN",             SDTF_runESMInject_MAIN },
344     { "ecc1_selftest",               SDTF_runECC1BitSelfTest },
345     { "ecc2_selftest",               SDTF_runECC2BitSelfTest },
346     { "ecc2_inject",                 SDTF_runECC2BitInjectTest },
347     { "ecc1_b0tcm0selftest",         SDTF_runECC1BitB0TCM0Bank0SelfTest },
348     { "ecc2_b0tcm0selftest",         SDTF_runECC2BitB0TCM0Bank0SelfTest },
349     { "ecc1_b0tcm0_b1selftest",      SDTF_runECC1BitB0TCM0Bank1SelfTest },
350     { "ecc2_b0tcm0_b1selftest",      SDTF_runECC2BitB0TCM0Bank1SelfTest },
351     { "ecc1_b1tcm0selftest",         SDTF_runECC1BitB1TCM0Bank0SelfTest },
352     { "ecc2_b1tcm0selftest",         SDTF_runECC2BitB1TCM0Bank0SelfTest },
353     { "ecc1_b1tcm0_b1selftest",      SDTF_runECC1BitB1TCM0Bank1SelfTest },
354     { "ecc2_b1tcm0_b1selftest",      SDTF_runECC2BitB1TCM0Bank1SelfTest },
355     { "ecc1_vimraminject",           SDTF_runECC1BitVIMRAMInjectTest },
356     { "ecc2_vimraminject",           SDTF_runECC2BitVIMRAMInjectTest },
357     { "ecc1_vimramselftest",         SDTF_runECC1BitVIMRAMSelfTest },
358     { "ecc2_vimramselftest",         SDTF_runECC2BitVIMRAMSelfTest },
359     { "crc_selftest",                SDTF_runCRCSelfTest },
360     { "crc_negativetest",            SDTF_runCRCNegativeTest },
361     { "mpu_selftest",                SDTF_runMPUSelfTest},
362     { "wdt_selftestendviolation",    SDTF_runWDTSelfTestEndViolation },
363     { "wdt_selftestwindowviolation", SDTF_runWDTSelfTestWindowViolation },
364     { "wdt_negativetests",           SDTF_runWDTNegativeTests },
365     { "RAT_test",                    SDTF_runtestRAT },
366     { "ecc_runnegativetests",        SDTF_ECC_runNegativeTests },
367     { "ecc2_programinject",          SDTF_runECC2BitCodeInjectTest },
368     { "exception_runapitests",       SDTF_runExceptionApiTests },
369     { "ecc1_inject",                 SDTF_runECC1BitInjectTest },
370 #ifdef SOC_J721E
371     { "cbass_1bitinject",            SDTF_runECC1BitCBASSInjectTest },
372     { "cbass_1bitselftest",          SDTF_runECC1BitCBASSSelfTest },
373     { "cbass_2bitinject",            SDTF_runECC2BitCBASSInjectTest },
374     { "cbass_2bitselftest",          SDTF_runECC2BitCBASSSelfTest },
375 #endif
376 #ifdef SOC_AM65XX
377 /*     { "ccm_selftest",                SDTF_runCCMSelfTest },
378     { "ccm_selftest_errorforce",     SDTF_runCCMSelfTestErrorForce },
379     { "ccm_vimselftest",             SDTF_runCCMVIMSelfTest },
380     { "ccm_inactivityselftest",      SDTF_runCCMInactivitySelfTest }, */
381     { "ccm_inject",                  SDTF_runCCMInjectError },
382     /* { "ccm_selftest_polarityinvert",     SDTF_runCCMSelftestPolarityInvert }, */
383 #endif
384     /* This needs to be last as it is destructive */
385     { "ecc2_vimramdedvector",        SDTF_runECC2BitVIMRAMDEDvector },
388      /* The following tests are not covered by run all */
390 };
392 char SDTF_specialCommands[SDTF_MAX_SPECIAL_COMMANDS][SDTF_MAX_COMMAND_LEN+1] =
394     /* The following are special commands */
395     "read_reg",
396     "write_reg",
397     "debug_test",
398     "run_all",
399     "help",
400 };
402 /*********************************************************************
403  * @fn      SDTF_runInteractiveTests
404  *
405  * @brief   Execute interactive tests
406  *
407  * @param   None
408  *
409  * @return  0 : Success; < 0 for failures
410  */
411 int32_t SDTF_runInteractiveTests(void)
413     char buffPointer[256];
414     char echoPrompt[] = "\n Interactive test :Enter a command or Esc to quit >";
415     char echoPrompt1[] = "Data received is:";
416     uint32_t endInteractiveTestsFlag=0;
417     int32_t retVal = 0;
418     uint32_t i;
420     SDTF_interactiveTaskCount++;
422     while(endInteractiveTestsFlag == 0)
423     {
424         /* Print prompt to UART port */
425         UART_printf(echoPrompt);
427         /* Scan input word from user */
428         if (UART_scanFmt("%s", &buffPointer) != S_PASS)
429         {
430             SDTF_printf("\n ERROR: UART_scanFmt failed");
431             endInteractiveTestsFlag = 1;
432             continue;
433         }
435         /* Check on word entered here */
436         /* If needed a command parser can be added here */
437         switch(buffPointer[0]) {
438         case '\0': /*Ignore empty string */
439             break;
441         case 27: /* Exit on ESC character */
442             endInteractiveTestsFlag = 1;
443             break;
445         default:
446             /* Display prompt  */
447             UART_printf(echoPrompt1);
448             /* Display received word */
449             UART_printf(buffPointer);
450             /* Print new line */
451             UART_printf("\n");
452             break;
453         }
455         /* Help command to display all commands */
456         if (strncmp(buffPointer, "help", SDTF_MAX_COMMAND_LEN) == 0) {
457             uint32_t i;
459             SDTF_printf("\n Here are the commands supported");
460             for(i=0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
461                 SDTF_printf("\n %s", SDTF_commandList[i].commandString);
462             }
463             SDTF_printf("\n --------------------------------");
464             SDTF_printf("\n Other commands");
465             for(; i< SDTF_MAX_COMMANDS; i++) {
466                 SDTF_printf("\n %s", SDTF_commandList[i].commandString);
467             }
468             SDTF_printf("\n --------------------------------");
469             SDTF_printf("\n Special commands");
470             for(i=0u; i< SDTF_MAX_SPECIAL_COMMANDS; i++) {
471                 SDTF_printf("\n %s", SDTF_specialCommands[i]);
472             }
473             SDTF_printf("\n --------------------------------");
474             SDTF_printf("\n [ESC]<enter> to quit");
475         }
478         /* Help command to display all commands */
479         if ((strncmp(buffPointer, "read_reg", SDTF_MAX_COMMAND_LEN) == 0)
480             || (strncmp(buffPointer, "write_reg", SDTF_MAX_COMMAND_LEN) == 0)) {
481             char buffPointer2[256];
482             uintptr_t regAddress;
484             /* Print prompt to UART port */
485             UART_printf("Enter address in hex: ");
487             /* Scan input word from user */
488             if (UART_scanFmt("%s", &buffPointer2) != S_PASS)
489             {
490                 SDTF_printf("\n ERROR: UART_scanFmt failed");
491                 endInteractiveTestsFlag = 1;
492                 continue;
493             }
494             sscanf(buffPointer2, "%x", &regAddress);
496             if (strncmp(buffPointer, "read_reg", SDTF_MAX_COMMAND_LEN) == 0) {
497                 SDTF_printf("\n Read value at 0x%x is 0x%x", regAddress, *((volatile uint32_t *)regAddress));
498             } else {
499                 char buffPointer3[256];
500                 uint32_t regValue;
502                 /* Print prompt to UART port */
503                 UART_printf("Enter value: ");
505                 /* Scan input word from user */
506                 if (UART_scanFmt("%s", &buffPointer3) != S_PASS)
507                 {
508                     SDTF_printf("\n ERROR: UART_scanFmt failed");
509                     endInteractiveTestsFlag = 1;
510                     continue;
511                 }
512                 sscanf(buffPointer3, "%x", &regValue);
513                 *((volatile uint32_t *)regAddress) = regValue;
514                 SDTF_printf("\n Written address 0x%x with value: 0x%x read value 0x%x",
515                             regAddress, regValue, *((volatile uint32_t *)regAddress));
516             }
518         }
520         /* Command to Run all commands */
521         if (strncmp(buffPointer, "debug_test", SDTF_MAX_COMMAND_LEN) == 0) {
522             /* Add any debug test here */
524         }
525         /* Command to Run all commands */
526         if (strncmp(buffPointer, "run_all", SDTF_MAX_COMMAND_LEN) == 0) {
528             SDTF_printf("\n Running all test commands supported");
529             for(i=0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
530                 if (SDTF_commandList[i].commandFunction!= ((void *)(0u))) {
531                     retVal = (*SDTF_commandList[i].commandFunction)();
532                     if ( retVal != 0) {
533                         break;
534                     }
535                 }
536             }
537         }
539         /* Search through all commands to execute appropriate functions */
540         for(i=0u; i< SDTF_MAX_COMMANDS; i++) {
541             if (strncmp(buffPointer, SDTF_commandList[i].commandString, SDTF_MAX_COMMAND_LEN) == 0) {
542                 if (SDTF_commandList[i].commandFunction != ((void *)(0u))) {
543                     retVal = (*SDTF_commandList[i].commandFunction)();
544                     break;
545                 }
546             }
547         }
548         if (retVal < 0) {
549             /* Print error message and check to continue*/
550             UART_printf("\n Error occurred: Enter \"continue\" command to continue");
551             /* Scan input word from user */
552             if (UART_scanFmt("%s", &buffPointer) != S_PASS)
553             {
554                 SDTF_printf("\n ERROR: UART_scanFmt failed");
555                 endInteractiveTestsFlag = 1;
556                 continue;
557             }
558             /* If continue in spite of error */
559              if (strncmp(buffPointer, "continue", SDTF_MAX_COMMAND_LEN) == 0) {
560                  /* Reset return value, so that test can continue*/
561                  retVal = 0;
562                  continue;
563              } else {
564                  /* Else end test */
565                  endInteractiveTestsFlag = 1;
566                  continue;
567              }
568         }
569     }
571     return retVal;
574 /*********************************************************************
575  * @fn      test_sdr_test
576  *
577  * @brief   Execute all sdr tests
578  *
579  * @param   None
580  *
581  * @return  None
582  */
583 void test_sdr_test(void)
585     /* Declarations of variables */
586     int32_t retVal = 0;
587     int32_t i;
589     SDTF_printf("\n Running all sdr test commands supported");
590     for(i = 0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
591         if (SDTF_commandList[i].commandFunction!= ((void *)(0u))) {
592             retVal = (*SDTF_commandList[i].commandFunction)();
593             if ( retVal != 0) {
594                 break;
595             }
596         }
597     }
599     if (retVal == 0)
600     {
601         UART_printStatus("\n All tests have passed. \n");
602     }
603     else
604     {
605         UART_printStatus("\n Few/all tests Failed \n");
606     }
608 #if defined (UNITY_INCLUDE_CONFIG_H)
609     TEST_ASSERT_EQUAL_INT32(0, retVal);
610 #endif