43ff1319e6ca762de299ee365d109153f203c7ea
[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(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 /*********************************************************************
204  * @fn      SDTF_runPeriodicTests
205  *
206  * @brief   Execute all the configured periodic tests
207  *
208  * @param   None
210 * @return  0 : Success; < 0 for failures
211 */
212 int32_t SDTF_runPeriodicTests(void)
214     SDR_Result result;
216     if (( SDTF_periodTaskTrigger == SDTF_PERIODIC_TASK_TRIGGER_ENABLE)
217         && (SDTF_allTasksEnded != 1u) ) {
219         /* Increment task count */
220         SDTF_periodicTaskCount++;
222         /* If max runs are reached print results */
223         if (SDTF_periodicTaskCount >= SDTF_MAX_PERIODIC_TEST_RUN) {
224             /* Mark all tasks_ended */
225             SDTF_allTasksEnded = 1u;
226             SDTF_printf("\n Periodic Tests: Cycle measurements");
227             SDTF_printf("\n Min: %d, Max %d Avg %d Last %d",
228                         SDTF_periodicExecutionTimeMin, SDTF_periodicExecutionTimeMax,
229                         SDTF_periodicExecutionTimeAvg, SDTF_periodicExecutionTime);
231         }
233         SDTF_profileBegin(SDTF_PROFILE_PERIODIC);
234         /* -------------- Periodic Test start ------------------------- */
235         {
236             /* Run test for ECC */
237             SDR_ECC_InjectErrorConfig_t injectErrorConfig;
239             /* Note the address is relative to start of ram */
240             injectErrorConfig.pErrMem = (uint32_t *)(0x00);
242             /* Run one shot test for ATCM 1 bit error */
243             injectErrorConfig.flipBitMask = 0x10;
244             result = SDR_ECC_selfTest(SDR_ECC_MEMTYPE_MCU_R5F0_CORE,
245                                            SDR_ECC_R5F_MEM_SUBTYPE_ATCM0_BANK0_VECTOR_ID,
246                                            SDR_INJECT_ECC_ERROR_FORCING_1BIT_ONCE,
247                                            &injectErrorConfig,
248                                            100000);
251             if (result != SDR_PASS ) {
252                 SDTF_printf("\n ATCM Single bit error at pErrMem 0x%p test failed",
253                             injectErrorConfig.pErrMem);
254                 return -1;
255              }
256         }
257         {
258              /* Run esm test 1*/
259              result = SDR_ESM_selfTest(1000);
260              if (result != SDR_PASS ) {
261                  SDTF_printf("\n ESM self test 1 failed");
262                  return -1;
263              }
264         }
266         /* -------------- Periodic Tests end ------------------------- */
267         SDTF_profileEnd(SDTF_PROFILE_PERIODIC);
269         /* Get the time taken for periodic tests */
270         SDTF_periodicExecutionTime = SDTF_profileDelta(SDTF_PROFILE_PERIODIC);
271         /* First time initialiaze average data */
272         if (SDTF_periodicExecutionFirstTime == 0u) {
273             SDTF_periodicExecutionTimeAvg = SDTF_periodicExecutionFirstTime;
274             SDTF_periodicExecutionFirstTime = 1u;
275         }
276         /* Record the minimum, maximum and average values of time taken */
277         if (SDTF_periodicExecutionTime < SDTF_periodicExecutionTimeMin) {
278             SDTF_periodicExecutionTimeMin = SDTF_periodicExecutionTime;
279         }
280         if (SDTF_periodicExecutionTime > SDTF_periodicExecutionTimeMax) {
281             SDTF_periodicExecutionTimeMax = SDTF_periodicExecutionTime;
282         }
283         SDTF_periodicExecutionTimeAvg = (SDTF_periodicExecutionTimeAvg + SDTF_periodicExecutionTime) >> 1u;
285         /* Clear flag which triggered periodic task */
286         SDTF_periodTaskTrigger = SDTF_PERIODIC_TASK_TRIGGER_OFF;
287     }
288     return 0; 
291 /* Maxumum number of special commands
292  * Should match number of items in the special commands array below
293  */
294 #define SDTF_MAX_SPECIAL_COMMANDS (5u)
296 #ifdef SOC_J721E
297 /* Number of commands run by the "run_all" command
298  * Note: This should match number of entries in the tables below
299  */
300 #define SDTF_NUM_RUNALL_TEST_COMMANDS (31u)
302 /* Other commands not covered by run_all */
303 #define SDTF_NUM_OTHER_TEST_COMMANDS (6u)
304 #else
305 /* Number of commands run by the "run_all" command
306  * Note: This should match number of entries in the tables below
307  */
308 #define SDTF_NUM_RUNALL_TEST_COMMANDS (37u)
310 /* Other commands not covered by run_all */
311 #define SDTF_NUM_OTHER_TEST_COMMANDS (0u)
312 #endif
314 /* Maxumum number of commands
315  * Note: This should match maximumum number of entries in the tables below
316  */
317 #define SDTF_MAX_COMMANDS (SDTF_NUM_RUNALL_TEST_COMMANDS+SDTF_NUM_OTHER_TEST_COMMANDS)
319 #define SDTF_MAX_COMMAND_LEN (64u)
321 /* prototype type for test functions */
322 typedef int32_t (* SDTF_testFunctionPtr_t) (void);
324 typedef struct SDTF_commandList_s
326     char commandString[SDTF_MAX_COMMAND_LEN+1];
327     SDTF_testFunctionPtr_t commandFunction;
328 }SDTF_commandList_t;
330 /* Full list of commands */
331 SDTF_commandList_t SDTF_commandList[SDTF_MAX_COMMANDS] =
333     { "esm_selftest",                SDTF_runESMSelfTest},
334     { "esm_inject",                  SDTF_runESMInject },
335     { "esm_apitest",                 SDTF_runESMAPITest },
336     { "esm_negativetest",            SDTF_runESMNegativeTest},
337     { "ecc1_selftest",               SDTF_runECC1BitSelfTest },
338     { "ecc2_selftest",               SDTF_runECC2BitSelfTest },
339     { "ecc2_inject",                 SDTF_runECC2BitInjectTest },
340     { "ecc1_b0tcm0selftest",         SDTF_runECC1BitB0TCM0Bank0SelfTest },
341     { "ecc2_b0tcm0selftest",         SDTF_runECC2BitB0TCM0Bank0SelfTest },
342     { "ecc1_b0tcm0_b1selftest",      SDTF_runECC1BitB0TCM0Bank1SelfTest },
343     { "ecc2_b0tcm0_b1selftest",      SDTF_runECC2BitB0TCM0Bank1SelfTest },
344     { "ecc1_b1tcm0selftest",         SDTF_runECC1BitB1TCM0Bank0SelfTest },
345     { "ecc2_b1tcm0selftest",         SDTF_runECC2BitB1TCM0Bank0SelfTest },
346     { "ecc1_b1tcm0_b1selftest",      SDTF_runECC1BitB1TCM0Bank1SelfTest },
347     { "ecc2_b1tcm0_b1selftest",      SDTF_runECC2BitB1TCM0Bank1SelfTest },
348     { "ecc1_vimraminject",           SDTF_runECC1BitVIMRAMInjectTest },
349     { "ecc2_vimraminject",           SDTF_runECC2BitVIMRAMInjectTest },
350     { "ecc1_vimramselftest",         SDTF_runECC1BitVIMRAMSelfTest },
351     { "ecc2_vimramselftest",         SDTF_runECC2BitVIMRAMSelfTest },
352     { "crc_selftest",                SDTF_runCRCSelfTest },
353     { "crc_negativetest",            SDTF_runCRCNegativeTest },
354     { "mpu_selftest",                SDTF_runMPUSelfTest},
355     { "wdt_selftestendviolation",    SDTF_runWDTSelfTestEndViolation },
356     { "wdt_selftestwindowviolation", SDTF_runWDTSelfTestWindowViolation },
357     { "wdt_negativetests",           SDTF_runWDTNegativeTests },
358     { "RAT_test",                    SDTF_runtestRAT },
359     { "ecc_runnegativetests",        SDTF_ECC_runNegativeTests },
360     { "ecc2_programinject",          SDTF_runECC2BitCodeInjectTest },
361     { "exception_runapitests",       SDTF_runExceptionApiTests },
362     { "ecc1_inject",                 SDTF_runECC1BitInjectTest },
363     { "ecc2_vimramdedvector",        SDTF_runECC2BitVIMRAMDEDvector },
364     { "ccm_selftest",                SDTF_runCCMSelfTest },
365     { "ccm_selftest_polarityinvert", SDTF_runCCMSelfTestErrorForce },
366     { "ccm_vimselftest",             SDTF_runCCMVIMSelfTest },
367     { "ccm_inactivityselftest",      SDTF_runCCMInactivitySelfTest },
368     { "ccm_inject",                  SDTF_runCCMInjectError },
369     { "ccm_selftest_errorforce",     SDTF_runCCMSelftestPolarityInvert },
371      /* The following tests are not covered by run all */
373 };
375 char SDTF_specialCommands[SDTF_MAX_SPECIAL_COMMANDS][SDTF_MAX_COMMAND_LEN+1] =
377     /* The following are special commands */
378     "read_reg",
379     "write_reg",
380     "debug_test",
381     "run_all",
382     "help",
383 };
385 /*********************************************************************
386  * @fn      SDTF_runInteractiveTests
387  *
388  * @brief   Execute interactive tests
389  *
390  * @param   None
391  *
392  * @return  0 : Success; < 0 for failures
393  */
394 int32_t SDTF_runInteractiveTests(void)
396     char buffPointer[256];
397     char echoPrompt[] = "\n Interactive test :Enter a command or Esc to quit >";
398     char echoPrompt1[] = "Data received is:";
399     uint32_t endInteractiveTestsFlag=0;
400     int32_t retVal = 0;
401     uint32_t i;
403     SDTF_interactiveTaskCount++;
405     while(endInteractiveTestsFlag == 0)
406     {
407         /* Print prompt to UART port */
408         UART_printf(echoPrompt);
410         /* Scan input word from user */
411         if (UART_scanFmt("%s", &buffPointer) != S_PASS)
412         {
413             SDTF_printf("\n ERROR: UART_scanFmt failed");
414             endInteractiveTestsFlag = 1;
415             continue;
416         }
418         /* Check on word entered here */
419         /* If needed a command parser can be added here */
420         switch(buffPointer[0]) {
421         case '\0': /*Ignore empty string */
422             break;
424         case 27: /* Exit on ESC character */
425             endInteractiveTestsFlag = 1;
426             break;
428         default:
429             /* Display prompt  */
430             UART_printf(echoPrompt1);
431             /* Display received word */
432             UART_printf(buffPointer);
433             /* Print new line */
434             UART_printf("\n");
435             break;
436         }
438         /* Help command to display all commands */
439         if (strncmp(buffPointer, "help", SDTF_MAX_COMMAND_LEN) == 0) {
440             uint32_t i;
442             SDTF_printf("\n Here are the commands supported");
443             for(i=0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
444                 SDTF_printf("\n %s", SDTF_commandList[i].commandString);
445             }
446             SDTF_printf("\n --------------------------------");
447             SDTF_printf("\n Other commands");
448             for(; i< SDTF_MAX_COMMANDS; i++) {
449                 SDTF_printf("\n %s", SDTF_commandList[i].commandString);
450             }
451             SDTF_printf("\n --------------------------------");
452             SDTF_printf("\n Special commands");
453             for(i=0u; i< SDTF_MAX_SPECIAL_COMMANDS; i++) {
454                 SDTF_printf("\n %s", SDTF_specialCommands[i]);
455             }
456             SDTF_printf("\n --------------------------------");
457             SDTF_printf("\n [ESC]<enter> to quit");
458         }
461         /* Help command to display all commands */
462         if ((strncmp(buffPointer, "read_reg", SDTF_MAX_COMMAND_LEN) == 0)
463             || (strncmp(buffPointer, "write_reg", SDTF_MAX_COMMAND_LEN) == 0)) {
464             char buffPointer2[256];
465             uintptr_t regAddress;
467             /* Print prompt to UART port */
468             UART_printf("Enter address in hex: ");
470             /* Scan input word from user */
471             if (UART_scanFmt("%s", &buffPointer2) != S_PASS)
472             {
473                 SDTF_printf("\n ERROR: UART_scanFmt failed");
474                 endInteractiveTestsFlag = 1;
475                 continue;
476             }
477             sscanf(buffPointer2, "%x", &regAddress);
479             if (strncmp(buffPointer, "read_reg", SDTF_MAX_COMMAND_LEN) == 0) {
480                 SDTF_printf("\n Read value at 0x%x is 0x%x", regAddress, *((uint32_t *)regAddress));
481             } else {
482                 char buffPointer3[256];
483                 uint32_t regValue;
485                 /* Print prompt to UART port */
486                 UART_printf("Enter value: ");
488                 /* Scan input word from user */
489                 if (UART_scanFmt("%s", &buffPointer3) != S_PASS)
490                 {
491                     SDTF_printf("\n ERROR: UART_scanFmt failed");
492                     endInteractiveTestsFlag = 1;
493                     continue;
494                 }
495                 sscanf(buffPointer3, "%x", &regValue);
496                 *((uint32_t *)regAddress) = regValue;
497                 SDTF_printf("\n Written address 0x%x with value: 0x%x read value 0x%x",
498                             regAddress, regValue, *((uint32_t *)regAddress));
499             }
501         }
503         /* Command to Run all commands */
504         if (strncmp(buffPointer, "debug_test", SDTF_MAX_COMMAND_LEN) == 0) {
505             /* Add any debug test here */
507         }
508         /* Command to Run all commands */
509         if (strncmp(buffPointer, "run_all", SDTF_MAX_COMMAND_LEN) == 0) {
511             SDTF_printf("\n Running all test commands supported");
512             for(i=0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
513                 if (SDTF_commandList[i].commandFunction!= ((void *)(0u))) {
514                     retVal = (*SDTF_commandList[i].commandFunction)();
515                     if ( retVal != 0) {
516                         break;
517                     }
518                 }
519             }
520         }
522         /* Search through all commands to execute appropriate functions */
523         for(i=0u; i< SDTF_MAX_COMMANDS; i++) {
524             if (strncmp(buffPointer, SDTF_commandList[i].commandString, SDTF_MAX_COMMAND_LEN) == 0) {
525                 if (SDTF_commandList[i].commandFunction != ((void *)(0u))) {
526                     retVal = (*SDTF_commandList[i].commandFunction)();
527                     break;
528                 }
529             }
530         }
531         if (retVal < 0) {
532             /* Print error message and check to continue*/
533             UART_printf("\n Error occurred: Enter \"continue\" command to continue");
534             /* Scan input word from user */
535             if (UART_scanFmt("%s", &buffPointer) != S_PASS)
536             {
537                 SDTF_printf("\n ERROR: UART_scanFmt failed");
538                 endInteractiveTestsFlag = 1;
539                 continue;
540             }
541             /* If continue in spite of error */
542              if (strncmp(buffPointer, "continue", SDTF_MAX_COMMAND_LEN) == 0) {
543                  /* Reset return value, so that test can continue*/
544                  retVal = 0;
545                  continue;
546              } else {
547                  /* Else end test */
548                  endInteractiveTestsFlag = 1;
549                  continue;
550              }
551         }
552     }
554     return retVal;
557 /*********************************************************************
558  * @fn      test_sdr_test
559  *
560  * @brief   Execute all sdr tests
561  *
562  * @param   None
563  *
564  * @return  None
565  */
566 void test_sdr_test(void)
568     /* Declarations of variables */
569     int32_t retVal = 0;
570     int32_t i;
572     SDTF_printf("\n Running all sdr test commands supported");
573     for(i = 0u; i< SDTF_NUM_RUNALL_TEST_COMMANDS; i++) {
574         if (SDTF_commandList[i].commandFunction!= ((void *)(0u))) {
575             retVal = (*SDTF_commandList[i].commandFunction)();
576             if ( retVal != 0) {
577                 break;
578             }
579         }
580     }
582     if (retVal == 0)
583     {
584         UART_printStatus("\n ALL TESTS PASSED \n");
585     }
586     else
587     {
588         UART_printStatus("\n Few/all tests Failed \n");
589     }
591 #if defined (UNITY_INCLUDE_CONFIG_H)
592     TEST_ASSERT_EQUAL_INT32(0, retval);
593 #endif