ti/drv/uart: SCI bug fixes and UART test enhancements
[processor-sdk/pdk.git] / packages / ti / drv / uart / test / src / main_uart_test.c
1 /**
2  * @file   main_test.c
3  *
4  * @brief  This file tests the UART driver APIs in Blocking mode.
5  */
6 /*
7  * Copyright (c) 2014 - 2018, Texas Instruments Incorporated
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * *  Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  *
17  * *  Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * *  Neither the name of Texas Instruments Incorporated nor the names of
22  *    its contributors may be used to endorse or promote products derived
23  *    from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
35  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  */
38 #include <stdio.h>
39 #include <string.h>
41 #ifdef USE_BIOS
42 /* XDCtools Header files */
43 #include <xdc/std.h>
44 #include <xdc/runtime/Error.h>
45 #include <xdc/runtime/System.h>
47 /* BIOS Header files */
48 #include <ti/sysbios/BIOS.h>
49 #include <ti/sysbios/knl/Task.h>
50 #endif /* #ifdef USE_BIOS */
52 /* CSL Header files */
53 #if defined(_TMS320C6X)
54 #include <ti/csl/csl_chip.h>
55 #endif
56 #include <ti/csl/soc.h>
57 #include <ti/csl/csl_types.h>
59 /* OSAL Header files */
60 #include <ti/osal/osal.h>
62 /* UART Header files */
63 #include <ti/drv/uart/UART.h>
64 #include <ti/drv/uart/UART_stdio.h>
65 #include <ti/drv/uart/src/UART_osal.h>
66 #include <ti/drv/uart/soc/UART_soc.h>
68 #include "UART_board.h"
70 #if defined(SOC_J721E) || defined(SOC_J7200)
71 #include <ti/csl/soc.h>
72 #endif
74 #if defined(SOC_J721E) || defined(SOC_AM65XX) || defined(SOC_J7200) || defined(SOC_AM64X)
75 #include <ti/drv/sciclient/sciclient.h>
76 #endif
78 #if defined(SOC_J721E) || defined(SOC_J7200)
79 #include <ti/csl/csl_clec.h>
80 #endif
82 #if defined (__C7100__)
83 #include <ti/csl/arch/csl_arch.h>
84 #endif
86 //#define CIO_DRV_CONSOLE
88 #ifdef CIO_DRV_CONSOLE
89 #define UART_test_log            printf
90 #define UART_test_log1           printf
91 #define UART_test_log2           printf
92 #define UART_test_log3           printf
93 #else
94 #define UART_test_log(x)
95 #define UART_test_log1(x,y)
96 #define UART_test_log2(x,y,z)
97 #define UART_test_log3(x,y,z,l)
98 #endif
101 #if defined(SOC_TPR12)
102 #if defined(SIM_BUILD)
103 #define UART_RX_LOOPBACK_ONLY
104 #endif
105 #define UART_API2_NOT_SUPPORTED
106 #define UART_NO_FIFO
107 #endif
109 void Uart_appC7xPreInit(void);
111 /* Define the UART test interface */
112 typedef struct UART_Tests_s
114     bool     (*testFunc)(bool);
115     bool     dmaMode;
116     int16_t  testId;
117     char     testDesc[80];
119 } UART_Tests;
121 /* UART test ID definitions */
122 #define UART_TEST_ID_DMA         0   /* UART DMA read write test in block mode */
123 #define UART_TEST_ID_INT         1   /* UART non-DMA read write test in block mode */
124 #define UART_TEST_ID_DMA_CB      2   /* UART DMA read write test in callback mode */
125 #define UART_TEST_ID_CB          3   /* UART non-DMA read write test in callback mode */
126 #define UART_TEST_ID_DMA_TO      4   /* UART DMA timeout test */
127 #define UART_TEST_ID_TO          5   /* UART non DMA timeout test */
128 #define UART_TEST_ID_DMA_RXERR   6   /* UART DMA RX error test */
129 #define UART_TEST_ID_RXERR       7   /* UART non-DMA RX error test */
130 #define UART_TEST_ID_DMA_CANCEL  8   /* UART DMA read write cancel test */
131 #define UART_TEST_ID_CANCEL      9   /* UART non-DMA read write cancel test */
132 #define UART_TEST_ID_DMA_RW      10  /* UART DMA simultaneous read write test */
133 #define UART_TEST_ID_RW          11  /* UART non-DMA simultaneous read write test */
134 #define UART_TEST_ID_DMA_TRGLVL  12  /* UART DMA TX/RX FIFO trigger level test */
135 #define UART_TEST_ID_PRINTF      13  /* UART stdio printf and scanf test */
136 #define UART_TEST_ID_TRGLVL      14  /* UART non-DMA TX/RX FIFO trigger level test */
137 #define UART_TEST_ID_POLL_TO     15  /* UART read write polling timeout test */
138 #define UART_TEST_ID_STDIOPARAMS 16  /* UART stdio printf and scanf test, with configurable params(Default params) */
139 #define UART_TEST_ID_INT_DISABLE 17  /* UART read write test with interrupt disabled */
140 #define UART_TEST_ID_RDVERIFY    18  /* UART non-DMA read API Test in loopback mode */
141 #define UART_TEST_ID_MULTI_INSTS 19  /* UART DMA multiple instances test in loopback mode */
142 #define UART_TEST_ID_API         20  /* UART API Test */
143 #define UART_TEST_ID_PROF_TX     21  /* UART non-DMA/DMA Blocking/Polling transmit polling */
144 #define UART_TEST_ID_DMA_LB_DATA 22  /* UART DMA data transfer test in loopback mode */
145 #define UART_TEST_ID_LB_DATA     23  /* UART non-DMA data transfer test in loopback mode */
147 /* Length of the input in number of characters */
148 #define UART_TEST_READ_LEN     (16U)
149 #define UART_RDVERIFY_READ_LEN (4U)
151 /* Timeout value of read and write */
152 #ifdef SIM_BUILD
153 #define UART_TEST_TIMEOUT      (50U)
154 #else
155 #define UART_TEST_TIMEOUT      (10000U)
156 #endif
158 /* Max number of instances to test in multiple instance test case */
159 #define UART_TEST_NUM_INSTS    (2U)
160 /* MAX Data Pattern Test Size for the Data Tests: */
161 #define MAX_TEST_BUFFER_SIZE   256
163 #if defined(CSL_CACHE_L2_LINESIZE)
164 #define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L2_LINESIZE
165 #elif defined(CSL_CACHE_L1D_LINESIZE)
166 #define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L1D_LINESIZE
167 #else
168 #define UART_TEST_CACHE_LINE_SIZE (128U)
169 #endif
171 char scanPrompt[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
172 char echoPrompt[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\n\r Data entered is as follows \r\n";
173 char dataPrint[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character \r\n";
174 char readTimeoutPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Read timed out \r\n";
175 char breakErrPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Received a break condition error \r\n";
176 char rdCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous read canceled \r\n";
177 char wrCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous write canceled \r\n";
178 char fifoTrgLvlData[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) =
179                         "0123456789112345678921234567893123456789412345678951234567896123456789712345678981234567899123456789"
180                         "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789abcedef12345"
181                         "6789ABCDEF012345678901234567899876543210deadbeef89512345";
182 char stdioPrint[64] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character and press ENTER \r\n";
184 UART_Transaction  callbackTransaction;
185 SemaphoreP_Handle callbackSem = NULL;
187 uint32_t uartTestInstance;
189 uint32_t verifyLoopback = FALSE;
191 uint32_t verifyRS485 = FALSE;
193 UART_PAR uartParity = UART_PAR_NONE;
195 /* Global Variable which holds the UART Handle */
196 UART_Handle     gUARTHandle = NULL;
198 #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
199 #ifdef UART_DMA_ENABLE
200 /*
201  * Ring parameters
202  */
203 /** \brief Number of ring entries - we can prime this much memcpy operations */
204 #define UDMA_TEST_APP_RING_ENTRIES      (1U)
205 /** \brief Size (in bytes) of each ring entry (Size of pointer - 64-bit) */
206 #define UDMA_TEST_APP_RING_ENTRY_SIZE   (sizeof(uint64_t))
207 /** \brief Total ring memory */
208 #define UDMA_TEST_APP_RING_MEM_SIZE     (UDMA_TEST_APP_RING_ENTRIES * \
209                                          UDMA_TEST_APP_RING_ENTRY_SIZE)
210 /** \brief This ensures every channel memory is aligned */
211 #define UDMA_TEST_APP_RING_MEM_SIZE_ALIGN ((UDMA_TEST_APP_RING_MEM_SIZE + UDMA_CACHELINE_ALIGNMENT) & ~(UDMA_CACHELINE_ALIGNMENT - 1U))
213 /**
214  *  \brief UDMA host mode buffer descriptor memory size.
215  *  Make it multiple of UART_TEST_CACHE_LINE_SIZE alignment
216  */
217 /** \brief UDMA host mode buffer descriptor memory size. */
218 #define UDMA_TEST_APP_DESC_SIZE         (sizeof(CSL_UdmapCppi5HMPD))
219 /** \brief This ensures every channel memory is aligned */
220 #define UDMA_TEST_APP_DESC_SIZE_ALIGN   ((UDMA_TEST_APP_DESC_SIZE + UDMA_CACHELINE_ALIGNMENT) & ~(UDMA_CACHELINE_ALIGNMENT - 1U))
222 /*
223  * UDMA driver objects
224  */
225 struct Udma_DrvObj      gUdmaDrvObj;
226 struct Udma_ChObj       gUdmaTxChObj;
227 struct Udma_ChObj       gUdmaRxChObj;
228 struct Udma_EventObj    gUdmaTxCqEventObj;
229 struct Udma_EventObj    gUdmaRxCqEventObj;
231 Udma_DrvHandle          gDrvHandle = NULL;
232 /*
233  * UDMA Memories
234  */
235 static uint8_t gTxRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
236 static uint8_t gTxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
237 static uint8_t gTdTxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
238 static uint8_t gUdmaTxHpdMem[UDMA_TEST_APP_DESC_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
239 static uint8_t gRxRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
240 static uint8_t gRxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
241 static uint8_t gTdRxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
242 static uint8_t gUdmaRxHpdMem[UDMA_TEST_APP_DESC_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
243 static UART_dmaInfo gUdmaInfo;
245 Udma_DrvHandle UartApp_udmaInit(UART_HwAttrs *cfg)
247     int32_t         retVal = UDMA_SOK;
248     Udma_InitPrms   initPrms;
249     uint32_t        instId;
251     if (gDrvHandle == NULL)
252     {
253         /* UDMA driver init */
254 #if defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM65XX)
255 #if defined (BUILD_MCU1_0) || defined (BUILD_MCU1_1)
256         instId = UDMA_INST_ID_MCU_0;
257 #else
258         instId = UDMA_INST_ID_MAIN_0;
259 #endif
260 #endif
262 #if defined(SOC_AM64X)
263         instId = UDMA_INST_ID_PKTDMA_0;
264 #endif
266         UdmaInitPrms_init(instId, &initPrms);
268         retVal = Udma_init(&gUdmaDrvObj, &initPrms);
269         if(UDMA_SOK == retVal)
270         {
271             gDrvHandle = &gUdmaDrvObj;
272         }
273     }
275     if(gDrvHandle != NULL)
276     {
277         gDrvHandle = &gUdmaDrvObj;
279         gUdmaInfo.txChHandle     = (void *)&gUdmaTxChObj;
280         gUdmaInfo.rxChHandle     = (void *)&gUdmaRxChObj;
281         gUdmaInfo.txRingMem      = (void *)&gTxRingMem[0];
282         gUdmaInfo.cqTxRingMem    = (void *)&gTxCompRingMem[0];
283         gUdmaInfo.tdCqTxRingMem  = (void *)&gTdTxCompRingMem[0];
284         gUdmaInfo.rxRingMem      = (void *)&gRxRingMem[0];
285         gUdmaInfo.cqRxRingMem    = (void *)&gRxCompRingMem[0];
286         gUdmaInfo.tdCqRxRingMem  = (void *)&gTdRxCompRingMem[0];
287         gUdmaInfo.txHpdMem       = (void *)&gUdmaTxHpdMem[0];
288         gUdmaInfo.rxHpdMem       = (void *)&gUdmaRxHpdMem[0];
289         gUdmaInfo.txEventHandle  = (void *)&gUdmaTxCqEventObj;
290         gUdmaInfo.rxEventHandle  = (void *)&gUdmaRxCqEventObj;
291         cfg->dmaInfo             = &gUdmaInfo;
292     }
294     return (gDrvHandle);
297 int32_t UART_udma_deinit(void)
299     int32_t         retVal = UDMA_SOK;
301     if (gDrvHandle != NULL)
302     {
303         retVal = Udma_deinit(gDrvHandle);
304         if(UDMA_SOK == retVal)
305         {
306             gDrvHandle = NULL;
307         }
308     }
310     return (retVal);
312 #endif
313 #endif /* #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X) */
315 #if defined(SOC_AM64X)
316 int32_t UART_configClk(uint32_t freq)
318     int32_t retVal = CSL_PASS;
319     uint64_t uartClk;
320     uint32_t parentID;
321     uint32_t clkID[] = {
322                            TISCI_DEV_UART0_FCLK_CLK,
323                            TISCI_DEV_UART1_FCLK_CLK,
324                            TISCI_DEV_UART2_FCLK_CLK,
325                            TISCI_DEV_UART3_FCLK_CLK,
326                            TISCI_DEV_UART4_FCLK_CLK,
327                            TISCI_DEV_UART5_FCLK_CLK,
328                            TISCI_DEV_UART6_FCLK_CLK,
329                        };
330     uint32_t modID[] = {
331                            TISCI_DEV_UART0,
332                            TISCI_DEV_UART1,
333                            TISCI_DEV_UART2,
334                            TISCI_DEV_UART3,
335                            TISCI_DEV_UART4,
336                            TISCI_DEV_UART5,
337                            TISCI_DEV_UART6,
338                        };
340     retVal = Sciclient_pmModuleClkRequest(modID[uartTestInstance],
341                                           clkID[uartTestInstance],
342                                           TISCI_MSG_VALUE_CLOCK_SW_STATE_REQ,
343                                           TISCI_MSG_FLAG_AOP,SCICLIENT_SERVICE_WAIT_FOREVER);
344     if (retVal == CSL_PASS)
345     {
346         if (freq == UART_MODULE_CLK_48M)
347         {
348             parentID = TISCI_DEV_UART0_FCLK_CLK_PARENT_USART_PROGRAMMABLE_CLOCK_DIVIDER_OUT0;
349         }
350         else
351         {
352             parentID = TISCI_DEV_UART0_FCLK_CLK_PARENT_HSDIV4_16FFT_MAIN_1_HSDIVOUT1_CLK;
353         }
354         retVal = Sciclient_pmSetModuleClkParent(modID[uartTestInstance],
355                                                 clkID[uartTestInstance],
356                                                 parentID,
357                                                 SCICLIENT_SERVICE_WAIT_FOREVER);
358     }
360     if (retVal == CSL_PASS)
361     {
362         uartClk = (uint64_t)freq;
363         retVal = Sciclient_pmSetModuleClkFreq(modID[uartTestInstance],
364                                               clkID[uartTestInstance],
365                                               uartClk,
366                                               TISCI_MSG_FLAG_AOP,
367                                               SCICLIENT_SERVICE_WAIT_FOREVER);
368     }
370     if (retVal == CSL_PASS)
371     {
372         uartClk = 0;
373         retVal = Sciclient_pmGetModuleClkFreq(modID[BOARD_OSPI_NOR_INSTANCE],
374                                               clkID[BOARD_OSPI_NOR_INSTANCE],
375                                               &uartClk,
376                                               SCICLIENT_SERVICE_WAIT_FOREVER);
377     }
379     if (retVal == CSL_PASS)
380     {
381         if ((uint32_t)uartClk != freq)
382         {
383             retVal = CSL_EFAIL;
384         }
385     }
387     return (retVal);
389 #endif
390 /*
391  *  ======== UART init config ========
392  */
393 static void UART_initConfig(bool dmaMode)
395     UART_HwAttrs uart_cfg;
397     /* Get the default UART init configurations */
398     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
400 #ifdef UART_DMA_ENABLE
401     if (dmaMode == true)
402     {
403 #if defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
404         uart_cfg.edmaHandle = UartApp_udmaInit(&uart_cfg);
405 #else
406         uart_cfg.edmaHandle = UartApp_edmaInit();
407     #if defined(SOC_TPR12)
408         uart_cfg.paramSetId = EDMA_NUM_DMA_CHANNELS;
409     #endif
410 #endif
411         uart_cfg.dmaMode    = TRUE;
412     }
413     else
414 #endif
415     {
416         uart_cfg.edmaHandle = NULL;
417         uart_cfg.dmaMode    = FALSE;
418     }
420     uart_cfg.loopback   = verifyLoopback;
421 #if defined(SOC_AM64X)
422     if (verifyRS485 == TRUE)
423     {
424         uart_cfg.frequency = UART_MODULE_CLK_160M;
425     }
426     else
427     {
428         uart_cfg.frequency = UART_MODULE_CLK_48M;
429     }
430     uart_cfg.dirEnable = verifyRS485;
431     UART_configClk(uart_cfg.frequency);
432 #endif
434     /* Set the DMA enabled UART init configurations */
435     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
438 void UART_getTestInstNum(uint32_t *instNum, bool *boardAM570x)
440 #if defined (idkAM571x)
441     Board_STATUS  boardStatus;
442     Board_IDInfo  id;
443 #endif
445     *instNum = UART_INSTANCE;
446     *boardAM570x = false;
448 #if defined (idkAM571x)
449     boardStatus = Board_getIDInfo(&id);
450     if (boardStatus != BOARD_SOK)
451     {
452         return;
453     }
455     /* Check if is DRA (AM570x) SoC */
456     if ((id.boardName[0] == 'D') &&
457         (id.boardName[1] == 'R') &&
458         (id.boardName[2] == 'A'))
459     {
460         *boardAM570x = true;
461         *instNum = 0;
462     }
463 #endif
466 bool Board_initUART(void)
468     Board_initCfg boardCfg;
469     Board_STATUS  boardStatus;
470     bool          boardAM570x;
472 #if defined(evmK2E) || defined(evmC6678)
473     boardCfg = BOARD_INIT_MODULE_CLOCK;
474 #else
475     boardCfg = BOARD_INIT_PINMUX_CONFIG |
476         BOARD_INIT_MODULE_CLOCK;
477 #endif
479     boardStatus = Board_init(boardCfg);
480     if (boardStatus != BOARD_SOK)
481     {
482         return (false);
483     }
485     UART_getTestInstNum(&uartTestInstance, &boardAM570x);
487 /* --- TODO: move this into the board library --- */
488 /* For SYSBIOS only */
489 #ifndef BAREMETAL
490 #if defined (SOC_J721E)
491 /* set up C7x CLEC for DMTimer0 */
492 #if defined (BUILD_C7X_1)
493     CSL_ClecEventConfig   cfgClec;
494     CSL_CLEC_EVTRegs     *clecBaseAddr = (CSL_CLEC_EVTRegs *)CSL_COMPUTE_CLUSTER0_CLEC_REGS_BASE;
495     uint32_t input         = CSLR_COMPUTE_CLUSTER0_GIC500SS_SPI_TIMER0_INTR_PEND_0 + 992; /* Used for Timer Interrupt */
497     /* Configure CLEC for DMTimer0, SYS/BIOS uses interrupt 14 for DMTimer0 by default */
498     cfgClec.secureClaimEnable = FALSE;
499     cfgClec.evtSendEnable     = TRUE;
500     cfgClec.rtMap             = CSL_CLEC_RTMAP_CPU_ALL;
501     cfgClec.extEvtNum         = 0;
502     cfgClec.c7xEvtNum         = 14;
503     CSL_clecConfigEvent(clecBaseAddr, input, &cfgClec);
504 #endif /* for C7X cores */
506 /* set up C66x Interrupt Router for DMTimer0 for C66x */
507 #if defined (BUILD_DSP_1) || defined (BUILD_DSP_2)
508     int32_t                               retVal;
509     struct tisci_msg_rm_irq_set_req      rmIrqReq;
510     struct tisci_msg_rm_irq_set_resp     rmIrqResp;
511     int32_t                              dst_id;
513 #if defined (BUILD_DSP_1)
514     dst_id = TISCI_DEV_C66SS0_CORE0;
515 #endif
516 #if defined (BUILD_DSP_2)
517     dst_id = TISCI_DEV_C66SS1_CORE0;
518 #endif
520     /* Set up C66x interrupt router for DMTimer0 */
521     memset (&rmIrqReq, 0, sizeof(rmIrqReq));
522     rmIrqReq.secondary_host = TISCI_MSG_VALUE_RM_UNUSED_SECONDARY_HOST;
523     rmIrqReq.src_id = TISCI_DEV_TIMER0;
524     rmIrqReq.src_index = 0; /* set to 0 for non-event based interrupt */
526     /* Set the destination interrupt */
527     rmIrqReq.valid_params |= TISCI_MSG_VALUE_RM_DST_ID_VALID;
528     rmIrqReq.valid_params |= TISCI_MSG_VALUE_RM_DST_HOST_IRQ_VALID;
530     /* Set the destination based on the core */
531     rmIrqReq.dst_id       = dst_id;
532 /* rmIrqReq.dst_host_irq has to match the DMTimer.timerSettings[0].eventId defined in sysbios_c66.cfg */
533 #if defined (BUILD_DSP_1)
534     rmIrqReq.dst_host_irq = 21; /* DMSC dest event, input to C66x INTC  */
535 #endif
536 #if defined (BUILD_DSP_2)
537     rmIrqReq.dst_host_irq = 20; /* DMSC dest event, input to C66x INTC  */
538 #endif
540     /* Config event */
541     retVal = Sciclient_rmIrqSet(
542                 (const struct tisci_msg_rm_irq_set_req *)&rmIrqReq,
543                 &rmIrqResp,
544                 SCICLIENT_SERVICE_WAIT_FOREVER);
545     if(0U != retVal)
546     {
547        return (false);
548     }
549 #endif /* for C66X cores */
550 #endif /* for SOC_J721E || SOC_J7200 */
551 #endif /* for SYSBIOS */
552 /* --- TODO: move this into the board library --- */
554 #if defined (SOC_AM572x) || defined (SOC_AM571x) || defined (SOC_AM574x)
555     CSL_l4per_cm_core_componentRegs *l4PerCmReg =
556         (CSL_l4per_cm_core_componentRegs *) CSL_MPU_L4PER_CM_CORE_REGS;
558     if (boardAM570x)
559     {
560 #if defined (_TMS320C6X)
561         UART_HwAttrs cfg;
563         /*
564          * AM5 DSP does not have a default Xbar connection for UART
565          * interrupt, need the following Xbar interrupt configuration
566          */
568         /* Use reserved DSP1_IRQ_34 */
569         CSL_xbarDspIrqConfigure(1,
570                                 CSL_XBAR_INST_DSP1_IRQ_34,
571                                 CSL_XBAR_UART1_IRQ);
573         /* configure Xbar for UART2 instance */
574         CSL_xbarDspIrqConfigure(1,
575                                 CSL_XBAR_INST_DSP1_IRQ_35,
576                                 CSL_XBAR_UART2_IRQ);
577         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
578         cfg.eventId = 35;
579         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
580 #endif
582 #if defined(__TI_ARM_V7M4__)
583         UART_HwAttrs cfg;
585         /*
586          * AM571/AM570 IPU does not have a default Xbar connection for UART 1
587          * interrupt, need to use a reserved IRQ Xbar instance for Xbar interrupt
588          * configuration
589          */
591         /* Use reserved XBAR_INST_IPU1_IRQ_24 */
592         CSL_xbarIpuIrqConfigure(1,
593                                 CSL_XBAR_INST_IPU1_IRQ_24,
594                                 CSL_XBAR_UART1_IRQ);
596         /* configure Xbar for UART2 instance */
597         CSL_xbarIpuIrqConfigure(1,
598                                 CSL_XBAR_INST_IPU1_IRQ_25,
599                                 CSL_XBAR_UART2_IRQ);
600         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
601         cfg.intNum = 25;
602         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
603 #endif
605         /* enable UART2 clock */
606         CSL_FINST(l4PerCmReg->CM_L4PER_UART2_CLKCTRL_REG,
607                   L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_MODULEMODE,
608                   ENABLE);
610         while(CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_IDLEST_FUNC !=
611               CSL_FEXT(l4PerCmReg->CM_L4PER_UART2_CLKCTRL_REG,
612               L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_IDLEST));
613     }
614     else
615     {
616 #if defined (_TMS320C6X)
617         UART_HwAttrs cfg;
619         CSL_xbarDspIrqConfigure(1,
620                                 CSL_XBAR_INST_DSP1_IRQ_34,
621                                 CSL_XBAR_UART3_IRQ);
623         /* configure Xbar for UART4 instance */
624         CSL_xbarDspIrqConfigure(1,
625                                 CSL_XBAR_INST_DSP1_IRQ_35,
626                                 CSL_XBAR_UART4_IRQ);
627         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
628         cfg.eventId = 35;
629         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
630 #endif
632 #if defined(__TI_ARM_V7M4__)
633         /*
634          * AM57x IPU does not have a default Xbar connection for UART 4
635          * interrupt, need to use a reserved IRQ Xbar instance for Xbar interrupt
636          * configuration
637          */
638         /* Use reserved XBAR_INST_IPU1_IRQ_24 */
639         CSL_xbarIpuIrqConfigure(1,
640                                 CSL_XBAR_INST_IPU1_IRQ_24,
641                                 CSL_XBAR_UART4_IRQ);
642 #endif
644         /* enable UART4 clock */
645         CSL_FINST(l4PerCmReg->CM_L4PER_UART4_CLKCTRL_REG,
646                   L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_MODULEMODE,
647                   ENABLE);
649         while(CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_IDLEST_FUNC !=
650               CSL_FEXT(l4PerCmReg->CM_L4PER_UART4_CLKCTRL_REG,
651               L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_IDLEST));
652     }
653 #endif
655 #if defined (SOC_AM335X) || defined (SOC_AM437X)
656     /* enable UART clock */
657     PRCMModuleEnable(42U, uartTestInstance + 1U, 0U);
658 #endif
659     return (true);
662 /**
663  *  @b Description
664  *  @n
665  *      Utility function which converts a local GEM L2 memory address
666  *      to global memory address.
667  *
668  *  @param[in]  addr
669  *      Local address to be converted
670  *
671  *  @retval
672  *      Computed L2 global Address
673  */
674 static uintptr_t l2_global_address (uintptr_t addr)
676 #if defined(SOC_K2H) || defined(SOC_K2K) || defined(SOC_K2L) || defined(SOC_K2E) || defined(SOC_K2G) || defined(SOC_C6678) || defined(SOC_C6657) || \
677     defined(DEVICE_K2H) || defined(DEVICE_K2K) || defined(DEVICE_K2L) || defined(DEVICE_K2E) || defined(DEVICE_K2G) || defined(DEVICE_C6678) || defined(DEVICE_C6657)
678 #ifdef _TMS320C6X
679     uint32_t corenum;
681     /* Get the core number. */
682     corenum = CSL_chipReadReg (CSL_CHIP_DNUM);
684     /* Compute the global address. */
685     return (addr + (0x10000000 + (corenum * 0x1000000)));
686 #else
687     return addr;
688 #endif
689 #elif defined (SOC_TPR12)
690     return ((uintptr_t)CSL_locToGlobAddr(addr));
691 #else
692     return addr;
693 #endif
697 void UART_callback(UART_Handle handle, void *buf, size_t count)
699     UART_osalPostLock(callbackSem);
702 void UART_callback2(UART_Handle handle, UART_Transaction *transaction)
704     UART_osalPostLock(callbackSem);
707 #if !defined(SOC_TPR12)
709 #define UART_NUM_TRIG_LVL           (4U)
711 /*
712  *  ======== UART_initConfigTrgLvl ========
713  */
714 static void UART_initConfigTrgLvl(uint32_t dmaMode,
715                                   uint32_t txTrigLvl,
716                                   uint32_t rxTrigLvl)
718     UART_HwAttrs uart_cfg;
720     /* Get the default UART init configurations */
721     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
723 #if defined(SOC_K2H) || defined(SOC_K2K) || defined(SOC_K2L) || defined(SOC_K2E) || defined(SOC_K2G) || defined(SOC_C6678) || defined(SOC_C6657) || defined(SOC_OMAPL137) || defined(SOC_OMAPL138) ||\
724     defined(DEVICE_K2H) || defined(DEVICE_K2K) || defined(DEVICE_K2L) || defined(DEVICE_K2E) || defined(DEVICE_K2G) || defined(DEVICE_C6678) || defined(DEVICE_C6657) || defined(DEVICE_OMAPL137) || defined(DEVICE_OMAPL138)
725     uart_cfg.txTrigLvl  = txTrigLvl;
726 #else
727     uart_cfg.txTrigLvl  = (UART_TxTrigLvl)txTrigLvl;
728 #endif
729     uart_cfg.rxTrigLvl  = (UART_RxTrigLvl)rxTrigLvl;
730     uart_cfg.loopback   = TRUE;
731 #ifdef UART_DMA_ENABLE
732     if (dmaMode == true)
733     {
734 #if defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
735         uart_cfg.edmaHandle = UartApp_udmaInit(&uart_cfg);
736 #else
737         uart_cfg.edmaHandle = UartApp_edmaInit();
738 #endif
739         uart_cfg.dmaMode    = TRUE;
740     }
741     else
742 #endif
743     {
744         uart_cfg.edmaHandle = NULL;
745         uart_cfg.dmaMode    = FALSE;
746     }
748     /* Set the TX/RX FIFO trigger levels */
749     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
752 bool UART_test_trglvl_xfer(UART_Handle uart, uint32_t dmaMode, uint32_t xferSize)
754     SemaphoreP_Params semParams;
755     UART_Transaction  transaction;
756     uintptr_t          addrFifoTrgLvlData, addrScanPrompt;
757     uint32_t          i;
758     bool              ret = false;
760     if (xferSize == 0)
761     {
762         return true;
763     }
764     /* Create call back semaphore */
765     UART_osalSemParamsInit(&semParams);
766     semParams.mode = SemaphoreP_Mode_BINARY;
767     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
769     if (dmaMode)
770     {
771         addrFifoTrgLvlData = l2_global_address((uintptr_t)fifoTrgLvlData);
772         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
773     }
774     else
775     {
776         addrFifoTrgLvlData = (uintptr_t)fifoTrgLvlData;
777         addrScanPrompt = (uintptr_t)scanPrompt;
778     }
780     /* Read in call back mode */
781     memset(scanPrompt, 0, sizeof(scanPrompt));
782     if (dmaMode)
783     {
784         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
785     }
787     UART_transactionInit(&callbackTransaction);
788     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
789     callbackTransaction.count = xferSize;
790     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
791     {
792         goto Err;
793     }
795     /* Write in blocking mode */
796     UART_transactionInit(&transaction);
797     transaction.buf = (void *)(uintptr_t)addrFifoTrgLvlData;
798     transaction.count = xferSize;
799     if (UART_write2(uart, &transaction) == UART_ERROR)
800     {
801         goto Err;
802     }
804     /* Wait for read callback */
805     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
806     {
807         goto Err;
808     }
810     /* Check if read data matches with write data */
811     for (i = 0; i < xferSize; i++)
812     {
813         if (scanPrompt[i] != fifoTrgLvlData[i])
814         {
815             goto Err;
816         }
817     }
818     ret = true;
820 Err:
821     if (callbackSem)
822     {
823             UART_osalDeleteBlockingLock(callbackSem);
824             callbackSem = NULL;
825     }
826     return (ret);
829 bool UART_test_trglvl(uint32_t dmaMode,
830                       int32_t txTrigLvl,
831                       int32_t rxTrigLvl)
833     UART_Handle       uart = NULL;
834     UART_Params       uartParams;
835     bool              ret = false;
836     int32_t           i;
838     /* UART SoC init configuration */
839     UART_initConfigTrgLvl(dmaMode, (uint32_t)(uintptr_t)txTrigLvl, (uint32_t)(uintptr_t)rxTrigLvl);
841     /* Read in callback mode and write in blocking mode */
842     UART_Params_init(&uartParams);
843     uartParams.readCallback = UART_callback;
844     uartParams.readMode = UART_MODE_CALLBACK;
845     uartParams.parityType = uartParity;
847     for ( i = -1; i < 2; i++)
848     {
849         uart = UART_open(uartTestInstance, &uartParams);
850         if (uart == NULL)
851         {
852             goto Err;
853         }
854         if (UART_test_trglvl_xfer(uart, dmaMode, (uint32_t)(uintptr_t)(txTrigLvl + i)) == false)
855         {
856             goto Err;
857         }
858         if (uart)
859         {
860             UART_close(uart);
861             uart = NULL;
862         }
864         uart = UART_open(uartTestInstance, &uartParams);
865         if (uart == NULL)
866         {
867             goto Err;
868         }
870         if (UART_test_trglvl_xfer(uart, dmaMode, (uint32_t)(uintptr_t)(rxTrigLvl + i)) == false)
871         {
872             goto Err;
873         }
875         if (uart)
876         {
877             UART_close(uart);
878             uart = NULL;
879         }
880     }
882     ret = true;
884 Err:
885     if (uart)
886     {
887         UART_close(uart);
888     }
889     return (ret);
892 /*
893  *  ======== UART DMA TX/RX FIFO trigger level test ========
894  */
895 static bool UART_test_fifo_trglvl(bool dmaMode)
897     bool     ret = true;
898     uint32_t i;
899 #if defined(SOC_AM574x) || defined(SOC_AM572x)|| defined(SOC_AM571x) || defined (SOC_DRA72x)  || defined (SOC_DRA75x) || defined (SOC_DRA78x) || defined (SOC_AM335X) || defined (SOC_AM437X) || defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
900     UART_TxTrigLvl txTrgLvl[UART_NUM_TRIG_LVL] =
901     {
902         UART_TXTRIGLVL_8,
903         UART_TXTRIGLVL_16,
904         UART_TXTRIGLVL_32,
905         UART_TXTRIGLVL_56
906     };
908     UART_RxTrigLvl rxTrgLvl[UART_NUM_TRIG_LVL] =
909     {
910         UART_RXTRIGLVL_8,
911         UART_RXTRIGLVL_16,
912         UART_RXTRIGLVL_56,
913         UART_RXTRIGLVL_60
914     };
915 #else
916     uint32_t txTrgLvl[UART_NUM_TRIG_LVL] =
917     {
918         2,
919         4,
920         8,
921         16
922     };
924     UART_RxTrigLvl rxTrgLvl[UART_NUM_TRIG_LVL] =
925     {
926         UART_RXTRIGLVL_1,
927         UART_RXTRIGLVL_4,
928         UART_RXTRIGLVL_8,
929         UART_RXTRIGLVL_14
930     };
931 #endif
932     for (i = 0; i < UART_NUM_TRIG_LVL; i++)
933     {
934         if (UART_test_trglvl(dmaMode, (int32_t)txTrgLvl[i], (int32_t)rxTrgLvl[i]) == false)
935         {
936             ret = false;
937             break;
938         }
939     }
941     return (ret);
944 #endif /* TPR12: no UART fifo */
945 /*
946  *  ======== UART stdio printf/scanf test ========
947  *
948  *  The test function tests stdio driver printf/scanf APIs
949  */
950 static bool UART_test_printf_scanf(bool dmaMode)
952     bool    ret = false;
954     if (uartParity == UART_PAR_NONE)
955     {
956         /* UART SoC init configuration */
957         UART_initConfig(dmaMode);
959         UART_stdioInit(uartTestInstance);
961         UART_printf(stdioPrint);
963 #ifndef UART_RX_LOOPBACK_ONLY
964         memset(scanPrompt, 0, sizeof(scanPrompt));
965         if (UART_scanFmt(scanPrompt) != S_PASS)
966         {
967             goto Err;
968         }
969         ret = true;
971 Err:
972 #else
973         ret = true;
974 #endif
975         UART_stdioDeInit();
976     }
977     else
978     {
979         /*
980          * bypass this test if the parity is not the default setting
981          * (UART_PAR_NONE), since UART_stdioInit() only allows default
982          * UART parameter settings.
983          */
984         ret = true;
985     }
987     return (ret);
990 /*
991  *  ======== UART stdio printf/scanf test with param config (default) ========
992  *
993  *  The test function tests stdio driver printf/scanf APIs with default params config.
994  */
995 static bool UART_test_printf_scanf_stdio_params(bool dmaMode)
997     bool    ret = false;
998     UART_Params params;
1000     /* UART SoC init configuration */
1001     UART_initConfig(dmaMode);
1003     /* UART params */
1004     UART_Params_init(&params);
1005     params.parityType = uartParity;
1007     UART_stdioInit2(uartTestInstance,&params);
1009     UART_printf(stdioPrint);
1011     memset(scanPrompt, 0, sizeof(scanPrompt));
1012 #ifndef UART_RX_LOOPBACK_ONLY
1013     if (UART_scanFmt(scanPrompt) != S_PASS)
1014     {
1015         goto Err;
1016     }
1017     ret = true;
1019 Err:
1020 #else
1021     ret = true;
1022 #endif
1023     UART_stdioDeInit();
1024     return (ret);
1027 #if !defined(UART_API2_NOT_SUPPORTED)
1028 #ifdef USE_BIOS
1029 /* Use a global variable to sync the read task and the write task */
1030 volatile bool taskSyncFlag;
1031 Void UART_simultaneous_rw_write(UArg a0, UArg a1)
1033         UART_Handle      uart = (UART_Handle)a0;
1034         bool             dmaMode = (bool)a1;
1035     uintptr_t         addrDataPrint;
1036     UART_Transaction transaction;
1038         if (dmaMode)
1039     {
1040         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1041     }
1042     else
1043     {
1044         addrDataPrint = (uintptr_t)dataPrint;
1045     }
1047     UART_transactionInit(&transaction);
1049     while (taskSyncFlag == true)
1050         {
1051         transaction.buf = (void *)(uintptr_t)addrDataPrint;
1052             transaction.count = strlen(dataPrint);
1053             UART_write2(uart, &transaction);
1054             Osal_delay(100);
1055         }
1057     /* resume the read test task */
1058     taskSyncFlag = true;
1060     Task_exit ();
1063 /*
1064  *  ======== UART simultaneous read/write test ========
1065  *
1066  *  The read task creates a write task which will continuously
1067  *  writes the data out to the console, while at the same time
1068  *  the read task reads the data from the console input.
1069  *
1070  *  Note:
1071  *  In blocking/interrupt mode, if the write size is less than
1072  *  the TX FIFO size (64 bytes), the driver will just copy
1073  *  the write data to the TX FIFO and will not use interrupt
1074  *  and write semaphore. The read task should have a higher
1075  *  priority than the write task to resume the task by the
1076  *  scheduler once it gets the read semaphore.
1077  *
1078  */
1079 static bool UART_test_simultaneous_rw(bool dmaMode)
1081     UART_Handle      uart = NULL;
1082     UART_Params      uartParams;
1083     uintptr_t         addrScanPrompt, addrEchoPrompt;
1084     UART_Transaction transaction;
1085     Task_Handle      writeTask;
1086     Task_Params      writeTaskParams;
1087     Error_Block      eb;
1088     bool             ret = false;
1090     /* UART SoC init configuration */
1091     UART_initConfig(dmaMode);
1093     /* Initialize the default configuration params. */
1094     UART_Params_init(&uartParams);
1095     uartParams.parityType = uartParity;
1097     uart = UART_open(uartTestInstance, &uartParams);
1098     if (uart == NULL)
1099     {
1100         goto Err;
1101     }
1103     /* run the write teas when task is created */
1104     taskSyncFlag = true;
1106     Error_init(&eb);
1108     /* Initialize the task params */
1109     Task_Params_init(&writeTaskParams);
1110     writeTaskParams.arg0 = (UArg)uart;
1111     writeTaskParams.arg1 = (UArg)dmaMode;
1112 #if defined (__C7100__)
1113     writeTaskParams.stackSize = 1024*16;
1114 #else
1115     writeTaskParams.stackSize = 1024*8;
1116 #endif
1117     /*
1118      * Set the write task priority to the default priority (1)
1119      * lower than the read task priority (2)
1120      */
1121     writeTaskParams.priority = 1;
1123     /* Create the UART write task */
1124     writeTask = Task_create((Task_FuncPtr)UART_simultaneous_rw_write, &writeTaskParams, &eb);
1125     if (writeTask == NULL)
1126     {
1127         System_abort("Task create failed");
1128         goto Err;
1129     }
1131     if (dmaMode)
1132     {
1133         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1134         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1135     }
1136     else
1137     {
1138         addrScanPrompt = (uintptr_t)scanPrompt;
1139         addrEchoPrompt = (uintptr_t)echoPrompt;
1140     }
1142     memset(scanPrompt, 0, sizeof(scanPrompt));
1143     if (dmaMode)
1144     {
1145         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1146     }
1147     UART_transactionInit(&transaction);
1148     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1149     transaction.count = UART_TEST_READ_LEN;
1150     if (UART_read2(uart, &transaction) == UART_ERROR)
1151     {
1152         taskSyncFlag = false;
1153         goto Err;
1154     }
1155     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
1156         (transaction.count != UART_TEST_READ_LEN))
1157     {
1158         taskSyncFlag = false;
1159         goto Err;
1160     }
1162     /* stop the write test task */
1163     taskSyncFlag = false;
1165     /* Wait for the write task complete and exit */
1166     while (taskSyncFlag == false)
1167     {
1168         Osal_delay(100);
1169     }
1170     taskSyncFlag = false;
1172     UART_transactionInit(&transaction);
1173     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1174     transaction.count = strlen(echoPrompt);
1175     if (UART_write2(uart, &transaction) == UART_ERROR)
1176     {
1177         goto Err;
1178     }
1180     UART_transactionInit(&transaction);
1181     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1182     transaction.count = UART_TEST_READ_LEN;
1183     if (UART_write2(uart, &transaction) == UART_ERROR)
1184     {
1185         goto Err;
1186     }
1188     Osal_delay(5000);
1190     ret = true;
1192 Err:
1193     if (uart)
1194     {
1195         UART_close(uart);
1196     }
1198     return (ret);
1200 #endif
1201 #endif
1203 /*
1204  *  ======== UART read cancel test ========
1205  *
1206  *  The test function uses console intput to simulate/test the
1207  *  read cancel in callback mode. In a real use case, user can
1208  *  read a large file from the console and cancel the read before
1209  *  the read is complete.
1210  *
1211  */
1212 static bool UART_test_read_write_cancel(bool dmaMode)
1214     UART_Handle       uart = NULL;
1215     UART_Params       uartParams;
1216     SemaphoreP_Params semParams;
1217     UART_Transaction  transaction;
1218     uintptr_t          addrRdCancelPrompt, addrWrCancelPrompt;
1219     uintptr_t          addrDataPrint, addrEchoPrompt, addrScanPrompt;
1220     bool              ret = false;
1222     /* Create call back semaphore */
1223     UART_osalSemParamsInit(&semParams);
1224     semParams.mode = SemaphoreP_Mode_BINARY;
1225     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
1227     /* UART SoC init configuration */
1228     UART_initConfig(dmaMode);
1230     /* Set callback mode for read */
1231     UART_Params_init(&uartParams);
1232     uartParams.readCallback = UART_callback;
1233     uartParams.readMode = UART_MODE_CALLBACK;
1234     uartParams.parityType = uartParity;
1236     if (dmaMode)
1237     {
1238         addrRdCancelPrompt = l2_global_address((uintptr_t)rdCancelPrompt);
1239         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1240         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1241         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1242     }
1243     else
1244     {
1245         addrRdCancelPrompt = (uintptr_t)rdCancelPrompt;
1246         addrDataPrint = (uintptr_t)dataPrint;
1247         addrEchoPrompt = (uintptr_t)echoPrompt;
1248         addrScanPrompt = (uintptr_t)scanPrompt;
1249     }
1251     uart = UART_open(uartTestInstance, &uartParams);
1252     if (uart == NULL)
1253     {
1254         goto Err;
1255     }
1257     /* Test receive error */
1259     /* Perform the first read, which will be cancelled before completion */
1260     memset(scanPrompt, 0, sizeof(scanPrompt));
1261     if (dmaMode)
1262     {
1263         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1264     }
1266     UART_transactionInit(&callbackTransaction);
1267     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1268     callbackTransaction.count = UART_TEST_READ_LEN;
1269 #if !defined(UART_API2_NOT_SUPPORTED)
1270     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1271 #else
1272     if (UART_read(uart, callbackTransaction.buf, UART_TEST_READ_LEN) == UART_ERROR)
1273 #endif
1274     {
1275         goto Err;
1276     }
1277     /* Delay for 10 seconds to allow user to enter chars */
1278 #if !defined(SIM_BUILD)
1279     Osal_delay(10000);
1280 #else
1281     Osal_delay(100);
1282 #endif
1283     /* Cancel the read before the read transfer is completed */
1284     UART_readCancel(uart);
1285     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1286     {
1287         goto Err;
1288     }
1290     /* Print read cancelled prompt */
1291     UART_transactionInit(&transaction);
1292     transaction.buf = (void *)(uintptr_t)addrRdCancelPrompt;
1293     transaction.count = strlen(rdCancelPrompt);
1294 #if !defined(UART_API2_NOT_SUPPORTED)
1295     if (UART_write2(uart, &transaction) == UART_ERROR)
1296 #else
1297     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1298 #endif
1299     {
1300         goto Err;
1301     }
1303     UART_transactionInit(&transaction);
1304     transaction.buf = (void *)(uintptr_t)addrDataPrint;
1305     transaction.count = strlen(dataPrint);
1306 #if !defined(UART_API2_NOT_SUPPORTED)
1307     if (UART_write2(uart, &transaction) == UART_ERROR)
1308 #else
1309     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1310 #endif
1311     {
1312         goto Err;
1313     }
1315     /* Perform the 2nd read, which will be completed */
1316     memset(scanPrompt, 0, sizeof(scanPrompt));
1317     if (dmaMode)
1318     {
1319         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1320     }
1322 #if !defined(UART_RX_LOOPBACK_ONLY)
1323     UART_transactionInit(&callbackTransaction);
1324     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1325     callbackTransaction.count = UART_TEST_READ_LEN;
1326 #if !defined(UART_API2_NOT_SUPPORTED)
1327     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1328 #else
1329     if (UART_read(uart, callbackTransaction.buf, UART_TEST_READ_LEN) == UART_ERROR)
1330 #endif
1331     {
1332         goto Err;
1333     }
1334     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1335     {
1336         goto Err;
1337     }
1338 #endif
1339     UART_transactionInit(&transaction);
1340     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1341     transaction.count = strlen(echoPrompt);
1342 #if !defined(UART_API2_NOT_SUPPORTED)
1343     if (UART_write2(uart, &transaction) == UART_ERROR)
1344 #else
1345     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1346 #endif
1347     {
1348         goto Err;
1349     }
1351     /* Print the 2nd read chars, should NOT contain any chars
1352      * in the first cancelled read
1353      */
1354     UART_transactionInit(&transaction);
1355     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1356     transaction.count = sizeof(scanPrompt);
1357 #if !defined(UART_API2_NOT_SUPPORTED)
1358     if (UART_write2(uart, &transaction) == UART_ERROR)
1359 #else
1360     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1361 #endif
1362     {
1363         goto Err;
1364     }
1366     UART_close(uart);
1368     /* write cancel test */
1370     /* Set callback mode for write */
1371     UART_Params_init(&uartParams);
1372     uartParams.writeCallback = UART_callback;
1373     uartParams.writeMode = UART_MODE_CALLBACK;
1374     uartParams.parityType = uartParity;
1376     if (dmaMode)
1377     {
1378         addrWrCancelPrompt = l2_global_address((uintptr_t)wrCancelPrompt);
1379     }
1380     else
1381     {
1382         addrWrCancelPrompt = (uintptr_t)wrCancelPrompt;
1383     }
1385     uart = UART_open(uartTestInstance, &uartParams);
1386     if (uart == NULL)
1387     {
1388         goto Err;
1389     }
1391     /* Perform the 1st write */
1392     UART_transactionInit(&callbackTransaction);
1393     callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
1394     callbackTransaction.count = strlen(wrCancelPrompt);
1395 #if !defined(UART_API2_NOT_SUPPORTED)
1396     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1397 #else
1398     if (UART_write(uart, callbackTransaction.buf, callbackTransaction.count) == UART_ERROR)
1399 #endif
1400     {
1401         goto Err;
1402     }
1403     /* Cancel the 1st write */
1404     UART_writeCancel(uart);
1405     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1406     {
1407         goto Err;
1408     }
1410     /* Perform the 2nd write */
1411     UART_transactionInit(&callbackTransaction);
1412     callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
1413     callbackTransaction.count = strlen(wrCancelPrompt);
1414 #if !defined(UART_API2_NOT_SUPPORTED)
1415     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1416 #else
1417     if (UART_write(uart, callbackTransaction.buf, callbackTransaction.count) == UART_ERROR)
1418 #endif
1419     {
1420         goto Err;
1421     }
1422     /* Cancel the write */
1423     UART_writeCancel(uart);
1424     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1425     {
1426         goto Err;
1427     }
1428     ret = true;
1430 Err:
1431     if (uart)
1432     {
1433         UART_close(uart);
1434     }
1436     if (callbackSem)
1437     {
1438         UART_osalDeleteBlockingLock(callbackSem);
1439         callbackSem = NULL;
1440     }
1442     return (ret);
1445 #if !defined(UART_API2_NOT_SUPPORTED)
1446 /*
1447  *  ======== UART receive error test ========
1448  *
1449  *  The test function tests receive error (e.g. break condition)
1450  */
1451 static bool UART_test_rx_err(bool dmaMode)
1453     UART_Handle      uart = NULL;
1454     UART_Params      uartParams;
1455     UART_Transaction transaction;
1456     uintptr_t         addrScanPrompt, addrBreakErrPrompt;
1457     bool             ret = false;
1459     /* UART SoC init configuration */
1460     UART_initConfig(dmaMode);
1462     /* Initialize the default configuration params. */
1463     UART_Params_init(&uartParams);
1464     uartParams.parityType = uartParity;
1466     if (dmaMode)
1467     {
1468         addrBreakErrPrompt = l2_global_address((uintptr_t)breakErrPrompt);
1469         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1470     }
1471     else
1472     {
1473         addrBreakErrPrompt = (uintptr_t)breakErrPrompt;
1474         addrScanPrompt = (uintptr_t)scanPrompt;
1475     }
1477     uart = UART_open(uartTestInstance, &uartParams);
1478     if (uart == NULL)
1479     {
1480         goto Err;
1481     }
1483     /* Test receive error */
1484     memset(scanPrompt, 0, sizeof(scanPrompt));
1485     if (dmaMode)
1486     {
1487         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1488     }
1489     UART_transactionInit(&transaction);
1490     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1491     transaction.count = UART_TEST_READ_LEN;
1492     if (UART_read2(uart, &transaction) == UART_ERROR)
1493     {
1494         if (transaction.status == UART_TRANSFER_STATUS_ERROR_BI)
1495         {
1496             UART_transactionInit(&transaction);
1497             transaction.buf = (void *)(uintptr_t)addrBreakErrPrompt;
1498             transaction.count = strlen(breakErrPrompt);
1499             if (UART_write2(uart, &transaction) == UART_ERROR)
1500             {
1501                 goto Err;
1502             }
1503         }
1504         else
1505         {
1506             goto Err;
1507         }
1508     }
1510     ret = true;
1512 Err:
1513     if (uart)
1514     {
1515         UART_close(uart);
1516     }
1518     return (ret);
1521 #endif
1523 /*
1524  *  ======== UART timeout test ========
1525  *
1526  *  The test function tests read/write with OS timeout
1527  */
1528 static bool UART_test_timeout(bool dmaMode)
1530     UART_Handle      uart = NULL;
1531     UART_Params      uartParams;
1532     UART_Transaction transaction;
1533     uintptr_t         addrScanPrompt, addrReadTimeoutPrompt;
1534     bool             ret = false;
1536     /* UART SoC init configuration */
1537     UART_initConfig(dmaMode);
1539     /* Initialize the default configuration params. */
1540     UART_Params_init(&uartParams);
1541     uartParams.parityType = uartParity;
1542     uartParams.readTimeout = UART_TEST_TIMEOUT;
1544     if (dmaMode)
1545     {
1546         addrReadTimeoutPrompt = l2_global_address((uintptr_t)readTimeoutPrompt);
1547         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1548     }
1549     else
1550     {
1551         addrReadTimeoutPrompt = (uintptr_t)readTimeoutPrompt;
1552         addrScanPrompt = (uintptr_t)scanPrompt;
1553     }
1555     uart = UART_open(uartTestInstance, &uartParams);
1556     if (uart == NULL)
1557     {
1558         goto Err;
1559     }
1561     /* Test read timeout */
1562     memset(scanPrompt, 0, sizeof(scanPrompt));
1563     if (dmaMode)
1564     {
1565         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1566     }
1567     UART_transactionInit(&transaction);
1568     transaction.buf = (void *)(uintptr_t)scanPrompt;
1569     transaction.count = UART_TEST_READ_LEN;
1570     transaction.timeout = UART_TEST_TIMEOUT;
1571 #if !defined(UART_API2_NOT_SUPPORTED)
1572     if (UART_read2(uart, &transaction) == UART_ERROR)
1573 #else
1574     if (UART_read(uart, transaction.buf, transaction.count) == UART_ERROR)
1575 #endif
1576     {
1577         UART_transactionInit(&transaction);
1578         transaction.buf = (void *)(uintptr_t)addrReadTimeoutPrompt;
1579         transaction.count = strlen(readTimeoutPrompt);
1580         transaction.timeout = UART_TEST_TIMEOUT;
1581         if (UART_write2(uart, &transaction) == UART_ERROR)
1582         {
1583             goto Err;
1584         }
1585     }
1587     ret = true;
1589 Err:
1590     if (uart)
1591     {
1592         UART_close(uart);
1593     }
1595     return (ret);
1598 /*
1599  *  ======== UART polling timeout test ========
1600  *
1601  *  The test function tests read/write with OS timeout in polling mode
1602  */
1603 static bool UART_test_polling_timeout(bool dmaMode)
1605     UART_Handle      uart = NULL;
1606     UART_Params      uartParams;
1607     bool             ret = false;
1608     uint32_t         rdSize = UART_TEST_READ_LEN;
1609     uint32_t         wrSize = strlen(readTimeoutPrompt);
1611     /* UART SoC init configuration */
1612     UART_initConfig(dmaMode);
1614     /* Initialize the default configuration params. */
1615     UART_Params_init(&uartParams);
1616     uartParams.parityType = uartParity;
1618     /* timeout is 0 for both read and write */
1619     uartParams.readTimeout  = UART_NO_WAIT;
1620     uartParams.writeTimeout = UART_NO_WAIT;
1621     uart = UART_open(uartTestInstance, &uartParams);
1622     if (uart == NULL)
1623     {
1624         goto Err;
1625     }
1627     memset(scanPrompt, 0, sizeof(scanPrompt));
1628     if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1629     {
1630         if (UART_writePolling(uart, (const void *)readTimeoutPrompt, wrSize) != wrSize)
1631         {
1632             ret = true;
1633         }
1634     }
1636     if (ret == true)
1637     {
1638         ret = false;
1640         UART_close(uart);
1642         /* timeout is 5 seconds for both read and write */
1643         uartParams.readTimeout  = UART_TEST_TIMEOUT;
1644         uartParams.writeTimeout = UART_TEST_TIMEOUT;
1645         uart = UART_open(uartTestInstance, &uartParams);
1646         if (uart == NULL)
1647         {
1648             goto Err;
1649         }
1651         /* Test read timeout */
1652         memset(scanPrompt, 0, sizeof(scanPrompt));
1653         if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1654         {
1655             UART_writePolling(uart, (const void *)readTimeoutPrompt, wrSize);
1656             ret = true;
1657         }
1658     }
1660     if (ret == true)
1661     {
1662         ret = false;
1664         UART_close(uart);
1666         /* timeout is 5 seconds for both read and write */
1667         uartParams.readTimeout  = UART_WAIT_FOREVER;
1668         uartParams.writeTimeout = UART_WAIT_FOREVER;
1669         uart = UART_open(uartTestInstance, &uartParams);
1670         if (uart == NULL)
1671         {
1672             goto Err;
1673         }
1675         wrSize = strlen(dataPrint);
1676         UART_writePolling(uart, (const void *)dataPrint, wrSize);
1678         memset(scanPrompt, 0, sizeof(scanPrompt));
1680 #if !defined(UART_RX_LOOPBACK_ONLY)
1681         if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1682         {
1683             goto Err;
1684         }
1685 #endif
1686         wrSize = strlen(echoPrompt);
1687         UART_writePolling(uart, (const void *)echoPrompt, wrSize);
1688         UART_writePolling(uart, (const void *)scanPrompt, rdSize);
1690         ret = true;
1691     }
1693 Err:
1694     if (uart)
1695     {
1696         UART_close(uart);
1697     }
1699     return (ret);
1702 /*
1703  *  ======== UART callback test ========
1704  *
1705  *  The test function tests the read/write in callback mode
1706  */
1707 static bool UART_test_callback(bool dmaMode)
1709     UART_Handle       uart = NULL;
1710     UART_Params       uartParams;
1711     SemaphoreP_Params semParams;
1712     uintptr_t          addrScanPrompt, addrDataPrint, addrEchoPrompt;
1713     bool              ret = false;
1715     /* Create call back semaphore */
1716     UART_osalSemParamsInit(&semParams);
1717     semParams.mode = SemaphoreP_Mode_BINARY;
1718     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
1720     /* Test read/write API's in callback mode */
1722     /* UART SoC init configuration */
1723     UART_initConfig(dmaMode);
1725     /* Set callback mode for both read and write */
1726     UART_Params_init(&uartParams);
1727     uartParams.readCallback = UART_callback;
1728     uartParams.readMode = UART_MODE_CALLBACK;
1729     uartParams.writeCallback = UART_callback;
1730     uartParams.writeMode = UART_MODE_CALLBACK;
1731     uartParams.parityType = uartParity;
1733     uart = UART_open(uartTestInstance, &uartParams);
1734     if (uart == NULL)
1735     {
1736         goto Err;
1737     }
1739     if (dmaMode)
1740     {
1741         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1742         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1743         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1744     }
1745     else
1746     {
1747         addrScanPrompt = (uintptr_t)scanPrompt;
1748         addrDataPrint = (uintptr_t)dataPrint;
1749         addrEchoPrompt = (uintptr_t)echoPrompt;
1750     }
1752     /* Write DMA or non-DMA test prompt */
1753     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
1754     {
1755         goto Err;
1756     }
1757     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1758     {
1759         goto Err;
1760     }
1762     memset(scanPrompt, 0, sizeof(scanPrompt));
1763     if (dmaMode)
1764     {
1765         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1766     }
1768 #if !defined(UART_RX_LOOPBACK_ONLY)
1770     if (UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN) == UART_ERROR)
1771     {
1772         goto Err;
1773     }
1774     if (UART_osalPendLock(callbackSem, uartParams.readTimeout) != SemaphoreP_OK)
1775     {
1776         goto Err;
1777     }
1779 #endif
1781     if (UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt)) == UART_ERROR)
1782     {
1783         goto Err;
1784     }
1785     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1786     {
1787         goto Err;
1788     }
1790     if (UART_write(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN) == UART_ERROR)
1791     {
1792         goto Err;
1793     }
1794     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1795     {
1796         goto Err;
1797     }
1799     UART_close(uart);
1800     uart = NULL;
1802     /* Test read2/write2 API's in callback mode */
1803 #if !defined(UART_API2_NOT_SUPPORTED)
1804     uartParams.readCallback2 = UART_callback2;
1805     uartParams.writeCallback2 = UART_callback2;
1806     uartParams.readCallback = NULL;
1807     uartParams.writeCallback = NULL;
1809     uart = UART_open(uartTestInstance, &uartParams);
1810     if (uart == NULL)
1811     {
1812         goto Err;
1813     }
1815     UART_transactionInit(&callbackTransaction);
1816     callbackTransaction.buf = (void *)(uintptr_t)addrDataPrint;
1817     callbackTransaction.count = strlen(dataPrint);
1818     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1819     {
1820         goto Err;
1821     }
1822     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1823     {
1824         goto Err;
1825     }
1827     memset(scanPrompt, 0, sizeof(scanPrompt));
1828     if (dmaMode)
1829     {
1830         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1831     }
1833 #if !defined(UART_RX_LOOPBACK_ONLY)
1834     UART_transactionInit(&callbackTransaction);
1835     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1836     callbackTransaction.count = UART_TEST_READ_LEN;
1837     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1838     {
1839         goto Err;
1840     }
1841     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1842     {
1843         goto Err;
1844     }
1845 #endif
1847     UART_transactionInit(&callbackTransaction);
1848     callbackTransaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1849     callbackTransaction.count = strlen(echoPrompt);
1850     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1851     {
1852         goto Err;
1853     }
1854     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1855     {
1856         goto Err;
1857     }
1859     UART_transactionInit(&callbackTransaction);
1860     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1861     callbackTransaction.count = UART_TEST_READ_LEN;
1862     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1863     {
1864         goto Err;
1865     }
1866     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1867     {
1868         goto Err;
1869     }
1871 #endif
1872     ret = true;
1874 Err:
1875     if (uart)
1876     {
1877         UART_close(uart);
1878     }
1879     if (callbackSem)
1880     {
1881         UART_osalDeleteBlockingLock(callbackSem);
1882         callbackSem = NULL;
1883     }
1884     return (ret);
1887 #if defined (SOC_AM64X)
1888 /* RS-485 Direction Enable loopback test */
1889 static bool UART_test_rs485(bool dmaMode)
1891     UART_Handle      uart = NULL;
1892     UART_Params      uartParams;
1893     int16_t          length = 0;
1894     bool             ret = true;
1895     uint8_t rBuff[UART_TEST_READ_LEN], tBuff[]="aaaabbbbccccddddeeee";
1897     /* UART SoC init configuration */
1898     verifyRS485    = TRUE;
1899     verifyLoopback = TRUE;
1900     UART_initConfig(dmaMode);
1902     UART_Params_init(&uartParams);
1903     uart = UART_open(uartTestInstance, &uartParams);
1904     if (uart == NULL)
1905     {
1906         goto Err;
1907     }
1909     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
1910     {
1911         goto Err;
1912     }
1914     memset(rBuff, 0, UART_TEST_READ_LEN);
1915     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
1916     for(length=0; length<UART_TEST_READ_LEN; length++)
1917     {
1918         if(tBuff[length] != rBuff[length])
1919         {
1920             ret = false;
1921             break;
1922         }
1923     }
1924     UART_close(uart);
1926 Err:
1927     if (uart != NULL)
1928     {
1929         UART_close(uart);
1930     }
1932     verifyRS485    = FALSE;
1933     verifyLoopback = FALSE;
1934     return (ret);
1936 #endif
1938 /*
1939  *  ========== UART read API test ==========
1940  *
1941  *  The test function for UART_read API
1942  *  in loopback mode
1943  */
1944 static bool UART_test_read_verify(bool dmaMode)
1946     UART_Handle      uart = NULL;
1947     UART_Params      uartParams;
1948     int16_t          length = 0;
1949     bool             ret = false;
1950     uint8_t rBuff[UART_TEST_READ_LEN], tBuff[]="aaaabbbbccccddddeeee";
1951 #if defined(UART_NO_FIFO)
1952     int i;
1953 #endif
1955     verifyLoopback = TRUE;
1956     /* UART SoC init configuration */
1957     UART_initConfig(dmaMode);
1959     /* Initialize the default configuration params. */
1960     UART_Params_init(&uartParams);
1961     uartParams.parityType = uartParity;
1963     uart = UART_open(uartTestInstance, &uartParams);
1965     if (uart == NULL)
1966     {
1967         goto Err;
1968     }
1970 #if !defined(UART_NO_FIFO)
1972     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
1973     {
1974         goto Err;
1975     }
1977     length = UART_read(uart, (void *)&rBuff[0], UART_RDVERIFY_READ_LEN);
1979     if (UART_write(uart, (void *)&tBuff[15], UART_RDVERIFY_READ_LEN) == UART_ERROR)
1980     {
1981         goto Err;
1982     }
1984     length = UART_read(uart, (void *)&rBuff[4], UART_RDVERIFY_READ_LEN);
1985     length = UART_read(uart, (void *)&rBuff[8], UART_RDVERIFY_READ_LEN);
1986     length = UART_read(uart, (void *)&rBuff[12], UART_RDVERIFY_READ_LEN);
1987 #else
1988     memset(rBuff, 0, UART_TEST_READ_LEN);
1989     for (i =0; i < UART_TEST_READ_LEN;i++)
1990     {
1991         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
1992         {
1993             goto Err;
1994         }
1996         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
1997     }
1999 #endif
2001     ret = true;
2002     for(length=0; length<UART_TEST_READ_LEN; length++)
2003     {
2004         if(tBuff[length] != rBuff[length])
2005         {
2006             ret = false;
2007             break;
2008         }
2009     }
2010     UART_close(uart);
2012     /* stop bit loopback test */
2013     UART_Params_init(&uartParams);
2014     uartParams.stopBits = UART_STOP_TWO;
2015     uart = UART_open(uartTestInstance, &uartParams);
2016     if (uart == NULL)
2017     {
2018         goto Err;
2019     }
2021 #if !defined(UART_NO_FIFO)
2022     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2023     {
2024         goto Err;
2025     }
2027     memset(rBuff, 0, UART_TEST_READ_LEN);
2028     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2029 #else
2030     memset(rBuff, 0, UART_TEST_READ_LEN);
2031     for (i =0; i < UART_TEST_READ_LEN;i++)
2032     {
2033         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2034         {
2035             goto Err;
2036         }
2038         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2039     }
2040 #endif
2041     for(length=0; length<UART_TEST_READ_LEN; length++)
2042     {
2043         if(tBuff[length] != rBuff[length])
2044         {
2045             ret = false;
2046             break;
2047         }
2048     }
2049     UART_close(uart);
2051     /* char length loopback test */
2052     UART_Params_init(&uartParams);
2053     uartParams.dataLength = UART_LEN_5;
2054     uart = UART_open(uartTestInstance, &uartParams);
2055     if (uart == NULL)
2056     {
2057         goto Err;
2058     }
2060 #if !defined(UART_NO_FIFO)
2061     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2062     {
2063         goto Err;
2064     }
2066     memset(rBuff, 0, UART_TEST_READ_LEN);
2067     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2068 #else
2069     memset(rBuff, 0, UART_TEST_READ_LEN);
2070     for (i =0; i < UART_TEST_READ_LEN;i++)
2071     {
2072         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2073         {
2074             goto Err;
2075         }
2077         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2078     }
2079 #endif
2080     for(length=0; length<UART_TEST_READ_LEN; length++)
2081     {
2082         if ((tBuff[length] & ((1 << (uartParams.dataLength + 5)) - 1)) != rBuff[length])
2083         {
2084             ret = false;
2085             break;
2086         }
2087     }
2088     UART_close(uart);
2090     /* parity loopback test */
2091     UART_Params_init(&uartParams);
2092     uartParams.parityType = UART_PAR_EVEN;
2093     uart = UART_open(uartTestInstance, &uartParams);
2094     if (uart == NULL)
2095     {
2096         goto Err;
2097     }
2098 #if !defined(UART_NO_FIFO)
2099     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2100     {
2101         goto Err;
2102     }
2104     memset(rBuff, 0, UART_TEST_READ_LEN);
2105     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2106 #else
2107     memset(rBuff, 0, UART_TEST_READ_LEN);
2108     for (i =0; i < UART_TEST_READ_LEN;i++)
2109     {
2110         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2111         {
2112             goto Err;
2113         }
2115         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2116     }
2117 #endif
2118     for(length=0; length<UART_TEST_READ_LEN; length++)
2119     {
2120         if(tBuff[length] != rBuff[length])
2121         {
2122             ret = false;
2123             break;
2124         }
2125     }
2126     UART_close(uart);
2127     uart = NULL;
2129 #if defined (SOC_AM64X)
2130     if (UART_test_rs485(dmaMode) == false)
2131     {
2132         ret = false;
2133     }
2134 #endif
2135 Err:
2136     if (uart != NULL)
2137     {
2138         UART_close(uart);
2139     }
2141     verifyLoopback = FALSE;
2142     return (ret);
2145 /*
2146  *  ======== UART read/write test ========
2147  *
2148  *  The test function tests read/write in blocking mode
2149  */
2150 static bool UART_test_read_write(bool dmaMode)
2152     UART_Handle      uart = NULL;
2153     UART_Params      uartParams;
2154     int              length = 0;
2155     uintptr_t        addrDataPrint, addrScanPrompt, addrEchoPrompt;
2156 #if !defined(UART_API2_NOT_SUPPORTED)
2157     UART_Transaction transaction;
2158 #endif
2159     bool             ret = false;
2161     /* UART SoC init configuration */
2162     UART_initConfig(dmaMode);
2164     /* Initialize the default configuration params. */
2165     UART_Params_init(&uartParams);
2166     uartParams.parityType = uartParity;
2168     uart = UART_open(uartTestInstance, &uartParams);
2170     if (uart == NULL)
2171     {
2172         goto Err;
2173     }
2175     if (dmaMode)
2176     {
2177         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
2178         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
2179         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
2180     }
2181     else
2182     {
2183         addrDataPrint = (uintptr_t)dataPrint;
2184         addrScanPrompt = (uintptr_t)scanPrompt;
2185         addrEchoPrompt = (uintptr_t)echoPrompt;
2186     }
2188     /* Test read/write API's in blocking mode */
2189     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
2190     {
2191         goto Err;
2192     }
2194     memset(scanPrompt, 0, sizeof(scanPrompt));
2195     if (dmaMode)
2196     {
2197         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2198     }
2199 #ifndef UART_RX_LOOPBACK_ONLY
2200     length = UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN);
2201     if (length != UART_TEST_READ_LEN)
2202     {
2203         goto Err;
2204     }
2205 #endif
2207     UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
2209     UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
2210     UART_close(uart);
2212 #if !defined(UART_API2_NOT_SUPPORTED)
2213     uart = UART_open(uartTestInstance, &uartParams);
2214     if (uart == NULL)
2215     {
2216         goto Err;
2217     }
2219     /* Test read2/write2 API's in blocking mode */
2220     UART_transactionInit(&transaction);
2221     transaction.buf = (void *)(uintptr_t)addrDataPrint;
2222     transaction.count = strlen(dataPrint);
2223     if (UART_write2(uart, &transaction) == UART_ERROR)
2224     {
2225         goto Err;
2226     }
2228     memset(scanPrompt, 0, sizeof(scanPrompt));
2229     if (dmaMode)
2230     {
2231         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2232     }
2233     UART_transactionInit(&transaction);
2234     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2235     transaction.count = UART_TEST_READ_LEN;
2236     if (UART_read2(uart, &transaction) == UART_ERROR)
2237     {
2238         goto Err;
2239     }
2240     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
2241         (transaction.count != UART_TEST_READ_LEN))
2242     {
2243         goto Err;
2244     }
2246     UART_transactionInit(&transaction);
2247     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
2248     transaction.count = strlen(echoPrompt);
2249     if (UART_write2(uart, &transaction) == UART_ERROR)
2250     {
2251         goto Err;
2252     }
2254     UART_transactionInit(&transaction);
2255     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2256     transaction.count = UART_TEST_READ_LEN;
2257     if (UART_write2(uart, &transaction) == UART_ERROR)
2258     {
2259         goto Err;
2260     }
2262 #else
2263     uart = NULL;
2264 #endif
2266     ret = true;
2268 Err:
2269     if (uart)
2270     {
2271         UART_close(uart);
2272     }
2274     return (ret);
2277 /*
2278  *  ======== UART read/write test with interrupt disabled ========
2279  *
2280  *  The test function tests read/write with interrupt disabled
2281  */
2282 static bool UART_test_read_write_int_disable(bool dmaMode)
2284     UART_Handle      uart = NULL;
2285     UART_Params      uartParams;
2286     int              length = 0;
2287     uintptr_t         addrDataPrint, addrScanPrompt, addrEchoPrompt;
2288     UART_Transaction transaction;
2289     bool             ret = false;
2290     UART_HwAttrs uart_cfg;
2292     /* UART SoC init configuration */
2293     UART_initConfig(dmaMode);
2295     /* Initialize the default configuration params. */
2296     UART_Params_init(&uartParams);
2297     uartParams.parityType = uartParity;
2299     /* Get the default UART init configurations */
2300     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
2302     uart_cfg.enableInterrupt=0; /* Disabling interrupt forcefully */
2304     /* Get the default UART init configurations */
2305     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
2307     uart = UART_open(uartTestInstance, &uartParams);
2309     if (uart == NULL)
2310     {
2311         goto Err;
2312     }
2314     if (dmaMode)
2315     {
2316         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
2317         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
2318         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
2319     }
2320     else
2321     {
2322         addrDataPrint = (uintptr_t)dataPrint;
2323         addrScanPrompt = (uintptr_t)scanPrompt;
2324         addrEchoPrompt = (uintptr_t)echoPrompt;
2325     }
2327     /* Test read/write API's in blocking mode */
2328     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
2329     {
2330         goto Err;
2331     }
2333     memset(scanPrompt, 0, sizeof(scanPrompt));
2334     if (dmaMode)
2335     {
2336         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2337     }
2339 #if !defined(UART_RX_LOOPBACK_ONLY)
2340     length = UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN);
2341     if (length != UART_TEST_READ_LEN)
2342     {
2343         goto Err;
2344     }
2345 #endif
2346     UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
2348     UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
2349     UART_close(uart);
2351     uart = UART_open(uartTestInstance, &uartParams);
2352     if (uart == NULL)
2353     {
2354         goto Err;
2355     }
2357 #if !defined(UART_API_NOT_SUPPORTED)
2358     /* Test read2/write2 API's in blocking mode */
2359     UART_transactionInit(&transaction);
2360     transaction.buf = (void *)(uintptr_t)addrDataPrint;
2361     transaction.count = strlen(dataPrint);
2362     if (UART_write2(uart, &transaction) == UART_ERROR)
2363     {
2364         goto Err;
2365     }
2367     memset(scanPrompt, 0, sizeof(scanPrompt));
2368     if (dmaMode)
2369     {
2370         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2371     }
2372     UART_transactionInit(&transaction);
2373     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2374     transaction.count = UART_TEST_READ_LEN;
2375     if (UART_read2(uart, &transaction) == UART_ERROR)
2376     {
2377         goto Err;
2378     }
2379     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
2380         (transaction.count != UART_TEST_READ_LEN))
2381     {
2382         goto Err;
2383     }
2385     UART_transactionInit(&transaction);
2386     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
2387     transaction.count = strlen(echoPrompt);
2388     if (UART_write2(uart, &transaction) == UART_ERROR)
2389     {
2390         goto Err;
2391     }
2393     UART_transactionInit(&transaction);
2394     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2395     transaction.count = UART_TEST_READ_LEN;
2396     if (UART_write2(uart, &transaction) == UART_ERROR)
2397     {
2398         goto Err;
2399     }
2401 #endif
2402     ret = true;
2404 Err:
2405     if (uart)
2406     {
2407         UART_close(uart);
2408     }
2410     /* Get the default UART init configurations */
2411     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
2412     uart_cfg.enableInterrupt=1; /* Re-enabling interrupt for the remaining the tests */
2413     /* Get the default UART init configurations */
2414     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
2416     return (ret);
2419 #ifdef UART_DMA_ENABLE
2420 #if !defined(SOC_TPR12)
2421 static uint32_t UART_getMaxNumInst(uint32_t numInst)
2423     uint32_t     i = 0;
2424 #if defined (SOC_AM572x) || defined (SOC_AM571x) || defined (SOC_AM574x) || defined (SOC_AM335X) || defined (SOC_AM437X)
2425     UART_HwAttrs uart_cfg;
2427     for (i = 0; i < numInst; i++)
2428     {
2429         memset(&uart_cfg, 0, sizeof(UART_HwAttrs));
2430         UART_socGetInitCfg(i, &uart_cfg);
2432         if (uart_cfg.baseAddr == 0)
2433         {
2434             break;
2435         }
2436     }
2437 #endif
2438     return (i);
2440 SemaphoreP_Handle MiCbSem[UART_TEST_NUM_INSTS] = {NULL, };
2441 UART_Handle       MiUartHandle[UART_TEST_NUM_INSTS] = {NULL, };
2442 void UART_miCallback(UART_Handle handle, void *buf, size_t count)
2444     uint32_t i;
2446     for (i = 0; i < UART_TEST_NUM_INSTS; i++)
2447     {
2448         if (MiUartHandle[i] == handle)
2449         {
2450             UART_osalPostLock(MiCbSem[i]);
2451             break;
2452         }
2453     }
2456 /*
2457  *  ========== UART multiple instances test ==========
2458  *
2459  *  The test function for UART read/write on multiple instances
2460  *  in loopback mode
2461  */
2462 #if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
2463 #pragma DATA_ALIGN (MiRxBuf, UART_TEST_CACHE_LINE_SIZE)
2464 char MiRxBuf[UART_TEST_NUM_INSTS][UART_TEST_CACHE_LINE_SIZE];
2465 #pragma DATA_ALIGN (MiTxBuf, UART_TEST_CACHE_LINE_SIZE)
2466 char MiTxBuf[UART_TEST_CACHE_LINE_SIZE];
2467 #else
2468 char MiRxBuf[UART_TEST_NUM_INSTS][UART_TEST_CACHE_LINE_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2469 char MiTxBuf[UART_TEST_CACHE_LINE_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2470 #endif
2472 static bool UART_test_multiple_instances(bool dmaMode)
2474     UART_Params       uartParams;
2475     bool              ret = false;
2476     uint32_t          i, j;
2477     uintptr_t          bufAddr;
2478     uint32_t          uartTestStartInst = uartTestInstance;
2479     uint32_t          numUartTestInstances;
2480     SemaphoreP_Params semParams;
2482     /* enable the loopback */
2483     verifyLoopback = TRUE;
2485     /* Get the max number of instances for testing */
2486     numUartTestInstances = UART_getMaxNumInst(UART_TEST_NUM_INSTS);
2488     for (i = 0; i < numUartTestInstances; i++)
2489     {
2490         /* UART SoC init configuration */
2491         UART_initConfig(dmaMode);
2493         /* Create call back semaphores */
2494         UART_osalSemParamsInit(&semParams);
2495         semParams.mode = SemaphoreP_Mode_BINARY;
2496         MiCbSem[i] = UART_osalCreateBlockingLock(0, &semParams);
2498         /* Set callback mode for read */
2499         UART_Params_init(&uartParams);
2500         uartParams.readCallback = UART_miCallback;
2501         uartParams.readMode = UART_MODE_CALLBACK;
2502         uartParams.parityType = uartParity;
2504         MiUartHandle[i] = UART_open(uartTestInstance, &uartParams);
2505         if (MiUartHandle[i] == NULL)
2506         {
2507             goto Err;
2508         }
2509         uartTestInstance++;
2510     }
2512     for (i = 0; i < numUartTestInstances; i++)
2513     {
2514         memset(MiRxBuf[i], 0, UART_TEST_CACHE_LINE_SIZE);
2515         if (dmaMode)
2516         {
2517             bufAddr = l2_global_address((uintptr_t)MiRxBuf[i]);
2518             CacheP_wbInv((void *)(uintptr_t)bufAddr, UART_TEST_CACHE_LINE_SIZE);
2519         }
2520         else
2521         {
2522             bufAddr = (uintptr_t)MiRxBuf[i];
2523         }
2525         UART_read(MiUartHandle[i], (void *)(uintptr_t)bufAddr, UART_TEST_READ_LEN);
2526     }
2528     for (i = 0; i < numUartTestInstances; i++)
2529     {
2530         for (j = 0; j < UART_TEST_READ_LEN; j++)
2531         {
2532             MiTxBuf[j] = fifoTrgLvlData[j] + (char)i;
2533         }
2534         if (dmaMode)
2535         {
2536             bufAddr = l2_global_address((uintptr_t)MiTxBuf);
2537             CacheP_wbInv((void *)(uintptr_t)bufAddr, UART_TEST_CACHE_LINE_SIZE);
2538         }
2539         else
2540         {
2541             bufAddr = (uintptr_t)MiTxBuf;
2542         }
2544         if (UART_write(MiUartHandle[i], (void *)(uintptr_t)bufAddr, UART_TEST_READ_LEN) == UART_ERROR)
2545         {
2546             goto Err;
2547         }
2548     }
2550     /* add delay for the read semaphore calback */
2551     Osal_delay(100);
2553     for (i = 0; i < numUartTestInstances; i++)
2554     {
2555         for (j = 0; j < UART_TEST_READ_LEN; j++)
2556         {
2557             if ((fifoTrgLvlData[j] + (char)i) != MiRxBuf[i][j])
2558             {
2559                 goto Err;
2560             }
2561         }
2562     }
2564     ret = true;
2566 Err:
2567     for (i = 0; i < numUartTestInstances; i++)
2568     {
2569         if (MiUartHandle[i] != NULL)
2570         {
2571             UART_close(MiUartHandle[i]);
2572             MiUartHandle[i] = NULL;
2573         }
2574     }
2576     verifyLoopback = FALSE;
2577     uartTestInstance = uartTestStartInst;
2578     return (ret);
2580 #endif /* if SOC_TPR12 */
2581 #endif /* if DMA */
2583 /**
2584  *  @b Description
2585  *  @n
2586  *      The function is used to test the UART Driver *WRITE* functions with
2587  *      various invalid arguments.
2588  *
2589  *  @param[in]  handle
2590  *      UART Handle
2591  *
2592  *  @retval
2593  *      Success -   0
2594  *  @retval
2595  *      Error   -   <0
2596  */
2597 static bool UART_writeInvalidArgs(UART_Handle handle)
2599     uint8_t     buffer[4];
2600     int32_t     status;
2602     /**************************************************************************
2603      * Test: Write with invalid buffer
2604      **************************************************************************/
2605     status = UART_write(handle, NULL, 128);
2606     if (status >= 0)
2607     {
2608         UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
2609         return false;
2610     }
2612     /**************************************************************************
2613      * Test: Write with invalid size
2614      **************************************************************************/
2615     status = UART_write(handle, &buffer[0], 0);
2616     if (status >= 0)
2617     {
2618         UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
2619         return false;
2620     }
2622     /**************************************************************************
2623      * Test: Write Polling with invalid buffer
2624      **************************************************************************/
2625     status = UART_writePolling(handle, NULL, 128);
2626     if (status >= 0)
2627     {
2628         UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
2629         return false;
2630     }
2632     /**************************************************************************
2633      * Test: Write Polling with invalid size
2634      **************************************************************************/
2635     status = UART_writePolling(handle, &buffer[0], 0);
2636     if (status >= 0)
2637     {
2638         UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
2639         return false;
2640     }
2642     return true;
2645 /**
2646  *  @b Description
2647  *  @n
2648  *      The function is used to test the UART Driver *READ* functions with
2649  *      various invalid arguments.
2650  *
2651  *  @param[in]  handle
2652  *      UART Handle
2653  *
2654  *  @retval
2655  *      Success -   0
2656  *  @retval
2657  *      Error   -   <0
2658  */
2659 static bool UART_readInvalidArgs(UART_Handle handle)
2661     uint8_t     buffer[4];
2662     int32_t     status;
2664     /**************************************************************************
2665      * Test: Read with invalid buffer
2666      **************************************************************************/
2667     status = UART_read(handle, NULL, 128);
2668     if (status != UART_EINVAL)
2669     {
2670         UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
2671         return false;
2672     }
2674     /**************************************************************************
2675      * Test: Read with invalid size
2676      **************************************************************************/
2677     status = UART_read(handle, &buffer[0], 0);
2678     if (status != UART_EINVAL)
2679     {
2680         UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
2681         return false;
2682     }
2684     /**************************************************************************
2685      * Test: Read Polling with invalid buffer
2686      **************************************************************************/
2687     status = UART_readPolling(handle, NULL, 128);
2688     if (status != UART_EINVAL)
2689     {
2690         UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
2691         return false;
2692     }
2694     /**************************************************************************
2695      * Test: Read Polling with invalid size
2696      **************************************************************************/
2697     status = UART_readPolling(handle, &buffer[0], 0);
2698     if (status != UART_EINVAL)
2699     {
2700         UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
2701         return false;
2702     }
2704     return true;
2707 /**
2708  *  @b Description
2709  *  @n
2710  *      The function is used to test the exported UART API.
2711  *
2712  *  @retval
2713  *      Success     -   0
2714  *  @retval
2715  *      Error       -   <0
2716  */
2717 bool UART_test_api (bool dmaMode)
2719     UART_Params     params;
2720     UART_Handle     handle;
2722     /* UART SoC init configuration */
2723     UART_initConfig(dmaMode);
2725     /* Setup the default UART Parameters */
2726     UART_Params_init(&params);
2728     /* Open the UART Instance */
2729     handle = UART_open(uartTestInstance, &params);
2730     if (handle == NULL)
2731     {
2732         UART_test_log("Error: Unable to open the UART Instance\n");
2733         return false;
2734     }
2735     /**************************************************************************
2736      * Test: Graceful shutdown
2737      **************************************************************************/
2738     UART_close(handle);
2740     /**************************************************************************
2741      * Test: Reopen the driver
2742      **************************************************************************/
2743     handle = UART_open(0, &params);
2744     if (handle == NULL)
2745     {
2746         UART_test_log("Error: Unable to open the UART Instance\n");
2747         return false;
2748     }
2750     /* Test: This will test the UART Write with Invalid arguments */
2751     if (!UART_writeInvalidArgs(handle))
2752         return false;
2754     /* Test: This will test the UART Read with Invalid arguments */
2755     if (!UART_readInvalidArgs(handle))
2756         return false;
2758     /* Close the driver: */
2759     UART_close(handle);
2760     return true;
2763 #if defined(SOC_TPR12) && defined(SIM_BUILD)
2765 /**
2766  *  @b Description
2767  *  @n
2768  *      The function is used to populate the *test* buffer with a predefined
2769  *      signature
2770  *
2771  *  @param[in]  ptrBuffer
2772  *      Buffer to be populated
2773  *  @param[in]  size
2774  *      Size of the buffer
2775  *
2776  *  @retval
2777  *      Not applicable
2778  */
2779 void UART_populateBuffer (char* ptrBuffer, uint32_t size)
2781     uint32_t index;
2782     char     ch = 'A';
2784     /* Populate the data buffer: */
2785     for (index = 0; index < size; index++)
2786     {
2787         *(ptrBuffer + index) = ch++;
2788         if (ch == ('Z'+1))
2789             ch = 'A';
2790     }
2791     return;
2794 /**
2795  *  @b Description
2796  *  @n
2797  *      The function is used to profile the UART Transmit API for
2798  *      comparison in DMA and Non-DMA mode
2799  *
2800  *  @retval
2801  *      Success -   0
2802  *  @retval
2803  *      Error   -   <0
2804  */
2805 #if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
2806 #pragma DATA_ALIGN (uartDataBuf, UART_TEST_CACHE_LINE_SIZE)
2807 char uartDataBuf[0x2000];
2808 #else
2809 char uartDataBuf[0x2000] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2810 #endif
2812 bool UART_test_profile_tx(bool dmaMode)
2814     int32_t         status;
2815     UART_Params     params;
2816     UART_Handle     handle;
2817     int32_t         testIndex;
2818     int32_t         dataSizeIndex;
2819     uint32_t        dataSize[] = { 64, 256, 1024, 4096, 8192 };
2820     uint32_t        numDataSize = sizeof(dataSize)/sizeof(uint32_t);
2821     uint32_t        baudRate =  921600;
2822     uintptr_t       ptrTxData;
2823     uint32_t        txTimeTaken;
2824     UART_Stats      stats;
2825     char            testDescription[128];
2827 #if defined(SIM_BUILD)
2828     numDataSize = 3;
2829 #endif
2831     CycleprofilerP_init();
2833     /********************************************************************************
2834      * Execute the test for all data sizes
2835      ********************************************************************************/
2836     for (dataSizeIndex = 0; dataSizeIndex < numDataSize; dataSizeIndex++)
2837     {
2838         /********************************************************************************
2839          * For each data size we will run through the following:-
2840          * - Test Index 0: Non-DMA + Blocking Mode
2841          * - Test Index 1: DMA + Blocking Mode
2842          * - Test Index 2: Non-DMA + Polling Mode
2843          * - Test Index 3: DMA + Polling Mode
2844          ********************************************************************************/
2845         for (testIndex = 0; testIndex < 4; testIndex++)
2846         {
2848 #ifdef UART_DMA_ENABLE
2849             if(testIndex & 1)
2850             {
2851                 dmaMode = true;
2852                 ptrTxData = l2_global_address((uintptr_t)uartDataBuf);
2853             }
2854             else
2855 #endif
2856             {
2857                 dmaMode = false;
2858                 ptrTxData = (uintptr_t)uartDataBuf;
2859             }
2861             /* UART SoC init configuration */
2862             UART_initConfig(dmaMode);
2864             /*******************************************************************************
2865              * Initialization:
2866              *******************************************************************************/
2867             UART_Params_init(&params);
2868             params.readDataMode   = UART_DATA_BINARY;
2869             params.writeDataMode  = UART_DATA_BINARY;
2870             params.baudRate       = baudRate;
2871             params.readEcho       = UART_ECHO_OFF;
2873             /* Open the UART Instance: */
2874             handle = UART_open(uartTestInstance, &params);
2875             if (handle == NULL)
2876             {
2877                 UART_test_log ("Error: Unable to open the UART Driver while profiling Transmit Data\n");
2878                 return false;
2879             }
2881             /******************************************************************************
2882              * Debug Message:
2883              ******************************************************************************/
2884             switch (testIndex)
2885             {
2886                 case 0:
2887                 {
2888                     sprintf (testDescription, "UART %d Profile Test in Non-DMA Blocking Mode [Data Size %d bytes]",
2889                              uartTestInstance, dataSize[dataSizeIndex]);
2890                     break;
2891                 }
2892                 case 1:
2893                 {
2894                     sprintf (testDescription, "UART %d Profile Test in DMA Blocking Mode [Data Size %d bytes]",
2895                              uartTestInstance, dataSize[dataSizeIndex]);
2896                     break;
2897                 }
2898                 case 2:
2899                 {
2900                     sprintf (testDescription, "UART %d Profile Test in Non-DMA Polling Mode [Data Size %d bytes]",
2901                              uartTestInstance, dataSize[dataSizeIndex]);
2902                     break;
2903                 }
2904                 case 3:
2905                 {
2906                     sprintf (testDescription, "UART %d Profile Test in DMA Polling Mode [Data Size %d bytes]",
2907                              uartTestInstance, dataSize[dataSizeIndex]);
2908                     break;
2909                 }
2910                 default:
2911                 {
2912                     /* Control should never come here */
2913                     OSAL_Assert (!0);
2914                     return false;
2915                 }
2916             }
2918             /* Initialize the memory to be used: */
2919             memset ((void *)uartDataBuf, 0, dataSize[dataSizeIndex]);
2921             /* Populate the transmit buffer: */
2922             UART_populateBuffer (uartDataBuf, dataSize[dataSizeIndex]);
2924             if (dmaMode)
2925             {
2926                 CacheP_wbInv((void *)(uintptr_t)uartDataBuf, (int32_t)dataSize[dataSizeIndex]);
2927             }
2929             /****************************************************************
2930              * Profile the time taken to send out the data
2931              ****************************************************************/
2932             txTimeTaken = CycleprofilerP_getTimeStamp();
2934             if ((testIndex == 0) || (testIndex == 1))
2935                 status = UART_write(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
2936             else
2937                 status = UART_writePolling(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
2939             txTimeTaken = CycleprofilerP_getTimeStamp() - txTimeTaken;
2941             /* Were we able to send out the data */
2942             if (status != dataSize[dataSizeIndex])
2943             {
2944                 UART_test_log1 ("Error: Unable to send out the data [Status %d]\n", status);
2945                 UART_close(handle);
2946                 return false;
2947             }
2949             /* Get the UART Statistics: */
2950             if (UART_control (handle, UART_CMD_GET_STATS, &stats) < 0)
2951             {
2952                 UART_close(handle);
2953                 return false;
2954             }
2956             /* Debug Message: */
2957             UART_test_log ("Debug: Transmit Measurements\n");
2958             UART_test_log1 ("Debug: Baud Rate        : %d\n", baudRate);
2959             UART_test_log1 ("Debug: Data Size        : %d\n", dataSize[dataSizeIndex]);
2960             UART_test_log1 ("Debug: Transmit         : %d ticks\n", txTimeTaken);
2961             UART_test_log1 ("Debug: Tx Interrupt     : %d\n", stats.numTxInterrupts);
2962             UART_test_log1 ("Debug: Tx DMA Interrupt : %d\n", stats.numTxDMAInterrupts);
2964             /* Close the driver: */
2965             UART_close(handle);
2966         }
2967     }
2969     /********************************************************************************************
2970      * This is just a beautification; we have mucked around with the UART Console by dumping
2971      * all the data. So here we open a console and just put a banner to make it clean
2972      ********************************************************************************************/
2973     {
2974         char* ptrTestDelimitter = "\n\r*********************************************\n\r";
2976         UART_Params_init(&params);
2977         params.readDataMode   = UART_DATA_BINARY;
2978         params.writeDataMode  = UART_DATA_BINARY;
2979         params.baudRate       = baudRate;
2980         params.readEcho       = UART_ECHO_OFF;
2982         /* Open the UART Instance: */
2983         handle = UART_open(uartTestInstance, &params);
2984         if (!handle)
2985         {
2986             UART_test_log ("Error: Unable to open the UART Driver while printing the test banner\n");
2987             return false;
2988         }
2990         /* Write the banner on the console*/
2991         UART_writePolling (handle, (uint8_t*)ptrTestDelimitter, strlen(ptrTestDelimitter));
2992         UART_writePolling (handle, (uint8_t*)ptrTestDelimitter, strlen(ptrTestDelimitter));
2994         /* Close the driver: */
2995         UART_close(handle);
2996     }
2998     return true;
3000 #endif
3002 bool UART_test_loopback_data(bool dmaMode)
3004     bool              ret = false;
3005     UART_Handle       handle = NULL;
3006     UART_Params       params;
3007     SemaphoreP_Params semParams;
3008     int32_t           status;
3009     uintptr_t         pTxBuf;
3010     uintptr_t         pRxBuf;
3011     uint32_t          i;
3013     /* Create call back semaphore for read */
3014     UART_osalSemParamsInit(&semParams);
3015     semParams.mode = SemaphoreP_Mode_BINARY;
3016     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
3018     /* enable the loopback */
3019     verifyLoopback = TRUE;
3021     /* UART SoC init configuration */
3022     UART_initConfig(dmaMode);
3024     /* Setup the read callback UART Parameters */
3025     UART_Params_init(&params);
3026     params.baudRate = 921600;
3027     params.readCallback = UART_callback;
3028     params.readMode = UART_MODE_CALLBACK;
3030     /* Open the UART Instance */
3031     handle = UART_open(uartTestInstance, &params);
3032     if (handle == NULL)
3033     {
3034         UART_test_log ("Error: Unable to open the UART Driver!\n");
3035         goto Err;
3036     }
3038     /* Reset the Rx buffer */
3039     memset(scanPrompt, 0, MAX_TEST_BUFFER_SIZE);
3041     if (dmaMode)
3042     {
3043         pTxBuf = l2_global_address((uintptr_t)fifoTrgLvlData);
3044         pRxBuf = l2_global_address((uintptr_t)scanPrompt);
3045         CacheP_wbInv((void *)(uintptr_t)scanPrompt, MAX_TEST_BUFFER_SIZE);
3046     }
3047     else
3048     {
3049         pTxBuf = (uintptr_t)fifoTrgLvlData;
3050         pRxBuf = (uintptr_t)scanPrompt;
3051     }
3053     /* RX in callback mode */
3054     status = UART_read(handle, (void *)pRxBuf, MAX_TEST_BUFFER_SIZE);
3055     if (status < 0)
3056     {
3057         UART_test_log1 ("Error: UART_read() return %d!\n", status);
3058         goto Err;
3059     }
3061     /* Send out the data */
3062     status = UART_write(handle, (void *)pTxBuf, MAX_TEST_BUFFER_SIZE);
3063     if (status < 0)
3064     {
3065         UART_test_log1 ("Error: UART_write() return %d!\n", status);
3066         goto Err;
3067     }
3069     /* Wait for RX call back */
3070     if ((status = UART_osalPendLock(callbackSem, params.writeTimeout)) != SemaphoreP_OK)
3071     {
3072         UART_test_log1 ("Error: UART_osalPendLock() return %d!\n", status);
3073         goto Err;
3074     }
3076     /* Check if read data matches with write data */
3077     for (i = 0; i < MAX_TEST_BUFFER_SIZE; i++)
3078     {
3079         if (scanPrompt[i] != fifoTrgLvlData[i])
3080         {
3081             UART_test_log3 ("Error: UART_test_loopback_data: data fails at index %d (%c != %c)\n", i, scanPrompt[i], fifoTrgLvlData[i]);
3082             goto Err;
3083         }
3084     }
3085     ret = true;
3087 Err:
3088     if (callbackSem != NULL)
3089     {
3090         UART_osalDeleteBlockingLock(callbackSem);
3091         callbackSem = NULL;
3092     }
3093     if (handle != NULL)
3094     {
3095         UART_close(handle);
3096     }
3098     verifyLoopback = FALSE;
3099     return (ret);
3102 UART_Tests Uart_tests[] =
3104 #ifdef UART_DMA_ENABLE
3105     {UART_test_read_write, true, UART_TEST_ID_DMA, "\r\n UART DMA read write test in block mode"},
3106 #endif
3107     {UART_test_read_write, false, UART_TEST_ID_INT, "\r\n UART non-DMA read write test in block mode"},
3108 #ifdef UART_DMA_ENABLE
3109     {UART_test_callback, true, UART_TEST_ID_DMA_CB, "\r\n UART DMA read write test in callback mode"},
3110 #endif
3111     {UART_test_callback, false, UART_TEST_ID_CB, "\r\n UART non-DMA read write test in callback mode"},
3112 #ifdef UART_DMA_ENABLE
3113     {UART_test_timeout, true, UART_TEST_ID_DMA_TO, "\r\n UART DMA timeout test, wait for 10 seconds to timeout read"},
3114 #endif
3115     {UART_test_timeout, false, UART_TEST_ID_TO, "\r\n UART non-DMA timeout test, wait for 10 seconds to timeout read"},
3116 #if !defined(UART_API2_NOT_SUPPORTED)
3117 #ifdef UART_DMA_ENABLE
3118     {UART_test_rx_err, true, UART_TEST_ID_DMA_RXERR, "\r\n UART DMA RX error test, enter a break"},
3119 #endif
3120     {UART_test_rx_err, false, UART_TEST_ID_RXERR, "\r\n UART non-DMA RX error test, enter a break"},
3121 #endif
3122 #ifdef UART_DMA_ENABLE
3123     {UART_test_read_write_cancel, true, UART_TEST_ID_DMA_CANCEL, "\r\n UART DMA read write cancel test, enter less than 16 chars"},
3124 #endif
3125     {UART_test_read_write_cancel, false, UART_TEST_ID_CANCEL, "\r\n UART non-DMA read write cancel test, enter less than 16 chars"},
3126 #ifdef USE_BIOS
3127 #if !defined(UART_API2_NOT_SUPPORTED)
3128 #ifdef UART_DMA_ENABLE
3129     {UART_test_simultaneous_rw, true, UART_TEST_ID_DMA_RW, "\r\n UART DMA simultaneous read write test "},
3130 #endif
3131     {UART_test_simultaneous_rw, false, UART_TEST_ID_RW, "\r\n UART non-DMA simultaneous read write test "},
3132 #endif
3133 #endif
3134 #if defined(UART_DMA_ENABLE)
3135 #if !defined(UART_NO_FIFO)
3136     {UART_test_fifo_trglvl, true, UART_TEST_ID_DMA_TRGLVL, "\r\n UART DMA TX/RX FIFO trigger level test "},
3137 #endif
3138 #endif
3139     {UART_test_printf_scanf, false, UART_TEST_ID_PRINTF, "\r\n UART stdio printf and scanf test "},
3140 #if !defined(UART_NO_FIFO)
3141     {UART_test_fifo_trglvl, false, UART_TEST_ID_TRGLVL, "\r\n UART non-DMA TX/RX FIFO trigger level test "},
3142 #endif
3143     {UART_test_polling_timeout, false, UART_TEST_ID_POLL_TO, "\r\n UART polling timeout test, wait for 10 seconds to timeout read"},
3144     {UART_test_printf_scanf_stdio_params, false, UART_TEST_ID_STDIOPARAMS, "\r\n UART stdio printf and scanf test with STDIO params(Default) "},
3145     {UART_test_read_write_int_disable, false, UART_TEST_ID_INT_DISABLE, "\r\n UART read write test with interrupt disabled"},
3146     {UART_test_read_verify, false, UART_TEST_ID_RDVERIFY, "\r\n UART non-DMA read API test in loopback mode"},
3147 #ifdef UART_DMA_ENABLE
3148 #if !defined(SOC_TPR12)
3149     {UART_test_multiple_instances, true, UART_TEST_ID_MULTI_INSTS, "\r\n UART DMA multiple instances loopback test "},
3150 #endif
3151 #endif
3152     {UART_test_api, false, UART_TEST_ID_API, "\r\n UART API Test"},
3153 #if defined(SOC_TPR12) && defined(SIM_BUILD)
3154     {UART_test_profile_tx, false, UART_TEST_ID_PROF_TX, "\r\n UART non-DMA/DMA Blocking/Polling transmit profiling"},
3155 #endif
3156 #ifdef UART_DMA_ENABLE
3157     {UART_test_loopback_data, true, UART_TEST_ID_DMA_LB_DATA, "\r\n UART DMA read write test with loopback"},
3158 #endif
3159     {UART_test_loopback_data, false, UART_TEST_ID_LB_DATA, "\r\n UART non-DMA read write test with loopback"},
3160     {NULL, }
3161 };
3163 void UART_test_print_test_desc(UART_Tests *test)
3166 #if !defined(SIM_BUILD)
3167     UART_Handle uart = NULL;
3168     UART_Params uartParams;
3169     char        testIdPrompt[16] = "\r\n UART UT ";
3170         char        crPrompt[16] = "\r\n";
3171     char        testId[16] = {0, };
3173     /* UART SoC init configuration */
3174     UART_initConfig(false);
3176     /* Initialize the default configuration params. */
3177     UART_Params_init(&uartParams);
3178     uartParams.parityType = uartParity;
3179     uart = UART_open(uartTestInstance, &uartParams);
3181     /* Print unit test ID */
3182     sprintf(testId, "%d", test->testId);
3183     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3184     UART_write(uart, (void *)(uintptr_t)testIdPrompt, sizeof(testIdPrompt));
3185     UART_write(uart, (void *)(uintptr_t)testId, sizeof(testId));
3186     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3188     /* Print test description */
3189     UART_write(uart, (void *)(uintptr_t)test->testDesc, sizeof(test->testDesc));
3190     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3192     UART_close(uart);
3193 #else
3194     printf("UART UT %d: %s\n", test->testId, test->testDesc);
3195 #endif
3198 void UART_test_print_test_result(UART_Tests *test, bool pass)
3200 #if !defined(SIM_BUILD)
3201     UART_Handle uart = NULL;
3202     UART_Params uartParams;
3203     char        testIdPrompt[16] = "\r\n UART UT ";
3204     char        crPrompt[16] = "\r\n";
3205     char        testId[16] = {0, };
3206     char        resultPass[16] = " PASSED";
3207     char        resultFail[16] = " FAILED";
3209     /* UART SoC init configuration */
3210     UART_initConfig(false);
3212     /* Initialize the default configuration params. */
3213     UART_Params_init(&uartParams);
3214     uartParams.parityType = uartParity;
3215     uart = UART_open(uartTestInstance, &uartParams);
3217     /* Print unit test ID */
3218     sprintf(testId, "%d", test->testId);
3219     UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
3220     UART_write(uart, (void *)(uintptr_t)testIdPrompt, strlen(testIdPrompt));
3221     UART_write(uart, (void *)(uintptr_t)testId, strlen(testId));
3222     if (pass == true)
3223     {
3224         UART_write(uart, (void *)(uintptr_t)resultPass, strlen(resultPass));
3225     }
3226     else
3227     {
3228         UART_write(uart, (void *)(uintptr_t)resultFail, strlen(resultFail));
3229     }
3231     UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
3233     UART_close(uart);
3234 #else
3235     printf("UART UT %d: %s\n", test->testId, pass?"PASSED":"FAILED");
3236 #endif
3239 void UART_test_print_test_results(bool pass)
3241     const char  resultPass[32] = "\r\n All tests have passed. \r\n";
3242     const char  resultFail[32] = "\r\n Some tests have failed. \r\n";
3244 #if !defined(SIM_BUILD)
3246     /* UART SoC init configuration */
3247     UART_initConfig(false);
3249     UART_stdioInit(uartTestInstance);
3251     if (pass == true)
3252     {
3253         UART_printStatus(resultPass);
3254     }
3255     else
3256     {
3257         UART_printStatus(resultFail);
3258     }
3259     UART_stdioDeInit();
3260 #else
3261     printf("%s", pass?resultPass:resultFail);
3262 #endif
3265 #ifdef USE_BIOS
3266 /*
3267  *  ======== taskFxn ========
3268  */
3269 Void taskFxn(UArg a0, UArg a1)
3270 #else
3271 int main(void)
3272 #endif /* #ifdef USE_BIOS */
3274     bool testResult = false;
3275     uint32_t i;
3277 #ifndef USE_BIOS
3278     if (Board_initUART() == false)
3279     {
3280         return(0);
3281     }
3282 #endif
3284     UART_init();
3286     for (i = 0; ; i++)
3287     {
3288         if (Uart_tests[i].testFunc == NULL)
3289         {
3290             break;
3291         }
3292         UART_test_print_test_desc(&Uart_tests[i]);
3293         testResult = Uart_tests[i].testFunc(Uart_tests[i].dmaMode);
3294         UART_test_print_test_result(&Uart_tests[i], testResult);
3296         if (testResult == false)
3297         {
3298             break;
3299         }
3301     }
3303     UART_test_print_test_results(testResult);
3305     while (1)
3306     {
3307     }
3310 #ifdef USE_BIOS
3311 /*
3312  *  ======== main ========
3313  */
3314 Int main()
3316     Task_Handle task;
3317     Error_Block eb;
3318     Task_Params taskParams;
3320         Uart_appC7xPreInit();
3322     if (Board_initUART() == false)
3323     {
3324         System_printf("\nBoard_initUART failed!\n");
3325         return(0);
3326     }
3328     Error_init(&eb);
3330     /* Initialize the task params */
3331     Task_Params_init(&taskParams);
3333     /* Set the task priority higher than the default priority (1) */
3334     taskParams.priority = 2;
3335     taskParams.stackSize = 0x6000;
3337     task = Task_create(taskFxn, &taskParams, &eb);
3338     if (task == NULL) {
3340         BIOS_exit(0);
3341     }
3342         BIOS_start();    /* does not return */
3343     return(0);
3345 #endif /* #ifdef USE_BIOS */