[PDK-9493] UART: Support FreeRTOS on R5 cores
[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 /* CSL Header files */
42 #if defined(_TMS320C6X)
43 #include <ti/csl/csl_chip.h>
44 #endif
45 #include <ti/csl/soc.h>
46 #include <ti/csl/csl_types.h>
48 /* OSAL Header files */
49 #include <ti/osal/osal.h>
51 #include <ti/osal/TaskP.h>
53 /* UART Header files */
54 #include <ti/drv/uart/UART.h>
55 #include <ti/drv/uart/UART_stdio.h>
56 #include <ti/drv/uart/src/UART_osal.h>
57 #include <ti/drv/uart/soc/UART_soc.h>
59 #include "UART_board.h"
61 #if defined(SOC_J721E) || defined(SOC_J7200)
62 #include <ti/csl/soc.h>
63 #endif
65 #if defined(SOC_J721E) || defined(SOC_AM65XX) || defined(SOC_J7200) || defined(SOC_AM64X)
66 #include <ti/drv/sciclient/sciclient.h>
67 #endif
69 #if defined(SOC_J721E) || defined(SOC_J7200)
70 #include <ti/csl/csl_clec.h>
71 #endif
73 #if defined (__C7100__)
74 #include <ti/csl/arch/csl_arch.h>
75 #endif
77 //#define CIO_DRV_CONSOLE
79 #ifdef CIO_DRV_CONSOLE
80 #define UART_test_log            printf
81 #define UART_test_log1           printf
82 #define UART_test_log2           printf
83 #define UART_test_log3           printf
84 #else
85 #define UART_test_log(x)
86 #define UART_test_log1(x,y)
87 #define UART_test_log2(x,y,z)
88 #define UART_test_log3(x,y,z,l)
89 #endif
92 #if defined(SOC_TPR12) || defined (SOC_AWR294X)
93 #if defined(SIM_BUILD)
94 #define UART_RX_LOOPBACK_ONLY
95 #endif
96 #define UART_API2_NOT_SUPPORTED
97 #define UART_NO_FIFO
98 #endif
100 void Uart_appC7xPreInit(void);
102 /* Define the UART test interface */
103 typedef struct UART_Tests_s
105     bool     (*testFunc)(bool);
106     bool     dmaMode;
107     int16_t  testId;
108     char     testDesc[80];
110 } UART_Tests;
112 /* UART test ID definitions */
113 #define UART_TEST_ID_DMA         0   /* UART DMA read write test in block mode */
114 #define UART_TEST_ID_INT         1   /* UART non-DMA read write test in block mode */
115 #define UART_TEST_ID_DMA_CB      2   /* UART DMA read write test in callback mode */
116 #define UART_TEST_ID_CB          3   /* UART non-DMA read write test in callback mode */
117 #define UART_TEST_ID_DMA_TO      4   /* UART DMA timeout test */
118 #define UART_TEST_ID_TO          5   /* UART non DMA timeout test */
119 #define UART_TEST_ID_DMA_RXERR   6   /* UART DMA RX error test */
120 #define UART_TEST_ID_RXERR       7   /* UART non-DMA RX error test */
121 #define UART_TEST_ID_DMA_CANCEL  8   /* UART DMA read write cancel test */
122 #define UART_TEST_ID_CANCEL      9   /* UART non-DMA read write cancel test */
123 #define UART_TEST_ID_DMA_RW      10  /* UART DMA simultaneous read write test */
124 #define UART_TEST_ID_RW          11  /* UART non-DMA simultaneous read write test */
125 #define UART_TEST_ID_DMA_TRGLVL  12  /* UART DMA TX/RX FIFO trigger level test */
126 #define UART_TEST_ID_PRINTF      13  /* UART stdio printf and scanf test */
127 #define UART_TEST_ID_TRGLVL      14  /* UART non-DMA TX/RX FIFO trigger level test */
128 #define UART_TEST_ID_POLL_TO     15  /* UART read write polling timeout test */
129 #define UART_TEST_ID_STDIOPARAMS 16  /* UART stdio printf and scanf test, with configurable params(Default params) */
130 #define UART_TEST_ID_INT_DISABLE 17  /* UART read write test with interrupt disabled */
131 #define UART_TEST_ID_RDVERIFY    18  /* UART non-DMA read API Test in loopback mode */
132 #define UART_TEST_ID_MULTI_INSTS 19  /* UART DMA multiple instances test in loopback mode */
133 #define UART_TEST_ID_API         20  /* UART API Test */
134 #define UART_TEST_ID_PROF_TX     21  /* UART non-DMA/DMA Blocking/Polling transmit polling */
135 #define UART_TEST_ID_DMA_LB_DATA 22  /* UART DMA data transfer test in loopback mode */
136 #define UART_TEST_ID_LB_DATA     23  /* UART non-DMA data transfer test in loopback mode */
138 /* Length of the input in number of characters */
139 #define UART_TEST_READ_LEN     (16U)
140 #define UART_RDVERIFY_READ_LEN (4U)
142 /* Timeout value of read and write */
143 #ifdef SIM_BUILD
144 #define UART_TEST_TIMEOUT      (50U)
145 #else
146 #define UART_TEST_TIMEOUT      (10000U)
147 #endif
149 /* Max number of instances to test in multiple instance test case */
150 #define UART_TEST_NUM_INSTS    (2U)
151 /* MAX Data Pattern Test Size for the Data Tests: */
152 #define MAX_TEST_BUFFER_SIZE   256
154 #if defined(CSL_CACHE_L2_LINESIZE)
155 #define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L2_LINESIZE
156 #elif defined(CSL_CACHE_L1D_LINESIZE)
157 #define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L1D_LINESIZE
158 #else
159 #define UART_TEST_CACHE_LINE_SIZE (128U)
160 #endif
162 char scanPrompt[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
163 char echoPrompt[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\n\r Data entered is as follows \r\n";
164 char dataPrint[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character \r\n";
165 char readTimeoutPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Read timed out \r\n";
166 char breakErrPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Received a break condition error \r\n";
167 char rdCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous read canceled \r\n";
168 char wrCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous write canceled \r\n";
169 char fifoTrgLvlData[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) =
170                         "0123456789112345678921234567893123456789412345678951234567896123456789712345678981234567899123456789"
171                         "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789abcedef12345"
172                         "6789ABCDEF012345678901234567899876543210deadbeef89512345";
173 char stdioPrint[64] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character and press ENTER \r\n";
175 UART_Transaction  callbackTransaction;
176 SemaphoreP_Handle callbackSem = NULL;
178 uint32_t uartTestInstance;
180 uint32_t verifyLoopback = FALSE;
182 uint32_t verifyRS485 = FALSE;
184 UART_PAR uartParity = UART_PAR_NONE;
186 /* Global Variable which holds the UART Handle */
187 UART_Handle     gUARTHandle = NULL;
189 #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
190 #ifdef UART_DMA_ENABLE
191 /*
192  * Ring parameters
193  */
194 /** \brief Number of ring entries - we can prime this much memcpy operations */
195 #define UDMA_TEST_APP_RING_ENTRIES      (1U)
196 /** \brief Size (in bytes) of each ring entry (Size of pointer - 64-bit) */
197 #define UDMA_TEST_APP_RING_ENTRY_SIZE   (sizeof(uint64_t))
198 /** \brief Total ring memory */
199 #define UDMA_TEST_APP_RING_MEM_SIZE     (UDMA_TEST_APP_RING_ENTRIES * \
200                                          UDMA_TEST_APP_RING_ENTRY_SIZE)
201 /** \brief This ensures every channel memory is aligned */
202 #define UDMA_TEST_APP_RING_MEM_SIZE_ALIGN ((UDMA_TEST_APP_RING_MEM_SIZE + UDMA_CACHELINE_ALIGNMENT) & ~(UDMA_CACHELINE_ALIGNMENT - 1U))
204 /**
205  *  \brief UDMA host mode buffer descriptor memory size.
206  *  Make it multiple of UART_TEST_CACHE_LINE_SIZE alignment
207  */
208 /** \brief UDMA host mode buffer descriptor memory size. */
209 #define UDMA_TEST_APP_DESC_SIZE         (sizeof(CSL_UdmapCppi5HMPD))
210 /** \brief This ensures every channel memory is aligned */
211 #define UDMA_TEST_APP_DESC_SIZE_ALIGN   ((UDMA_TEST_APP_DESC_SIZE + UDMA_CACHELINE_ALIGNMENT) & ~(UDMA_CACHELINE_ALIGNMENT - 1U))
213 /*
214  * UDMA driver objects
215  */
216 struct Udma_DrvObj      gUdmaDrvObj;
217 struct Udma_ChObj       gUdmaTxChObj;
218 struct Udma_ChObj       gUdmaRxChObj;
219 struct Udma_EventObj    gUdmaTxCqEventObj;
220 struct Udma_EventObj    gUdmaRxCqEventObj;
222 Udma_DrvHandle          gDrvHandle = NULL;
223 /*
224  * UDMA Memories
225  */
226 static uint8_t gTxRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
227 static uint8_t gTxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
228 static uint8_t gTdTxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
229 static uint8_t gUdmaTxHpdMem[UDMA_TEST_APP_DESC_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
230 static uint8_t gRxRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
231 static uint8_t gRxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
232 static uint8_t gTdRxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
233 static uint8_t gUdmaRxHpdMem[UDMA_TEST_APP_DESC_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
234 static UART_dmaInfo gUdmaInfo;
236 Udma_DrvHandle UartApp_udmaInit(UART_HwAttrs *cfg)
238     int32_t         retVal = UDMA_SOK;
239     Udma_InitPrms   initPrms;
240     uint32_t        instId;
242     if (gDrvHandle == NULL)
243     {
244         /* UDMA driver init */
245 #if defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM65XX)
246 #if defined (BUILD_MCU1_0) || defined (BUILD_MCU1_1)
247         instId = UDMA_INST_ID_MCU_0;
248 #else
249         instId = UDMA_INST_ID_MAIN_0;
250 #endif
251 #endif
253 #if defined(SOC_AM64X)
254         instId = UDMA_INST_ID_PKTDMA_0;
255 #endif
257         UdmaInitPrms_init(instId, &initPrms);
259         retVal = Udma_init(&gUdmaDrvObj, &initPrms);
260         if(UDMA_SOK == retVal)
261         {
262             gDrvHandle = &gUdmaDrvObj;
263         }
264     }
266     if(gDrvHandle != NULL)
267     {
268         gDrvHandle = &gUdmaDrvObj;
270         gUdmaInfo.txChHandle     = (void *)&gUdmaTxChObj;
271         gUdmaInfo.rxChHandle     = (void *)&gUdmaRxChObj;
272         gUdmaInfo.txRingMem      = (void *)&gTxRingMem[0];
273         gUdmaInfo.cqTxRingMem    = (void *)&gTxCompRingMem[0];
274         gUdmaInfo.tdCqTxRingMem  = (void *)&gTdTxCompRingMem[0];
275         gUdmaInfo.rxRingMem      = (void *)&gRxRingMem[0];
276         gUdmaInfo.cqRxRingMem    = (void *)&gRxCompRingMem[0];
277         gUdmaInfo.tdCqRxRingMem  = (void *)&gTdRxCompRingMem[0];
278         gUdmaInfo.txHpdMem       = (void *)&gUdmaTxHpdMem[0];
279         gUdmaInfo.rxHpdMem       = (void *)&gUdmaRxHpdMem[0];
280         gUdmaInfo.txEventHandle  = (void *)&gUdmaTxCqEventObj;
281         gUdmaInfo.rxEventHandle  = (void *)&gUdmaRxCqEventObj;
282         cfg->dmaInfo             = &gUdmaInfo;
283     }
285     return (gDrvHandle);
288 int32_t UART_udma_deinit(void)
290     int32_t         retVal = UDMA_SOK;
292     if (gDrvHandle != NULL)
293     {
294         retVal = Udma_deinit(gDrvHandle);
295         if(UDMA_SOK == retVal)
296         {
297             gDrvHandle = NULL;
298         }
299     }
301     return (retVal);
303 #endif
304 #endif /* #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X) */
306 #if defined(SOC_AM64X) && defined(BUILD_MCU)
307 int32_t UART_configClk(uint32_t freq)
309     int32_t retVal = CSL_PASS;
310     uint64_t uartClk;
311     uint32_t parentID;
312     uint32_t clkID[] = {
313                            TISCI_DEV_UART0_FCLK_CLK,
314                            TISCI_DEV_UART1_FCLK_CLK,
315                            TISCI_DEV_UART2_FCLK_CLK,
316                            TISCI_DEV_UART3_FCLK_CLK,
317                            TISCI_DEV_UART4_FCLK_CLK,
318                            TISCI_DEV_UART5_FCLK_CLK,
319                            TISCI_DEV_UART6_FCLK_CLK,
320                        };
321     uint32_t modID[] = {
322                            TISCI_DEV_UART0,
323                            TISCI_DEV_UART1,
324                            TISCI_DEV_UART2,
325                            TISCI_DEV_UART3,
326                            TISCI_DEV_UART4,
327                            TISCI_DEV_UART5,
328                            TISCI_DEV_UART6,
329                        };
331     retVal = Sciclient_pmModuleClkRequest(modID[uartTestInstance],
332                                           clkID[uartTestInstance],
333                                           TISCI_MSG_VALUE_CLOCK_SW_STATE_REQ,
334                                           TISCI_MSG_FLAG_AOP,SCICLIENT_SERVICE_WAIT_FOREVER);
335     if (retVal == CSL_PASS)
336     {
337         if (freq == UART_MODULE_CLK_48M)
338         {
339             parentID = TISCI_DEV_UART0_FCLK_CLK_PARENT_USART_PROGRAMMABLE_CLOCK_DIVIDER_OUT0;
340         }
341         else
342         {
343             parentID = TISCI_DEV_UART0_FCLK_CLK_PARENT_HSDIV4_16FFT_MAIN_1_HSDIVOUT1_CLK;
344         }
345         retVal = Sciclient_pmSetModuleClkParent(modID[uartTestInstance],
346                                                 clkID[uartTestInstance],
347                                                 parentID,
348                                                 SCICLIENT_SERVICE_WAIT_FOREVER);
349     }
351     if (retVal == CSL_PASS)
352     {
353         uartClk = (uint64_t)freq;
354         retVal = Sciclient_pmSetModuleClkFreq(modID[uartTestInstance],
355                                               clkID[uartTestInstance],
356                                               uartClk,
357                                               TISCI_MSG_FLAG_AOP,
358                                               SCICLIENT_SERVICE_WAIT_FOREVER);
359     }
361     if (retVal == CSL_PASS)
362     {
363         uartClk = 0;
364         retVal = Sciclient_pmGetModuleClkFreq(modID[BOARD_OSPI_NOR_INSTANCE],
365                                               clkID[BOARD_OSPI_NOR_INSTANCE],
366                                               &uartClk,
367                                               SCICLIENT_SERVICE_WAIT_FOREVER);
368     }
370     if (retVal == CSL_PASS)
371     {
372         if ((uint32_t)uartClk != freq)
373         {
374             retVal = CSL_EFAIL;
375         }
376     }
378     return (retVal);
380 #endif
381 /*
382  *  ======== UART init config ========
383  */
384 static void UART_initConfig(bool dmaMode)
386     UART_HwAttrs uart_cfg;
388     /* Get the default UART init configurations */
389     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
391 #ifdef UART_DMA_ENABLE
392     if (dmaMode == true)
393     {
394 #if defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
395         uart_cfg.edmaHandle = UartApp_udmaInit(&uart_cfg);
396 #else
397         uart_cfg.edmaHandle = UartApp_edmaInit();
398     #if defined(SOC_TPR12) || defined (SOC_AWR294X)
399         uart_cfg.paramSetId = EDMA_NUM_DMA_CHANNELS;
400     #endif
401 #endif
402         uart_cfg.dmaMode    = TRUE;
403     }
404     else
405 #endif
406     {
407         uart_cfg.edmaHandle = NULL;
408         uart_cfg.dmaMode    = FALSE;
409     }
411     uart_cfg.loopback   = verifyLoopback;
412 #if defined(SOC_AM64X) && defined(BUILD_MCU)
413     if (verifyRS485 == TRUE)
414     {
415         uart_cfg.frequency = UART_MODULE_CLK_160M;
416     }
417     else
418     {
419         uart_cfg.frequency = UART_MODULE_CLK_48M;
420     }
421     uart_cfg.dirEnable = verifyRS485;
422     UART_configClk(uart_cfg.frequency);
423 #endif
425     /* Set the DMA enabled UART init configurations */
426     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
429 void UART_getTestInstNum(uint32_t *instNum, bool *boardAM570x)
431 #if defined (idkAM571x)
432     Board_STATUS  boardStatus;
433     Board_IDInfo  id;
434 #endif
436     *instNum = UART_INSTANCE;
437     *boardAM570x = false;
439 #if defined (idkAM571x)
440     boardStatus = Board_getIDInfo(&id);
441     if (boardStatus != BOARD_SOK)
442     {
443         return;
444     }
446     /* Check if is DRA (AM570x) SoC */
447     if ((id.boardName[0] == 'D') &&
448         (id.boardName[1] == 'R') &&
449         (id.boardName[2] == 'A'))
450     {
451         *boardAM570x = true;
452         *instNum = 0;
453     }
454 #endif
457 bool Board_initUART(void)
459     Board_initCfg boardCfg;
460     Board_STATUS  boardStatus;
461     bool          boardAM570x;
463 #if defined(evmK2E) || defined(evmC6678)
464     boardCfg = BOARD_INIT_MODULE_CLOCK;
465 #else
466     boardCfg = BOARD_INIT_PINMUX_CONFIG |
467         BOARD_INIT_MODULE_CLOCK;
468 #endif
470     boardStatus = Board_init(boardCfg);
471     if (boardStatus != BOARD_SOK)
472     {
473         return (false);
474     }
476     UART_getTestInstNum(&uartTestInstance, &boardAM570x);
478 /* --- TODO: move this into the board library --- */
479 /* For SYSBIOS only */
480 #ifndef BAREMETAL
481 #if defined (SOC_J721E)
482 /* set up C7x CLEC for DMTimer0 */
483 #if defined (BUILD_C7X_1)
484     CSL_ClecEventConfig   cfgClec;
485     CSL_CLEC_EVTRegs     *clecBaseAddr = (CSL_CLEC_EVTRegs *)CSL_COMPUTE_CLUSTER0_CLEC_REGS_BASE;
486     uint32_t input         = CSLR_COMPUTE_CLUSTER0_GIC500SS_SPI_TIMER0_INTR_PEND_0 + 992; /* Used for Timer Interrupt */
488     /* Configure CLEC for DMTimer0, SYS/BIOS uses interrupt 14 for DMTimer0 by default */
489     cfgClec.secureClaimEnable = FALSE;
490     cfgClec.evtSendEnable     = TRUE;
491     cfgClec.rtMap             = CSL_CLEC_RTMAP_CPU_ALL;
492     cfgClec.extEvtNum         = 0;
493     cfgClec.c7xEvtNum         = 14;
494     CSL_clecConfigEvent(clecBaseAddr, input, &cfgClec);
495 #endif /* for C7X cores */
497 /* set up C66x Interrupt Router for DMTimer0 for C66x */
498 #if defined (BUILD_DSP_1) || defined (BUILD_DSP_2)
499     int32_t                               retVal;
500     struct tisci_msg_rm_irq_set_req      rmIrqReq;
501     struct tisci_msg_rm_irq_set_resp     rmIrqResp;
502     int32_t                              dst_id;
504 #if defined (BUILD_DSP_1)
505     dst_id = TISCI_DEV_C66SS0_CORE0;
506 #endif
507 #if defined (BUILD_DSP_2)
508     dst_id = TISCI_DEV_C66SS1_CORE0;
509 #endif
511     /* Set up C66x interrupt router for DMTimer0 */
512     memset (&rmIrqReq, 0, sizeof(rmIrqReq));
513     rmIrqReq.secondary_host = TISCI_MSG_VALUE_RM_UNUSED_SECONDARY_HOST;
514     rmIrqReq.src_id = TISCI_DEV_TIMER0;
515     rmIrqReq.src_index = 0; /* set to 0 for non-event based interrupt */
517     /* Set the destination interrupt */
518     rmIrqReq.valid_params |= TISCI_MSG_VALUE_RM_DST_ID_VALID;
519     rmIrqReq.valid_params |= TISCI_MSG_VALUE_RM_DST_HOST_IRQ_VALID;
521     /* Set the destination based on the core */
522     rmIrqReq.dst_id       = dst_id;
523 /* rmIrqReq.dst_host_irq has to match the DMTimer.timerSettings[0].eventId defined in sysbios_c66.cfg */
524 #if defined (BUILD_DSP_1)
525     rmIrqReq.dst_host_irq = 21; /* DMSC dest event, input to C66x INTC  */
526 #endif
527 #if defined (BUILD_DSP_2)
528     rmIrqReq.dst_host_irq = 20; /* DMSC dest event, input to C66x INTC  */
529 #endif
531     /* Config event */
532     retVal = Sciclient_rmIrqSet(
533                 (const struct tisci_msg_rm_irq_set_req *)&rmIrqReq,
534                 &rmIrqResp,
535                 SCICLIENT_SERVICE_WAIT_FOREVER);
536     if(0U != retVal)
537     {
538        return (false);
539     }
540 #endif /* for C66X cores */
541 #endif /* for SOC_J721E || SOC_J7200 */
542 #endif /* for SYSBIOS */
543 /* --- TODO: move this into the board library --- */
545 #if defined (SOC_AM572x) || defined (SOC_AM571x) || defined (SOC_AM574x)
546     CSL_l4per_cm_core_componentRegs *l4PerCmReg =
547         (CSL_l4per_cm_core_componentRegs *) CSL_MPU_L4PER_CM_CORE_REGS;
549     if (boardAM570x)
550     {
551 #if defined (_TMS320C6X)
552         UART_HwAttrs cfg;
554         /*
555          * AM5 DSP does not have a default Xbar connection for UART
556          * interrupt, need the following Xbar interrupt configuration
557          */
559         /* Use reserved DSP1_IRQ_34 */
560         CSL_xbarDspIrqConfigure(1,
561                                 CSL_XBAR_INST_DSP1_IRQ_34,
562                                 CSL_XBAR_UART1_IRQ);
564         /* configure Xbar for UART2 instance */
565         CSL_xbarDspIrqConfigure(1,
566                                 CSL_XBAR_INST_DSP1_IRQ_35,
567                                 CSL_XBAR_UART2_IRQ);
568         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
569         cfg.eventId = 35;
570         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
571 #endif
573 #if defined(__TI_ARM_V7M4__)
574         UART_HwAttrs cfg;
576         /*
577          * AM571/AM570 IPU does not have a default Xbar connection for UART 1
578          * interrupt, need to use a reserved IRQ Xbar instance for Xbar interrupt
579          * configuration
580          */
582         /* Use reserved XBAR_INST_IPU1_IRQ_24 */
583         CSL_xbarIpuIrqConfigure(1,
584                                 CSL_XBAR_INST_IPU1_IRQ_24,
585                                 CSL_XBAR_UART1_IRQ);
587         /* configure Xbar for UART2 instance */
588         CSL_xbarIpuIrqConfigure(1,
589                                 CSL_XBAR_INST_IPU1_IRQ_25,
590                                 CSL_XBAR_UART2_IRQ);
591         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
592         cfg.intNum = 25;
593         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
594 #endif
596         /* enable UART2 clock */
597         CSL_FINST(l4PerCmReg->CM_L4PER_UART2_CLKCTRL_REG,
598                   L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_MODULEMODE,
599                   ENABLE);
601         while(CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_IDLEST_FUNC !=
602               CSL_FEXT(l4PerCmReg->CM_L4PER_UART2_CLKCTRL_REG,
603               L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_IDLEST));
604     }
605     else
606     {
607 #if defined (_TMS320C6X)
608         UART_HwAttrs cfg;
610         CSL_xbarDspIrqConfigure(1,
611                                 CSL_XBAR_INST_DSP1_IRQ_34,
612                                 CSL_XBAR_UART3_IRQ);
614         /* configure Xbar for UART4 instance */
615         CSL_xbarDspIrqConfigure(1,
616                                 CSL_XBAR_INST_DSP1_IRQ_35,
617                                 CSL_XBAR_UART4_IRQ);
618         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
619         cfg.eventId = 35;
620         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
621 #endif
623 #if defined(__TI_ARM_V7M4__)
624         /*
625          * AM57x IPU does not have a default Xbar connection for UART 4
626          * interrupt, need to use a reserved IRQ Xbar instance for Xbar interrupt
627          * configuration
628          */
629         /* Use reserved XBAR_INST_IPU1_IRQ_24 */
630         CSL_xbarIpuIrqConfigure(1,
631                                 CSL_XBAR_INST_IPU1_IRQ_24,
632                                 CSL_XBAR_UART4_IRQ);
633 #endif
635         /* enable UART4 clock */
636         CSL_FINST(l4PerCmReg->CM_L4PER_UART4_CLKCTRL_REG,
637                   L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_MODULEMODE,
638                   ENABLE);
640         while(CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_IDLEST_FUNC !=
641               CSL_FEXT(l4PerCmReg->CM_L4PER_UART4_CLKCTRL_REG,
642               L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_IDLEST));
643     }
644 #endif
646 #if defined (SOC_AM335X) || defined (SOC_AM437X)
647     /* enable UART clock */
648     PRCMModuleEnable(42U, uartTestInstance + 1U, 0U);
649 #endif
650     return (true);
653 /**
654  *  @b Description
655  *  @n
656  *      Utility function which converts a local GEM L2 memory address
657  *      to global memory address.
658  *
659  *  @param[in]  addr
660  *      Local address to be converted
661  *
662  *  @retval
663  *      Computed L2 global Address
664  */
665 static uintptr_t l2_global_address (uintptr_t addr)
667 #if defined(SOC_K2H) || defined(SOC_K2K) || defined(SOC_K2L) || defined(SOC_K2E) || defined(SOC_K2G) || defined(SOC_C6678) || defined(SOC_C6657) || \
668     defined(DEVICE_K2H) || defined(DEVICE_K2K) || defined(DEVICE_K2L) || defined(DEVICE_K2E) || defined(DEVICE_K2G) || defined(DEVICE_C6678) || defined(DEVICE_C6657)
669 #ifdef _TMS320C6X
670     uint32_t corenum;
672     /* Get the core number. */
673     corenum = CSL_chipReadReg (CSL_CHIP_DNUM);
675     /* Compute the global address. */
676     return (addr + (0x10000000 + (corenum * 0x1000000)));
677 #else
678     return addr;
679 #endif
680 #elif defined (SOC_TPR12) || defined (SOC_AWR294X)
681     return ((uintptr_t)CSL_locToGlobAddr(addr));
682 #else
683     return addr;
684 #endif
688 void UART_callback(UART_Handle handle, void *buf, size_t count)
690     UART_osalPostLock(callbackSem);
693 void UART_callback2(UART_Handle handle, UART_Transaction *transaction)
695     UART_osalPostLock(callbackSem);
698 #if !(defined(SOC_TPR12) || defined (SOC_AWR294X))
700 #define UART_NUM_TRIG_LVL           (4U)
702 /*
703  *  ======== UART_initConfigTrgLvl ========
704  */
705 static void UART_initConfigTrgLvl(uint32_t dmaMode,
706                                   uint32_t txTrigLvl,
707                                   uint32_t rxTrigLvl)
709     UART_HwAttrs uart_cfg;
711     /* Get the default UART init configurations */
712     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
714 #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) ||\
715     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)
716     uart_cfg.txTrigLvl  = txTrigLvl;
717 #else
718     uart_cfg.txTrigLvl  = (UART_TxTrigLvl)txTrigLvl;
719 #endif
720     uart_cfg.rxTrigLvl  = (UART_RxTrigLvl)rxTrigLvl;
721     uart_cfg.loopback   = TRUE;
722 #ifdef UART_DMA_ENABLE
723     if (dmaMode == true)
724     {
725 #if defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
726         uart_cfg.edmaHandle = UartApp_udmaInit(&uart_cfg);
727 #else
728         uart_cfg.edmaHandle = UartApp_edmaInit();
729 #endif
730         uart_cfg.dmaMode    = TRUE;
731     }
732     else
733 #endif
734     {
735         uart_cfg.edmaHandle = NULL;
736         uart_cfg.dmaMode    = FALSE;
737     }
739     /* Set the TX/RX FIFO trigger levels */
740     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
743 bool UART_test_trglvl_xfer(UART_Handle uart, uint32_t dmaMode, uint32_t xferSize)
745     SemaphoreP_Params semParams;
746     UART_Transaction  transaction;
747     uintptr_t          addrFifoTrgLvlData, addrScanPrompt;
748     uint32_t          i;
749     bool              ret = false;
751     if (xferSize == 0)
752     {
753         return true;
754     }
755     /* Create call back semaphore */
756     UART_osalSemParamsInit(&semParams);
757     semParams.mode = SemaphoreP_Mode_BINARY;
758     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
760     if (dmaMode)
761     {
762         addrFifoTrgLvlData = l2_global_address((uintptr_t)fifoTrgLvlData);
763         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
764     }
765     else
766     {
767         addrFifoTrgLvlData = (uintptr_t)fifoTrgLvlData;
768         addrScanPrompt = (uintptr_t)scanPrompt;
769     }
771     /* Read in call back mode */
772     memset(scanPrompt, 0, sizeof(scanPrompt));
773     if (dmaMode)
774     {
775         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
776     }
778     UART_transactionInit(&callbackTransaction);
779     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
780     callbackTransaction.count = xferSize;
781     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
782     {
783         goto Err;
784     }
786     /* Write in blocking mode */
787     UART_transactionInit(&transaction);
788     transaction.buf = (void *)(uintptr_t)addrFifoTrgLvlData;
789     transaction.count = xferSize;
790     if (UART_write2(uart, &transaction) == UART_ERROR)
791     {
792         goto Err;
793     }
795     /* Wait for read callback */
796     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
797     {
798         goto Err;
799     }
801     /* Check if read data matches with write data */
802     for (i = 0; i < xferSize; i++)
803     {
804         if (scanPrompt[i] != fifoTrgLvlData[i])
805         {
806             goto Err;
807         }
808     }
809     ret = true;
811 Err:
812     if (callbackSem)
813     {
814             UART_osalDeleteBlockingLock(callbackSem);
815             callbackSem = NULL;
816     }
817     return (ret);
820 bool UART_test_trglvl(uint32_t dmaMode,
821                       int32_t txTrigLvl,
822                       int32_t rxTrigLvl)
824     UART_Handle       uart = NULL;
825     UART_Params       uartParams;
826     bool              ret = false;
827     int32_t           i;
829     /* UART SoC init configuration */
830     UART_initConfigTrgLvl(dmaMode, (uint32_t)(uintptr_t)txTrigLvl, (uint32_t)(uintptr_t)rxTrigLvl);
832     /* Read in callback mode and write in blocking mode */
833     UART_Params_init(&uartParams);
834     uartParams.readCallback = UART_callback;
835     uartParams.readMode = UART_MODE_CALLBACK;
836     uartParams.parityType = uartParity;
838     for ( i = -1; i < 2; i++)
839     {
840         uart = UART_open(uartTestInstance, &uartParams);
841         if (uart == NULL)
842         {
843             goto Err;
844         }
845         if (UART_test_trglvl_xfer(uart, dmaMode, (uint32_t)(uintptr_t)(txTrigLvl + i)) == false)
846         {
847             goto Err;
848         }
849         if (uart)
850         {
851             UART_close(uart);
852             uart = NULL;
853         }
855         uart = UART_open(uartTestInstance, &uartParams);
856         if (uart == NULL)
857         {
858             goto Err;
859         }
861         if (UART_test_trglvl_xfer(uart, dmaMode, (uint32_t)(uintptr_t)(rxTrigLvl + i)) == false)
862         {
863             goto Err;
864         }
866         if (uart)
867         {
868             UART_close(uart);
869             uart = NULL;
870         }
871     }
873     ret = true;
875 Err:
876     if (uart)
877     {
878         UART_close(uart);
879     }
880     return (ret);
883 /*
884  *  ======== UART DMA TX/RX FIFO trigger level test ========
885  */
886 static bool UART_test_fifo_trglvl(bool dmaMode)
888     bool     ret = true;
889     uint32_t i;
890 #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)
891     UART_TxTrigLvl txTrgLvl[UART_NUM_TRIG_LVL] =
892     {
893         UART_TXTRIGLVL_8,
894         UART_TXTRIGLVL_16,
895         UART_TXTRIGLVL_32,
896         UART_TXTRIGLVL_56
897     };
899     UART_RxTrigLvl rxTrgLvl[UART_NUM_TRIG_LVL] =
900     {
901         UART_RXTRIGLVL_8,
902         UART_RXTRIGLVL_16,
903         UART_RXTRIGLVL_56,
904         UART_RXTRIGLVL_60
905     };
906 #else
907     uint32_t txTrgLvl[UART_NUM_TRIG_LVL] =
908     {
909         2,
910         4,
911         8,
912         16
913     };
915     UART_RxTrigLvl rxTrgLvl[UART_NUM_TRIG_LVL] =
916     {
917         UART_RXTRIGLVL_1,
918         UART_RXTRIGLVL_4,
919         UART_RXTRIGLVL_8,
920         UART_RXTRIGLVL_14
921     };
922 #endif
923     for (i = 0; i < UART_NUM_TRIG_LVL; i++)
924     {
925         if (UART_test_trglvl(dmaMode, (int32_t)txTrgLvl[i], (int32_t)rxTrgLvl[i]) == false)
926         {
927             ret = false;
928             break;
929         }
930     }
932     return (ret);
935 #endif /* TPR12: no UART fifo */
936 /*
937  *  ======== UART stdio printf/scanf test ========
938  *
939  *  The test function tests stdio driver printf/scanf APIs
940  */
941 static bool UART_test_printf_scanf(bool dmaMode)
943     bool    ret = false;
945     if (uartParity == UART_PAR_NONE)
946     {
947         /* UART SoC init configuration */
948         UART_initConfig(dmaMode);
950         UART_stdioInit(uartTestInstance);
952         UART_printf(stdioPrint);
954 #ifndef UART_RX_LOOPBACK_ONLY
955         memset(scanPrompt, 0, sizeof(scanPrompt));
956         if (UART_scanFmt(scanPrompt) != S_PASS)
957         {
958             goto Err;
959         }
960         ret = true;
962 Err:
963 #else
964         ret = true;
965 #endif
966         UART_stdioDeInit();
967     }
968     else
969     {
970         /*
971          * bypass this test if the parity is not the default setting
972          * (UART_PAR_NONE), since UART_stdioInit() only allows default
973          * UART parameter settings.
974          */
975         ret = true;
976     }
978     return (ret);
981 /*
982  *  ======== UART stdio printf/scanf test with param config (default) ========
983  *
984  *  The test function tests stdio driver printf/scanf APIs with default params config.
985  */
986 static bool UART_test_printf_scanf_stdio_params(bool dmaMode)
988     bool    ret = false;
989     UART_Params params;
991     /* UART SoC init configuration */
992     UART_initConfig(dmaMode);
994     /* UART params */
995     UART_Params_init(&params);
996     params.parityType = uartParity;
998     UART_stdioInit2(uartTestInstance,&params);
1000     UART_printf(stdioPrint);
1002     memset(scanPrompt, 0, sizeof(scanPrompt));
1003 #ifndef UART_RX_LOOPBACK_ONLY
1004     if (UART_scanFmt(scanPrompt) != S_PASS)
1005     {
1006         goto Err;
1007     }
1008     ret = true;
1010 Err:
1011 #else
1012     ret = true;
1013 #endif
1014     UART_stdioDeInit();
1015     return (ret);
1018 #if !defined(UART_API2_NOT_SUPPORTED)
1019 #if defined (USE_BIOS) || defined (FREERTOS)
1020 #if defined (__C7100__)
1021 #define APP_TSK_STACK_WRITE              (16U * 1024U)
1022 #else
1023 #define APP_TSK_STACK_WRITE              (8U * 1024U)
1024 #endif /* #if defined (__C7100__) */
1025 static uint8_t  gAppTskStackWrite[APP_TSK_STACK_WRITE] __attribute__((aligned(32)));
1026 /* Use a global variable to sync the read task and the write task */
1027 volatile bool taskSyncFlag;
1028 void UART_simultaneous_rw_write(void *a0, void *a1)
1030         UART_Handle      uart = (UART_Handle)a0;
1031         bool             dmaMode = (bool)a1;
1032     uintptr_t         addrDataPrint;
1033     UART_Transaction transaction;
1035         if (dmaMode)
1036     {
1037         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1038     }
1039     else
1040     {
1041         addrDataPrint = (uintptr_t)dataPrint;
1042     }
1044     UART_transactionInit(&transaction);
1046     while (taskSyncFlag == true)
1047         {
1048         transaction.buf = (void *)(uintptr_t)addrDataPrint;
1049             transaction.count = strlen(dataPrint);
1050             UART_write2(uart, &transaction);
1051             Osal_delay(100);
1052         }
1054     /* resume the read test task */
1055     taskSyncFlag = true;
1058 /*
1059  *  ======== UART simultaneous read/write test ========
1060  *
1061  *  The read task creates a write task which will continuously
1062  *  writes the data out to the console, while at the same time
1063  *  the read task reads the data from the console input.
1064  *
1065  *  Note:
1066  *  In blocking/interrupt mode, if the write size is less than
1067  *  the TX FIFO size (64 bytes), the driver will just copy
1068  *  the write data to the TX FIFO and will not use interrupt
1069  *  and write semaphore. The read task should have a higher
1070  *  priority than the write task to resume the task by the
1071  *  scheduler once it gets the read semaphore.
1072  *
1073  */
1074 static bool UART_test_simultaneous_rw(bool dmaMode)
1076     UART_Handle      uart = NULL;
1077     UART_Params      uartParams;
1078     uintptr_t         addrScanPrompt, addrEchoPrompt;
1079     UART_Transaction transaction;
1080     TaskP_Handle      writeTask;
1081     TaskP_Params      writeTaskParams;
1082     bool              ret = false;
1084     /* UART SoC init configuration */
1085     UART_initConfig(dmaMode);
1087     /* Initialize the default configuration params. */
1088     UART_Params_init(&uartParams);
1089     uartParams.parityType = uartParity;
1091     uart = UART_open(uartTestInstance, &uartParams);
1092     if (uart == NULL)
1093     {
1094         goto Err;
1095     }
1097     /* run the write teas when task is created */
1098     taskSyncFlag = true;
1100     /* Initialize the task params */
1101     TaskP_Params_init(&writeTaskParams);
1102     writeTaskParams.arg0 = (void *)uart;
1103     writeTaskParams.arg1 = (void *)dmaMode;
1104     writeTaskParams.stack = gAppTskStackWrite;
1105     writeTaskParams.stacksize = sizeof (gAppTskStackWrite);
1106     /*
1107      * Set the write task priority to the default priority (1)
1108      * lower than the read task priority (2)
1109      */
1110     writeTaskParams.priority = 1;
1112     /* Create the UART write task */
1113     writeTask = TaskP_create(UART_simultaneous_rw_write, &writeTaskParams);
1114     if (writeTask == NULL)
1115     {
1116         goto Err;
1117     }
1119     if (dmaMode)
1120     {
1121         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1122         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1123     }
1124     else
1125     {
1126         addrScanPrompt = (uintptr_t)scanPrompt;
1127         addrEchoPrompt = (uintptr_t)echoPrompt;
1128     }
1130     memset(scanPrompt, 0, sizeof(scanPrompt));
1131     if (dmaMode)
1132     {
1133         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1134     }
1135     UART_transactionInit(&transaction);
1136     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1137     transaction.count = UART_TEST_READ_LEN;
1138     if (UART_read2(uart, &transaction) == UART_ERROR)
1139     {
1140         taskSyncFlag = false;
1141         goto Err;
1142     }
1143     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
1144         (transaction.count != UART_TEST_READ_LEN))
1145     {
1146         taskSyncFlag = false;
1147         goto Err;
1148     }
1150     /* stop the write test task */
1151     taskSyncFlag = false;
1153     /* Wait for the write task complete and exit */
1154     while (taskSyncFlag == false)
1155     {
1156         Osal_delay(100);
1157     }
1158     taskSyncFlag = false;
1159     /* Delete write task */
1160     TaskP_delete(writeTask);
1162     UART_transactionInit(&transaction);
1163     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1164     transaction.count = strlen(echoPrompt);
1165     if (UART_write2(uart, &transaction) == UART_ERROR)
1166     {
1167         goto Err;
1168     }
1170     UART_transactionInit(&transaction);
1171     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1172     transaction.count = UART_TEST_READ_LEN;
1173     if (UART_write2(uart, &transaction) == UART_ERROR)
1174     {
1175         goto Err;
1176     }
1178     Osal_delay(5000);
1180     ret = true;
1182 Err:
1183     if (uart)
1184     {
1185         UART_close(uart);
1186     }
1188     return (ret);
1190 #endif /* #if defined (USE_BIOS) || defined (FREERTOS) */
1191 #endif /* #if !defined(UART_API2_NOT_SUPPORTED) */
1193 /*
1194  *  ======== UART read cancel test ========
1195  *
1196  *  The test function uses console intput to simulate/test the
1197  *  read cancel in callback mode. In a real use case, user can
1198  *  read a large file from the console and cancel the read before
1199  *  the read is complete.
1200  *
1201  */
1202 static bool UART_test_read_write_cancel(bool dmaMode)
1204     UART_Handle       uart = NULL;
1205     UART_Params       uartParams;
1206     SemaphoreP_Params semParams;
1207     UART_Transaction  transaction;
1208     uintptr_t          addrRdCancelPrompt, addrWrCancelPrompt;
1209     uintptr_t          addrDataPrint, addrEchoPrompt, addrScanPrompt;
1210     bool              ret = false;
1212     /* Create call back semaphore */
1213     UART_osalSemParamsInit(&semParams);
1214     semParams.mode = SemaphoreP_Mode_BINARY;
1215     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
1217     /* UART SoC init configuration */
1218     UART_initConfig(dmaMode);
1220     /* Set callback mode for read */
1221     UART_Params_init(&uartParams);
1222     uartParams.readCallback = UART_callback;
1223     uartParams.readMode = UART_MODE_CALLBACK;
1224     uartParams.parityType = uartParity;
1226     if (dmaMode)
1227     {
1228         addrRdCancelPrompt = l2_global_address((uintptr_t)rdCancelPrompt);
1229         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1230         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1231         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1232     }
1233     else
1234     {
1235         addrRdCancelPrompt = (uintptr_t)rdCancelPrompt;
1236         addrDataPrint = (uintptr_t)dataPrint;
1237         addrEchoPrompt = (uintptr_t)echoPrompt;
1238         addrScanPrompt = (uintptr_t)scanPrompt;
1239     }
1241     uart = UART_open(uartTestInstance, &uartParams);
1242     if (uart == NULL)
1243     {
1244         goto Err;
1245     }
1247     /* Test receive error */
1249     /* Perform the first read, which will be cancelled before completion */
1250     memset(scanPrompt, 0, sizeof(scanPrompt));
1251     if (dmaMode)
1252     {
1253         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1254     }
1256     UART_transactionInit(&callbackTransaction);
1257     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1258     callbackTransaction.count = UART_TEST_READ_LEN;
1259 #if !defined(UART_API2_NOT_SUPPORTED)
1260     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1261 #else
1262     if (UART_read(uart, callbackTransaction.buf, UART_TEST_READ_LEN) == UART_ERROR)
1263 #endif
1264     {
1265         goto Err;
1266     }
1267     /* Delay for 10 seconds to allow user to enter chars */
1268 #if !defined(SIM_BUILD)
1269     Osal_delay(10000);
1270 #else
1271     Osal_delay(100);
1272 #endif
1273     /* Cancel the read before the read transfer is completed */
1274     UART_readCancel(uart);
1275     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1276     {
1277         goto Err;
1278     }
1280     /* Print read cancelled prompt */
1281     UART_transactionInit(&transaction);
1282     transaction.buf = (void *)(uintptr_t)addrRdCancelPrompt;
1283     transaction.count = strlen(rdCancelPrompt);
1284 #if !defined(UART_API2_NOT_SUPPORTED)
1285     if (UART_write2(uart, &transaction) == UART_ERROR)
1286 #else
1287     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1288 #endif
1289     {
1290         goto Err;
1291     }
1293     UART_transactionInit(&transaction);
1294     transaction.buf = (void *)(uintptr_t)addrDataPrint;
1295     transaction.count = strlen(dataPrint);
1296 #if !defined(UART_API2_NOT_SUPPORTED)
1297     if (UART_write2(uart, &transaction) == UART_ERROR)
1298 #else
1299     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1300 #endif
1301     {
1302         goto Err;
1303     }
1305     /* Perform the 2nd read, which will be completed */
1306     memset(scanPrompt, 0, sizeof(scanPrompt));
1307     if (dmaMode)
1308     {
1309         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1310     }
1312 #if !defined(UART_RX_LOOPBACK_ONLY)
1313     UART_transactionInit(&callbackTransaction);
1314     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1315     callbackTransaction.count = UART_TEST_READ_LEN;
1316 #if !defined(UART_API2_NOT_SUPPORTED)
1317     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1318 #else
1319     if (UART_read(uart, callbackTransaction.buf, UART_TEST_READ_LEN) == UART_ERROR)
1320 #endif
1321     {
1322         goto Err;
1323     }
1324     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1325     {
1326         goto Err;
1327     }
1328 #endif
1329     UART_transactionInit(&transaction);
1330     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1331     transaction.count = strlen(echoPrompt);
1332 #if !defined(UART_API2_NOT_SUPPORTED)
1333     if (UART_write2(uart, &transaction) == UART_ERROR)
1334 #else
1335     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1336 #endif
1337     {
1338         goto Err;
1339     }
1341     /* Print the 2nd read chars, should NOT contain any chars
1342      * in the first cancelled read
1343      */
1344     UART_transactionInit(&transaction);
1345     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1346     transaction.count = sizeof(scanPrompt);
1347 #if !defined(UART_API2_NOT_SUPPORTED)
1348     if (UART_write2(uart, &transaction) == UART_ERROR)
1349 #else
1350     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1351 #endif
1352     {
1353         goto Err;
1354     }
1356     UART_close(uart);
1358     /* write cancel test */
1360     /* Set callback mode for write */
1361     UART_Params_init(&uartParams);
1362     uartParams.writeCallback = UART_callback;
1363     uartParams.writeMode = UART_MODE_CALLBACK;
1364     uartParams.parityType = uartParity;
1366     if (dmaMode)
1367     {
1368         addrWrCancelPrompt = l2_global_address((uintptr_t)wrCancelPrompt);
1369     }
1370     else
1371     {
1372         addrWrCancelPrompt = (uintptr_t)wrCancelPrompt;
1373     }
1375     uart = UART_open(uartTestInstance, &uartParams);
1376     if (uart == NULL)
1377     {
1378         goto Err;
1379     }
1381     /* Perform the 1st write */
1382     UART_transactionInit(&callbackTransaction);
1383     callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
1384     callbackTransaction.count = strlen(wrCancelPrompt);
1385 #if !defined(UART_API2_NOT_SUPPORTED)
1386     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1387 #else
1388     if (UART_write(uart, callbackTransaction.buf, callbackTransaction.count) == UART_ERROR)
1389 #endif
1390     {
1391         goto Err;
1392     }
1393     /* Cancel the 1st write */
1394     UART_writeCancel(uart);
1395     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1396     {
1397         goto Err;
1398     }
1400     /* Perform the 2nd write */
1401     UART_transactionInit(&callbackTransaction);
1402     callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
1403     callbackTransaction.count = strlen(wrCancelPrompt);
1404 #if !defined(UART_API2_NOT_SUPPORTED)
1405     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1406 #else
1407     if (UART_write(uart, callbackTransaction.buf, callbackTransaction.count) == UART_ERROR)
1408 #endif
1409     {
1410         goto Err;
1411     }
1412     /* Cancel the write */
1413     UART_writeCancel(uart);
1414     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1415     {
1416         goto Err;
1417     }
1418     ret = true;
1420 Err:
1421     if (uart)
1422     {
1423         UART_close(uart);
1424     }
1426     if (callbackSem)
1427     {
1428         UART_osalDeleteBlockingLock(callbackSem);
1429         callbackSem = NULL;
1430     }
1432     return (ret);
1435 #if !defined(UART_API2_NOT_SUPPORTED)
1436 /*
1437  *  ======== UART receive error test ========
1438  *
1439  *  The test function tests receive error (e.g. break condition)
1440  */
1441 static bool UART_test_rx_err(bool dmaMode)
1443     UART_Handle      uart = NULL;
1444     UART_Params      uartParams;
1445     UART_Transaction transaction;
1446     uintptr_t         addrScanPrompt, addrBreakErrPrompt;
1447     bool             ret = false;
1449     /* UART SoC init configuration */
1450     UART_initConfig(dmaMode);
1452     /* Initialize the default configuration params. */
1453     UART_Params_init(&uartParams);
1454     uartParams.parityType = uartParity;
1456     if (dmaMode)
1457     {
1458         addrBreakErrPrompt = l2_global_address((uintptr_t)breakErrPrompt);
1459         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1460     }
1461     else
1462     {
1463         addrBreakErrPrompt = (uintptr_t)breakErrPrompt;
1464         addrScanPrompt = (uintptr_t)scanPrompt;
1465     }
1467     uart = UART_open(uartTestInstance, &uartParams);
1468     if (uart == NULL)
1469     {
1470         goto Err;
1471     }
1473     /* Test receive error */
1474     memset(scanPrompt, 0, sizeof(scanPrompt));
1475     if (dmaMode)
1476     {
1477         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1478     }
1479     UART_transactionInit(&transaction);
1480     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1481     transaction.count = UART_TEST_READ_LEN;
1482     if (UART_read2(uart, &transaction) == UART_ERROR)
1483     {
1484         if (transaction.status == UART_TRANSFER_STATUS_ERROR_BI)
1485         {
1486             UART_transactionInit(&transaction);
1487             transaction.buf = (void *)(uintptr_t)addrBreakErrPrompt;
1488             transaction.count = strlen(breakErrPrompt);
1489             if (UART_write2(uart, &transaction) == UART_ERROR)
1490             {
1491                 goto Err;
1492             }
1493         }
1494         else
1495         {
1496             goto Err;
1497         }
1498     }
1500     ret = true;
1502 Err:
1503     if (uart)
1504     {
1505         UART_close(uart);
1506     }
1508     return (ret);
1511 #endif
1513 /*
1514  *  ======== UART timeout test ========
1515  *
1516  *  The test function tests read/write with OS timeout
1517  */
1518 static bool UART_test_timeout(bool dmaMode)
1520     UART_Handle      uart = NULL;
1521     UART_Params      uartParams;
1522     UART_Transaction transaction;
1523     uintptr_t         addrScanPrompt, addrReadTimeoutPrompt;
1524     bool             ret = false;
1526     /* UART SoC init configuration */
1527     UART_initConfig(dmaMode);
1529     /* Initialize the default configuration params. */
1530     UART_Params_init(&uartParams);
1531     uartParams.parityType = uartParity;
1532     uartParams.readTimeout = UART_TEST_TIMEOUT;
1534     if (dmaMode)
1535     {
1536         addrReadTimeoutPrompt = l2_global_address((uintptr_t)readTimeoutPrompt);
1537         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1538     }
1539     else
1540     {
1541         addrReadTimeoutPrompt = (uintptr_t)readTimeoutPrompt;
1542         addrScanPrompt = (uintptr_t)scanPrompt;
1543     }
1545     uart = UART_open(uartTestInstance, &uartParams);
1546     if (uart == NULL)
1547     {
1548         goto Err;
1549     }
1551     /* Test read timeout */
1552     memset(scanPrompt, 0, sizeof(scanPrompt));
1553     if (dmaMode)
1554     {
1555         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1556     }
1557     UART_transactionInit(&transaction);
1558     transaction.buf = (void *)(uintptr_t)scanPrompt;
1559     transaction.count = UART_TEST_READ_LEN;
1560     transaction.timeout = UART_TEST_TIMEOUT;
1561 #if !defined(UART_API2_NOT_SUPPORTED)
1562     if (UART_read2(uart, &transaction) == UART_ERROR)
1563 #else
1564     if (UART_read(uart, transaction.buf, transaction.count) == UART_ERROR)
1565 #endif
1566     {
1567         UART_transactionInit(&transaction);
1568         transaction.buf = (void *)(uintptr_t)addrReadTimeoutPrompt;
1569         transaction.count = strlen(readTimeoutPrompt);
1570         transaction.timeout = UART_TEST_TIMEOUT;
1571         if (UART_write2(uart, &transaction) == UART_ERROR)
1572         {
1573             goto Err;
1574         }
1575     }
1577     ret = true;
1579 Err:
1580     if (uart)
1581     {
1582         UART_close(uart);
1583     }
1585     return (ret);
1588 /*
1589  *  ======== UART polling timeout test ========
1590  *
1591  *  The test function tests read/write with OS timeout in polling mode
1592  */
1593 static bool UART_test_polling_timeout(bool dmaMode)
1595     UART_Handle      uart = NULL;
1596     UART_Params      uartParams;
1597     bool             ret = false;
1598     uint32_t         rdSize = UART_TEST_READ_LEN;
1599     uint32_t         wrSize = strlen(readTimeoutPrompt);
1601     /* UART SoC init configuration */
1602     UART_initConfig(dmaMode);
1604     /* Initialize the default configuration params. */
1605     UART_Params_init(&uartParams);
1606     uartParams.parityType = uartParity;
1608     /* timeout is 0 for both read and write */
1609     uartParams.readTimeout  = UART_NO_WAIT;
1610     uartParams.writeTimeout = UART_NO_WAIT;
1611     uart = UART_open(uartTestInstance, &uartParams);
1612     if (uart == NULL)
1613     {
1614         goto Err;
1615     }
1617     memset(scanPrompt, 0, sizeof(scanPrompt));
1618     if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1619     {
1620         if (UART_writePolling(uart, (const void *)readTimeoutPrompt, wrSize) != wrSize)
1621         {
1622             ret = true;
1623         }
1624     }
1626     if (ret == true)
1627     {
1628         ret = false;
1630         UART_close(uart);
1632         /* timeout is 5 seconds for both read and write */
1633         uartParams.readTimeout  = UART_TEST_TIMEOUT;
1634         uartParams.writeTimeout = UART_TEST_TIMEOUT;
1635         uart = UART_open(uartTestInstance, &uartParams);
1636         if (uart == NULL)
1637         {
1638             goto Err;
1639         }
1641         /* Test read timeout */
1642         memset(scanPrompt, 0, sizeof(scanPrompt));
1643         if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1644         {
1645             UART_writePolling(uart, (const void *)readTimeoutPrompt, wrSize);
1646             ret = true;
1647         }
1648     }
1650     if (ret == true)
1651     {
1652         ret = false;
1654         UART_close(uart);
1656         /* timeout is 5 seconds for both read and write */
1657         uartParams.readTimeout  = UART_WAIT_FOREVER;
1658         uartParams.writeTimeout = UART_WAIT_FOREVER;
1659         uart = UART_open(uartTestInstance, &uartParams);
1660         if (uart == NULL)
1661         {
1662             goto Err;
1663         }
1665         wrSize = strlen(dataPrint);
1666         UART_writePolling(uart, (const void *)dataPrint, wrSize);
1668         memset(scanPrompt, 0, sizeof(scanPrompt));
1670 #if !defined(UART_RX_LOOPBACK_ONLY)
1671         if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1672         {
1673             goto Err;
1674         }
1675 #endif
1676         wrSize = strlen(echoPrompt);
1677         UART_writePolling(uart, (const void *)echoPrompt, wrSize);
1678         UART_writePolling(uart, (const void *)scanPrompt, rdSize);
1680         ret = true;
1681     }
1683 Err:
1684     if (uart)
1685     {
1686         UART_close(uart);
1687     }
1689     return (ret);
1692 /*
1693  *  ======== UART callback test ========
1694  *
1695  *  The test function tests the read/write in callback mode
1696  */
1697 static bool UART_test_callback(bool dmaMode)
1699     UART_Handle       uart = NULL;
1700     UART_Params       uartParams;
1701     SemaphoreP_Params semParams;
1702     uintptr_t          addrScanPrompt, addrDataPrint, addrEchoPrompt;
1703     bool              ret = false;
1705     /* Create call back semaphore */
1706     UART_osalSemParamsInit(&semParams);
1707     semParams.mode = SemaphoreP_Mode_BINARY;
1708     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
1710     /* Test read/write API's in callback mode */
1712     /* UART SoC init configuration */
1713     UART_initConfig(dmaMode);
1715     /* Set callback mode for both read and write */
1716     UART_Params_init(&uartParams);
1717     uartParams.readCallback = UART_callback;
1718     uartParams.readMode = UART_MODE_CALLBACK;
1719     uartParams.writeCallback = UART_callback;
1720     uartParams.writeMode = UART_MODE_CALLBACK;
1721     uartParams.parityType = uartParity;
1723     uart = UART_open(uartTestInstance, &uartParams);
1724     if (uart == NULL)
1725     {
1726         goto Err;
1727     }
1729     if (dmaMode)
1730     {
1731         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1732         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1733         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1734     }
1735     else
1736     {
1737         addrScanPrompt = (uintptr_t)scanPrompt;
1738         addrDataPrint = (uintptr_t)dataPrint;
1739         addrEchoPrompt = (uintptr_t)echoPrompt;
1740     }
1742     /* Write DMA or non-DMA test prompt */
1743     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
1744     {
1745         goto Err;
1746     }
1747     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1748     {
1749         goto Err;
1750     }
1752     memset(scanPrompt, 0, sizeof(scanPrompt));
1753     if (dmaMode)
1754     {
1755         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1756     }
1758 #if !defined(UART_RX_LOOPBACK_ONLY)
1760     if (UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN) == UART_ERROR)
1761     {
1762         goto Err;
1763     }
1764     if (UART_osalPendLock(callbackSem, uartParams.readTimeout) != SemaphoreP_OK)
1765     {
1766         goto Err;
1767     }
1769 #endif
1771     if (UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt)) == UART_ERROR)
1772     {
1773         goto Err;
1774     }
1775     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1776     {
1777         goto Err;
1778     }
1780     if (UART_write(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN) == UART_ERROR)
1781     {
1782         goto Err;
1783     }
1784     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1785     {
1786         goto Err;
1787     }
1789     UART_close(uart);
1790     uart = NULL;
1792     /* Test read2/write2 API's in callback mode */
1793 #if !defined(UART_API2_NOT_SUPPORTED)
1794     uartParams.readCallback2 = UART_callback2;
1795     uartParams.writeCallback2 = UART_callback2;
1796     uartParams.readCallback = NULL;
1797     uartParams.writeCallback = NULL;
1799     uart = UART_open(uartTestInstance, &uartParams);
1800     if (uart == NULL)
1801     {
1802         goto Err;
1803     }
1805     UART_transactionInit(&callbackTransaction);
1806     callbackTransaction.buf = (void *)(uintptr_t)addrDataPrint;
1807     callbackTransaction.count = strlen(dataPrint);
1808     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1809     {
1810         goto Err;
1811     }
1812     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1813     {
1814         goto Err;
1815     }
1817     memset(scanPrompt, 0, sizeof(scanPrompt));
1818     if (dmaMode)
1819     {
1820         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1821     }
1823 #if !defined(UART_RX_LOOPBACK_ONLY)
1824     UART_transactionInit(&callbackTransaction);
1825     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1826     callbackTransaction.count = UART_TEST_READ_LEN;
1827     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1828     {
1829         goto Err;
1830     }
1831     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1832     {
1833         goto Err;
1834     }
1835 #endif
1837     UART_transactionInit(&callbackTransaction);
1838     callbackTransaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1839     callbackTransaction.count = strlen(echoPrompt);
1840     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1841     {
1842         goto Err;
1843     }
1844     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1845     {
1846         goto Err;
1847     }
1849     UART_transactionInit(&callbackTransaction);
1850     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1851     callbackTransaction.count = UART_TEST_READ_LEN;
1852     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1853     {
1854         goto Err;
1855     }
1856     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1857     {
1858         goto Err;
1859     }
1861 #endif
1862     ret = true;
1864 Err:
1865     if (uart)
1866     {
1867         UART_close(uart);
1868     }
1869     if (callbackSem)
1870     {
1871         UART_osalDeleteBlockingLock(callbackSem);
1872         callbackSem = NULL;
1873     }
1874     return (ret);
1877 #if defined (SOC_AM64X) && defined(BUILD_MCU)
1878 /* RS-485 Direction Enable loopback test */
1879 static bool UART_test_rs485(bool dmaMode)
1881     UART_Handle      uart = NULL;
1882     UART_Params      uartParams;
1883     int16_t          length = 0;
1884     bool             ret = true;
1885     uint8_t rBuff[UART_TEST_READ_LEN], tBuff[]="aaaabbbbccccddddeeee";
1887     /* UART SoC init configuration */
1888     verifyRS485    = TRUE;
1889     verifyLoopback = TRUE;
1890     UART_initConfig(dmaMode);
1892     UART_Params_init(&uartParams);
1893     uart = UART_open(uartTestInstance, &uartParams);
1894     if (uart == NULL)
1895     {
1896         goto Err;
1897     }
1899     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
1900     {
1901         goto Err;
1902     }
1904     memset(rBuff, 0, UART_TEST_READ_LEN);
1905     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
1906     for(length=0; length<UART_TEST_READ_LEN; length++)
1907     {
1908         if(tBuff[length] != rBuff[length])
1909         {
1910             ret = false;
1911             break;
1912         }
1913     }
1914     UART_close(uart);
1916 Err:
1917     if (uart != NULL)
1918     {
1919         UART_close(uart);
1920     }
1922     verifyRS485    = FALSE;
1923     verifyLoopback = FALSE;
1924     return (ret);
1926 #endif
1928 /*
1929  *  ========== UART read API test ==========
1930  *
1931  *  The test function for UART_read API
1932  *  in loopback mode
1933  */
1934 static bool UART_test_read_verify(bool dmaMode)
1936     UART_Handle      uart = NULL;
1937     UART_Params      uartParams;
1938     int16_t          length = 0;
1939     bool             ret = false;
1940     uint8_t rBuff[UART_TEST_READ_LEN], tBuff[]="aaaabbbbccccddddeeee";
1941 #if defined(UART_NO_FIFO)
1942     int i;
1943 #endif
1945     verifyLoopback = TRUE;
1946     /* UART SoC init configuration */
1947     UART_initConfig(dmaMode);
1949     /* Initialize the default configuration params. */
1950     UART_Params_init(&uartParams);
1951     uartParams.parityType = uartParity;
1953     uart = UART_open(uartTestInstance, &uartParams);
1955     if (uart == NULL)
1956     {
1957         goto Err;
1958     }
1960 #if !defined(UART_NO_FIFO)
1962     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
1963     {
1964         goto Err;
1965     }
1967     length = UART_read(uart, (void *)&rBuff[0], UART_RDVERIFY_READ_LEN);
1969     if (UART_write(uart, (void *)&tBuff[15], UART_RDVERIFY_READ_LEN) == UART_ERROR)
1970     {
1971         goto Err;
1972     }
1974     length = UART_read(uart, (void *)&rBuff[4], UART_RDVERIFY_READ_LEN);
1975     length = UART_read(uart, (void *)&rBuff[8], UART_RDVERIFY_READ_LEN);
1976     length = UART_read(uart, (void *)&rBuff[12], UART_RDVERIFY_READ_LEN);
1977 #else
1978     memset(rBuff, 0, UART_TEST_READ_LEN);
1979     for (i =0; i < UART_TEST_READ_LEN;i++)
1980     {
1981         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
1982         {
1983             goto Err;
1984         }
1986         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
1987     }
1989 #endif
1991     ret = true;
1992     for(length=0; length<UART_TEST_READ_LEN; length++)
1993     {
1994         if(tBuff[length] != rBuff[length])
1995         {
1996             ret = false;
1997             break;
1998         }
1999     }
2000     UART_close(uart);
2002     /* stop bit loopback test */
2003     UART_Params_init(&uartParams);
2004     uartParams.stopBits = UART_STOP_TWO;
2005     uart = UART_open(uartTestInstance, &uartParams);
2006     if (uart == NULL)
2007     {
2008         goto Err;
2009     }
2011 #if !defined(UART_NO_FIFO)
2012     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2013     {
2014         goto Err;
2015     }
2017     memset(rBuff, 0, UART_TEST_READ_LEN);
2018     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2019 #else
2020     memset(rBuff, 0, UART_TEST_READ_LEN);
2021     for (i =0; i < UART_TEST_READ_LEN;i++)
2022     {
2023         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2024         {
2025             goto Err;
2026         }
2028         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2029     }
2030 #endif
2031     for(length=0; length<UART_TEST_READ_LEN; length++)
2032     {
2033         if(tBuff[length] != rBuff[length])
2034         {
2035             ret = false;
2036             break;
2037         }
2038     }
2039     UART_close(uart);
2041     /* char length loopback test */
2042     UART_Params_init(&uartParams);
2043     uartParams.dataLength = UART_LEN_5;
2044     uart = UART_open(uartTestInstance, &uartParams);
2045     if (uart == NULL)
2046     {
2047         goto Err;
2048     }
2050 #if !defined(UART_NO_FIFO)
2051     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2052     {
2053         goto Err;
2054     }
2056     memset(rBuff, 0, UART_TEST_READ_LEN);
2057     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2058 #else
2059     memset(rBuff, 0, UART_TEST_READ_LEN);
2060     for (i =0; i < UART_TEST_READ_LEN;i++)
2061     {
2062         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2063         {
2064             goto Err;
2065         }
2067         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2068     }
2069 #endif
2070     for(length=0; length<UART_TEST_READ_LEN; length++)
2071     {
2072         if ((tBuff[length] & ((1 << (uartParams.dataLength + 5)) - 1)) != rBuff[length])
2073         {
2074             ret = false;
2075             break;
2076         }
2077     }
2078     UART_close(uart);
2080     /* parity loopback test */
2081     UART_Params_init(&uartParams);
2082     uartParams.parityType = UART_PAR_EVEN;
2083     uart = UART_open(uartTestInstance, &uartParams);
2084     if (uart == NULL)
2085     {
2086         goto Err;
2087     }
2088 #if !defined(UART_NO_FIFO)
2089     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2090     {
2091         goto Err;
2092     }
2094     memset(rBuff, 0, UART_TEST_READ_LEN);
2095     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2096 #else
2097     memset(rBuff, 0, UART_TEST_READ_LEN);
2098     for (i =0; i < UART_TEST_READ_LEN;i++)
2099     {
2100         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2101         {
2102             goto Err;
2103         }
2105         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2106     }
2107 #endif
2108     for(length=0; length<UART_TEST_READ_LEN; length++)
2109     {
2110         if(tBuff[length] != rBuff[length])
2111         {
2112             ret = false;
2113             break;
2114         }
2115     }
2116     UART_close(uart);
2117     uart = NULL;
2119 #if defined (SOC_AM64X) && defined(BUILD_MCU)
2120     if (UART_test_rs485(dmaMode) == false)
2121     {
2122         ret = false;
2123     }
2124 #endif
2125 Err:
2126     if (uart != NULL)
2127     {
2128         UART_close(uart);
2129     }
2131     verifyLoopback = FALSE;
2132     return (ret);
2135 /*
2136  *  ======== UART read/write test ========
2137  *
2138  *  The test function tests read/write in blocking mode
2139  */
2140 static bool UART_test_read_write(bool dmaMode)
2142     UART_Handle      uart = NULL;
2143     UART_Params      uartParams;
2144     int              length = 0;
2145     uintptr_t        addrDataPrint, addrScanPrompt, addrEchoPrompt;
2146 #if !defined(UART_API2_NOT_SUPPORTED)
2147     UART_Transaction transaction;
2148 #endif
2149     bool             ret = false;
2151     /* UART SoC init configuration */
2152     UART_initConfig(dmaMode);
2154     /* Initialize the default configuration params. */
2155     UART_Params_init(&uartParams);
2156     uartParams.parityType = uartParity;
2158     uart = UART_open(uartTestInstance, &uartParams);
2160     if (uart == NULL)
2161     {
2162         goto Err;
2163     }
2165     if (dmaMode)
2166     {
2167         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
2168         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
2169         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
2170     }
2171     else
2172     {
2173         addrDataPrint = (uintptr_t)dataPrint;
2174         addrScanPrompt = (uintptr_t)scanPrompt;
2175         addrEchoPrompt = (uintptr_t)echoPrompt;
2176     }
2178     /* Test read/write API's in blocking mode */
2179     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
2180     {
2181         goto Err;
2182     }
2184     memset(scanPrompt, 0, sizeof(scanPrompt));
2185     if (dmaMode)
2186     {
2187         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2188     }
2189 #ifndef UART_RX_LOOPBACK_ONLY
2190     length = UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN);
2191     if (length != UART_TEST_READ_LEN)
2192     {
2193         goto Err;
2194     }
2195 #endif
2197     UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
2199     UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
2200     UART_close(uart);
2202 #if !defined(UART_API2_NOT_SUPPORTED)
2203     uart = UART_open(uartTestInstance, &uartParams);
2204     if (uart == NULL)
2205     {
2206         goto Err;
2207     }
2209     /* Test read2/write2 API's in blocking mode */
2210     UART_transactionInit(&transaction);
2211     transaction.buf = (void *)(uintptr_t)addrDataPrint;
2212     transaction.count = strlen(dataPrint);
2213     if (UART_write2(uart, &transaction) == UART_ERROR)
2214     {
2215         goto Err;
2216     }
2218     memset(scanPrompt, 0, sizeof(scanPrompt));
2219     if (dmaMode)
2220     {
2221         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2222     }
2223     UART_transactionInit(&transaction);
2224     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2225     transaction.count = UART_TEST_READ_LEN;
2226     if (UART_read2(uart, &transaction) == UART_ERROR)
2227     {
2228         goto Err;
2229     }
2230     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
2231         (transaction.count != UART_TEST_READ_LEN))
2232     {
2233         goto Err;
2234     }
2236     UART_transactionInit(&transaction);
2237     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
2238     transaction.count = strlen(echoPrompt);
2239     if (UART_write2(uart, &transaction) == UART_ERROR)
2240     {
2241         goto Err;
2242     }
2244     UART_transactionInit(&transaction);
2245     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2246     transaction.count = UART_TEST_READ_LEN;
2247     if (UART_write2(uart, &transaction) == UART_ERROR)
2248     {
2249         goto Err;
2250     }
2252 #else
2253     uart = NULL;
2254 #endif
2256     ret = true;
2258 Err:
2259     if (uart)
2260     {
2261         UART_close(uart);
2262     }
2264     return (ret);
2267 /*
2268  *  ======== UART read/write test with interrupt disabled ========
2269  *
2270  *  The test function tests read/write with interrupt disabled
2271  */
2272 static bool UART_test_read_write_int_disable(bool dmaMode)
2274     UART_Handle      uart = NULL;
2275     UART_Params      uartParams;
2276     int              length = 0;
2277     uintptr_t         addrDataPrint, addrScanPrompt, addrEchoPrompt;
2278     UART_Transaction transaction;
2279     bool             ret = false;
2280     UART_HwAttrs uart_cfg;
2282     /* UART SoC init configuration */
2283     UART_initConfig(dmaMode);
2285     /* Initialize the default configuration params. */
2286     UART_Params_init(&uartParams);
2287     uartParams.parityType = uartParity;
2289     /* Get the default UART init configurations */
2290     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
2292     uart_cfg.enableInterrupt=0; /* Disabling interrupt forcefully */
2294     /* Get the default UART init configurations */
2295     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
2297     uart = UART_open(uartTestInstance, &uartParams);
2299     if (uart == NULL)
2300     {
2301         goto Err;
2302     }
2304     if (dmaMode)
2305     {
2306         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
2307         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
2308         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
2309     }
2310     else
2311     {
2312         addrDataPrint = (uintptr_t)dataPrint;
2313         addrScanPrompt = (uintptr_t)scanPrompt;
2314         addrEchoPrompt = (uintptr_t)echoPrompt;
2315     }
2317     /* Test read/write API's in blocking mode */
2318     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
2319     {
2320         goto Err;
2321     }
2323     memset(scanPrompt, 0, sizeof(scanPrompt));
2324     if (dmaMode)
2325     {
2326         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2327     }
2329 #if !defined(UART_RX_LOOPBACK_ONLY)
2330     length = UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN);
2331     if (length != UART_TEST_READ_LEN)
2332     {
2333         goto Err;
2334     }
2335 #endif
2336     UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
2338     UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
2339     UART_close(uart);
2341     uart = UART_open(uartTestInstance, &uartParams);
2342     if (uart == NULL)
2343     {
2344         goto Err;
2345     }
2347 #if !defined(UART_API_NOT_SUPPORTED)
2348     /* Test read2/write2 API's in blocking mode */
2349     UART_transactionInit(&transaction);
2350     transaction.buf = (void *)(uintptr_t)addrDataPrint;
2351     transaction.count = strlen(dataPrint);
2352     if (UART_write2(uart, &transaction) == UART_ERROR)
2353     {
2354         goto Err;
2355     }
2357     memset(scanPrompt, 0, sizeof(scanPrompt));
2358     if (dmaMode)
2359     {
2360         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2361     }
2362     UART_transactionInit(&transaction);
2363     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2364     transaction.count = UART_TEST_READ_LEN;
2365     if (UART_read2(uart, &transaction) == UART_ERROR)
2366     {
2367         goto Err;
2368     }
2369     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
2370         (transaction.count != UART_TEST_READ_LEN))
2371     {
2372         goto Err;
2373     }
2375     UART_transactionInit(&transaction);
2376     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
2377     transaction.count = strlen(echoPrompt);
2378     if (UART_write2(uart, &transaction) == UART_ERROR)
2379     {
2380         goto Err;
2381     }
2383     UART_transactionInit(&transaction);
2384     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2385     transaction.count = UART_TEST_READ_LEN;
2386     if (UART_write2(uart, &transaction) == UART_ERROR)
2387     {
2388         goto Err;
2389     }
2391 #endif
2392     ret = true;
2394 Err:
2395     if (uart)
2396     {
2397         UART_close(uart);
2398     }
2400     /* Get the default UART init configurations */
2401     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
2402     uart_cfg.enableInterrupt=1; /* Re-enabling interrupt for the remaining the tests */
2403     /* Get the default UART init configurations */
2404     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
2406     return (ret);
2409 #ifdef UART_DMA_ENABLE
2410 #if !(defined(SOC_TPR12) || defined (SOC_AWR294X))
2411 static uint32_t UART_getMaxNumInst(uint32_t numInst)
2413     uint32_t     i = 0;
2414 #if defined (SOC_AM572x) || defined (SOC_AM571x) || defined (SOC_AM574x) || defined (SOC_AM335X) || defined (SOC_AM437X)
2415     UART_HwAttrs uart_cfg;
2417     for (i = 0; i < numInst; i++)
2418     {
2419         memset(&uart_cfg, 0, sizeof(UART_HwAttrs));
2420         UART_socGetInitCfg(i, &uart_cfg);
2422         if (uart_cfg.baseAddr == 0)
2423         {
2424             break;
2425         }
2426     }
2427 #endif
2428     return (i);
2430 SemaphoreP_Handle MiCbSem[UART_TEST_NUM_INSTS] = {NULL, };
2431 UART_Handle       MiUartHandle[UART_TEST_NUM_INSTS] = {NULL, };
2432 void UART_miCallback(UART_Handle handle, void *buf, size_t count)
2434     uint32_t i;
2436     for (i = 0; i < UART_TEST_NUM_INSTS; i++)
2437     {
2438         if (MiUartHandle[i] == handle)
2439         {
2440             UART_osalPostLock(MiCbSem[i]);
2441             break;
2442         }
2443     }
2446 /*
2447  *  ========== UART multiple instances test ==========
2448  *
2449  *  The test function for UART read/write on multiple instances
2450  *  in loopback mode
2451  */
2452 #if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
2453 #pragma DATA_ALIGN (MiRxBuf, UART_TEST_CACHE_LINE_SIZE)
2454 char MiRxBuf[UART_TEST_NUM_INSTS][UART_TEST_CACHE_LINE_SIZE];
2455 #pragma DATA_ALIGN (MiTxBuf, UART_TEST_CACHE_LINE_SIZE)
2456 char MiTxBuf[UART_TEST_CACHE_LINE_SIZE];
2457 #else
2458 char MiRxBuf[UART_TEST_NUM_INSTS][UART_TEST_CACHE_LINE_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2459 char MiTxBuf[UART_TEST_CACHE_LINE_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2460 #endif
2462 static bool UART_test_multiple_instances(bool dmaMode)
2464     UART_Params       uartParams;
2465     bool              ret = false;
2466     uint32_t          i, j;
2467     uintptr_t          bufAddr;
2468     uint32_t          uartTestStartInst = uartTestInstance;
2469     uint32_t          numUartTestInstances;
2470     SemaphoreP_Params semParams;
2472     /* enable the loopback */
2473     verifyLoopback = TRUE;
2475     /* Get the max number of instances for testing */
2476     numUartTestInstances = UART_getMaxNumInst(UART_TEST_NUM_INSTS);
2478     for (i = 0; i < numUartTestInstances; i++)
2479     {
2480         /* UART SoC init configuration */
2481         UART_initConfig(dmaMode);
2483         /* Create call back semaphores */
2484         UART_osalSemParamsInit(&semParams);
2485         semParams.mode = SemaphoreP_Mode_BINARY;
2486         MiCbSem[i] = UART_osalCreateBlockingLock(0, &semParams);
2488         /* Set callback mode for read */
2489         UART_Params_init(&uartParams);
2490         uartParams.readCallback = UART_miCallback;
2491         uartParams.readMode = UART_MODE_CALLBACK;
2492         uartParams.parityType = uartParity;
2494         MiUartHandle[i] = UART_open(uartTestInstance, &uartParams);
2495         if (MiUartHandle[i] == NULL)
2496         {
2497             goto Err;
2498         }
2499         uartTestInstance++;
2500     }
2502     for (i = 0; i < numUartTestInstances; i++)
2503     {
2504         memset(MiRxBuf[i], 0, UART_TEST_CACHE_LINE_SIZE);
2505         if (dmaMode)
2506         {
2507             bufAddr = l2_global_address((uintptr_t)MiRxBuf[i]);
2508             CacheP_wbInv((void *)(uintptr_t)bufAddr, UART_TEST_CACHE_LINE_SIZE);
2509         }
2510         else
2511         {
2512             bufAddr = (uintptr_t)MiRxBuf[i];
2513         }
2515         UART_read(MiUartHandle[i], (void *)(uintptr_t)bufAddr, UART_TEST_READ_LEN);
2516     }
2518     for (i = 0; i < numUartTestInstances; i++)
2519     {
2520         for (j = 0; j < UART_TEST_READ_LEN; j++)
2521         {
2522             MiTxBuf[j] = fifoTrgLvlData[j] + (char)i;
2523         }
2524         if (dmaMode)
2525         {
2526             bufAddr = l2_global_address((uintptr_t)MiTxBuf);
2527             CacheP_wbInv((void *)(uintptr_t)bufAddr, UART_TEST_CACHE_LINE_SIZE);
2528         }
2529         else
2530         {
2531             bufAddr = (uintptr_t)MiTxBuf;
2532         }
2534         if (UART_write(MiUartHandle[i], (void *)(uintptr_t)bufAddr, UART_TEST_READ_LEN) == UART_ERROR)
2535         {
2536             goto Err;
2537         }
2538     }
2540     /* add delay for the read semaphore calback */
2541     Osal_delay(100);
2543     for (i = 0; i < numUartTestInstances; i++)
2544     {
2545         for (j = 0; j < UART_TEST_READ_LEN; j++)
2546         {
2547             if ((fifoTrgLvlData[j] + (char)i) != MiRxBuf[i][j])
2548             {
2549                 goto Err;
2550             }
2551         }
2552     }
2554     ret = true;
2556 Err:
2557     for (i = 0; i < numUartTestInstances; i++)
2558     {
2559         if (MiUartHandle[i] != NULL)
2560         {
2561             UART_close(MiUartHandle[i]);
2562             MiUartHandle[i] = NULL;
2563         }
2564     }
2566     verifyLoopback = FALSE;
2567     uartTestInstance = uartTestStartInst;
2568     return (ret);
2570 #endif /* if SOC_TPR12 */
2571 #endif /* if DMA */
2573 /**
2574  *  @b Description
2575  *  @n
2576  *      The function is used to test the UART Driver *WRITE* functions with
2577  *      various invalid arguments.
2578  *
2579  *  @param[in]  handle
2580  *      UART Handle
2581  *
2582  *  @retval
2583  *      Success -   0
2584  *  @retval
2585  *      Error   -   <0
2586  */
2587 static bool UART_writeInvalidArgs(UART_Handle handle)
2589     uint8_t     buffer[4];
2590     int32_t     status;
2592     /**************************************************************************
2593      * Test: Write with invalid buffer
2594      **************************************************************************/
2595     status = UART_write(handle, NULL, 128);
2596     if (status >= 0)
2597     {
2598         UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
2599         return false;
2600     }
2602     /**************************************************************************
2603      * Test: Write with invalid size
2604      **************************************************************************/
2605     status = UART_write(handle, &buffer[0], 0);
2606     if (status >= 0)
2607     {
2608         UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
2609         return false;
2610     }
2612     /**************************************************************************
2613      * Test: Write Polling with invalid buffer
2614      **************************************************************************/
2615     status = UART_writePolling(handle, NULL, 128);
2616     if (status >= 0)
2617     {
2618         UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
2619         return false;
2620     }
2622     /**************************************************************************
2623      * Test: Write Polling with invalid size
2624      **************************************************************************/
2625     status = UART_writePolling(handle, &buffer[0], 0);
2626     if (status >= 0)
2627     {
2628         UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
2629         return false;
2630     }
2632     return true;
2635 /**
2636  *  @b Description
2637  *  @n
2638  *      The function is used to test the UART Driver *READ* functions with
2639  *      various invalid arguments.
2640  *
2641  *  @param[in]  handle
2642  *      UART Handle
2643  *
2644  *  @retval
2645  *      Success -   0
2646  *  @retval
2647  *      Error   -   <0
2648  */
2649 static bool UART_readInvalidArgs(UART_Handle handle)
2651     uint8_t     buffer[4];
2652     int32_t     status;
2654     /**************************************************************************
2655      * Test: Read with invalid buffer
2656      **************************************************************************/
2657     status = UART_read(handle, NULL, 128);
2658     if (status != UART_EINVAL)
2659     {
2660         UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
2661         return false;
2662     }
2664     /**************************************************************************
2665      * Test: Read with invalid size
2666      **************************************************************************/
2667     status = UART_read(handle, &buffer[0], 0);
2668     if (status != UART_EINVAL)
2669     {
2670         UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
2671         return false;
2672     }
2674     /**************************************************************************
2675      * Test: Read Polling with invalid buffer
2676      **************************************************************************/
2677     status = UART_readPolling(handle, NULL, 128);
2678     if (status != UART_EINVAL)
2679     {
2680         UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
2681         return false;
2682     }
2684     /**************************************************************************
2685      * Test: Read Polling with invalid size
2686      **************************************************************************/
2687     status = UART_readPolling(handle, &buffer[0], 0);
2688     if (status != UART_EINVAL)
2689     {
2690         UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
2691         return false;
2692     }
2694     return true;
2697 /**
2698  *  @b Description
2699  *  @n
2700  *      The function is used to test the exported UART API.
2701  *
2702  *  @retval
2703  *      Success     -   0
2704  *  @retval
2705  *      Error       -   <0
2706  */
2707 bool UART_test_api (bool dmaMode)
2709     UART_Params     params;
2710     UART_Handle     handle;
2712     /* UART SoC init configuration */
2713     UART_initConfig(dmaMode);
2715     /* Setup the default UART Parameters */
2716     UART_Params_init(&params);
2718     /* Open the UART Instance */
2719     handle = UART_open(uartTestInstance, &params);
2720     if (handle == NULL)
2721     {
2722         UART_test_log("Error: Unable to open the UART Instance\n");
2723         return false;
2724     }
2725     /**************************************************************************
2726      * Test: Graceful shutdown
2727      **************************************************************************/
2728     UART_close(handle);
2730     /**************************************************************************
2731      * Test: Reopen the driver
2732      **************************************************************************/
2733     handle = UART_open(0, &params);
2734     if (handle == NULL)
2735     {
2736         UART_test_log("Error: Unable to open the UART Instance\n");
2737         return false;
2738     }
2740     /* Test: This will test the UART Write with Invalid arguments */
2741     if (!UART_writeInvalidArgs(handle))
2742         return false;
2744     /* Test: This will test the UART Read with Invalid arguments */
2745     if (!UART_readInvalidArgs(handle))
2746         return false;
2748     /* Close the driver: */
2749     UART_close(handle);
2750     return true;
2753 #if (defined(SOC_TPR12) || defined (SOC_AWR294X)) && defined(SIM_BUILD)
2755 /**
2756  *  @b Description
2757  *  @n
2758  *      The function is used to populate the *test* buffer with a predefined
2759  *      signature
2760  *
2761  *  @param[in]  ptrBuffer
2762  *      Buffer to be populated
2763  *  @param[in]  size
2764  *      Size of the buffer
2765  *
2766  *  @retval
2767  *      Not applicable
2768  */
2769 void UART_populateBuffer (char* ptrBuffer, uint32_t size)
2771     uint32_t index;
2772     char     ch = 'A';
2774     /* Populate the data buffer: */
2775     for (index = 0; index < size; index++)
2776     {
2777         *(ptrBuffer + index) = ch++;
2778         if (ch == ('Z'+1))
2779             ch = 'A';
2780     }
2781     return;
2784 /**
2785  *  @b Description
2786  *  @n
2787  *      The function is used to profile the UART Transmit API for
2788  *      comparison in DMA and Non-DMA mode
2789  *
2790  *  @retval
2791  *      Success -   0
2792  *  @retval
2793  *      Error   -   <0
2794  */
2795 #if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
2796 #pragma DATA_ALIGN (uartDataBuf, UART_TEST_CACHE_LINE_SIZE)
2797 char uartDataBuf[0x2000];
2798 #else
2799 char uartDataBuf[0x2000] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2800 #endif
2802 bool UART_test_profile_tx(bool dmaMode)
2804     int32_t         status;
2805     UART_Params     params;
2806     UART_Handle     handle;
2807     int32_t         testIndex;
2808     int32_t         dataSizeIndex;
2809     uint32_t        dataSize[] = { 64, 256, 1024, 4096, 8192 };
2810     uint32_t        numDataSize = sizeof(dataSize)/sizeof(uint32_t);
2811     uint32_t        baudRate =  921600;
2812     uintptr_t       ptrTxData;
2813     uint32_t        txTimeTaken;
2814     UART_Stats      stats;
2815     char            testDescription[128];
2817 #if defined(SIM_BUILD)
2818     numDataSize = 3;
2819 #endif
2821     CycleprofilerP_init();
2823     /********************************************************************************
2824      * Execute the test for all data sizes
2825      ********************************************************************************/
2826     for (dataSizeIndex = 0; dataSizeIndex < numDataSize; dataSizeIndex++)
2827     {
2828         /********************************************************************************
2829          * For each data size we will run through the following:-
2830          * - Test Index 0: Non-DMA + Blocking Mode
2831          * - Test Index 1: DMA + Blocking Mode
2832          * - Test Index 2: Non-DMA + Polling Mode
2833          * - Test Index 3: DMA + Polling Mode
2834          ********************************************************************************/
2835         for (testIndex = 0; testIndex < 4; testIndex++)
2836         {
2838 #ifdef UART_DMA_ENABLE
2839             if(testIndex & 1)
2840             {
2841                 dmaMode = true;
2842                 ptrTxData = l2_global_address((uintptr_t)uartDataBuf);
2843             }
2844             else
2845 #endif
2846             {
2847                 dmaMode = false;
2848                 ptrTxData = (uintptr_t)uartDataBuf;
2849             }
2851             /* UART SoC init configuration */
2852             UART_initConfig(dmaMode);
2854             /*******************************************************************************
2855              * Initialization:
2856              *******************************************************************************/
2857             UART_Params_init(&params);
2858             params.readDataMode   = UART_DATA_BINARY;
2859             params.writeDataMode  = UART_DATA_BINARY;
2860             params.baudRate       = baudRate;
2861             params.readEcho       = UART_ECHO_OFF;
2863             /* Open the UART Instance: */
2864             handle = UART_open(uartTestInstance, &params);
2865             if (handle == NULL)
2866             {
2867                 UART_test_log ("Error: Unable to open the UART Driver while profiling Transmit Data\n");
2868                 return false;
2869             }
2871             /******************************************************************************
2872              * Debug Message:
2873              ******************************************************************************/
2874             switch (testIndex)
2875             {
2876                 case 0:
2877                 {
2878                     sprintf (testDescription, "UART %d Profile Test in Non-DMA Blocking Mode [Data Size %d bytes]",
2879                              uartTestInstance, dataSize[dataSizeIndex]);
2880                     break;
2881                 }
2882                 case 1:
2883                 {
2884                     sprintf (testDescription, "UART %d Profile Test in DMA Blocking Mode [Data Size %d bytes]",
2885                              uartTestInstance, dataSize[dataSizeIndex]);
2886                     break;
2887                 }
2888                 case 2:
2889                 {
2890                     sprintf (testDescription, "UART %d Profile Test in Non-DMA Polling Mode [Data Size %d bytes]",
2891                              uartTestInstance, dataSize[dataSizeIndex]);
2892                     break;
2893                 }
2894                 case 3:
2895                 {
2896                     sprintf (testDescription, "UART %d Profile Test in DMA Polling Mode [Data Size %d bytes]",
2897                              uartTestInstance, dataSize[dataSizeIndex]);
2898                     break;
2899                 }
2900                 default:
2901                 {
2902                     /* Control should never come here */
2903                     OSAL_Assert (!0);
2904                     return false;
2905                 }
2906             }
2908             /* Initialize the memory to be used: */
2909             memset ((void *)uartDataBuf, 0, dataSize[dataSizeIndex]);
2911             /* Populate the transmit buffer: */
2912             UART_populateBuffer (uartDataBuf, dataSize[dataSizeIndex]);
2914             if (dmaMode)
2915             {
2916                 CacheP_wbInv((void *)(uintptr_t)uartDataBuf, (int32_t)dataSize[dataSizeIndex]);
2917             }
2919             /****************************************************************
2920              * Profile the time taken to send out the data
2921              ****************************************************************/
2922             txTimeTaken = CycleprofilerP_getTimeStamp();
2924             if ((testIndex == 0) || (testIndex == 1))
2925                 status = UART_write(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
2926             else
2927                 status = UART_writePolling(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
2929             txTimeTaken = CycleprofilerP_getTimeStamp() - txTimeTaken;
2931             /* Were we able to send out the data */
2932             if (status != dataSize[dataSizeIndex])
2933             {
2934                 UART_test_log1 ("Error: Unable to send out the data [Status %d]\n", status);
2935                 UART_close(handle);
2936                 return false;
2937             }
2939             /* Get the UART Statistics: */
2940             if (UART_control (handle, UART_CMD_GET_STATS, &stats) < 0)
2941             {
2942                 UART_close(handle);
2943                 return false;
2944             }
2946             /* Debug Message: */
2947             UART_test_log ("Debug: Transmit Measurements\n");
2948             UART_test_log1 ("Debug: Baud Rate        : %d\n", baudRate);
2949             UART_test_log1 ("Debug: Data Size        : %d\n", dataSize[dataSizeIndex]);
2950             UART_test_log1 ("Debug: Transmit         : %d ticks\n", txTimeTaken);
2951             UART_test_log1 ("Debug: Tx Interrupt     : %d\n", stats.numTxInterrupts);
2952             UART_test_log1 ("Debug: Tx DMA Interrupt : %d\n", stats.numTxDMAInterrupts);
2954             /* Close the driver: */
2955             UART_close(handle);
2956         }
2957     }
2959     /********************************************************************************************
2960      * This is just a beautification; we have mucked around with the UART Console by dumping
2961      * all the data. So here we open a console and just put a banner to make it clean
2962      ********************************************************************************************/
2963     {
2964         char* ptrTestDelimitter = "\n\r*********************************************\n\r";
2966         UART_Params_init(&params);
2967         params.readDataMode   = UART_DATA_BINARY;
2968         params.writeDataMode  = UART_DATA_BINARY;
2969         params.baudRate       = baudRate;
2970         params.readEcho       = UART_ECHO_OFF;
2972         /* Open the UART Instance: */
2973         handle = UART_open(uartTestInstance, &params);
2974         if (!handle)
2975         {
2976             UART_test_log ("Error: Unable to open the UART Driver while printing the test banner\n");
2977             return false;
2978         }
2980         /* Write the banner on the console*/
2981         UART_writePolling (handle, (uint8_t*)ptrTestDelimitter, strlen(ptrTestDelimitter));
2982         UART_writePolling (handle, (uint8_t*)ptrTestDelimitter, strlen(ptrTestDelimitter));
2984         /* Close the driver: */
2985         UART_close(handle);
2986     }
2988     return true;
2990 #endif
2992 bool UART_test_loopback_data(bool dmaMode)
2994     bool              ret = false;
2995     UART_Handle       handle = NULL;
2996     UART_Params       params;
2997     SemaphoreP_Params semParams;
2998     int32_t           status;
2999     uintptr_t         pTxBuf;
3000     uintptr_t         pRxBuf;
3001     uint32_t          i;
3003     /* Create call back semaphore for read */
3004     UART_osalSemParamsInit(&semParams);
3005     semParams.mode = SemaphoreP_Mode_BINARY;
3006     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
3008     /* enable the loopback */
3009     verifyLoopback = TRUE;
3011     /* UART SoC init configuration */
3012     UART_initConfig(dmaMode);
3014     /* Setup the read callback UART Parameters */
3015     UART_Params_init(&params);
3016     params.baudRate = 921600;
3017     params.readCallback = UART_callback;
3018     params.readMode = UART_MODE_CALLBACK;
3020     /* Open the UART Instance */
3021     handle = UART_open(uartTestInstance, &params);
3022     if (handle == NULL)
3023     {
3024         UART_test_log ("Error: Unable to open the UART Driver!\n");
3025         goto Err;
3026     }
3028     /* Reset the Rx buffer */
3029     memset(scanPrompt, 0, MAX_TEST_BUFFER_SIZE);
3031     if (dmaMode)
3032     {
3033         pTxBuf = l2_global_address((uintptr_t)fifoTrgLvlData);
3034         pRxBuf = l2_global_address((uintptr_t)scanPrompt);
3035         CacheP_wbInv((void *)(uintptr_t)scanPrompt, MAX_TEST_BUFFER_SIZE);
3036     }
3037     else
3038     {
3039         pTxBuf = (uintptr_t)fifoTrgLvlData;
3040         pRxBuf = (uintptr_t)scanPrompt;
3041     }
3043     /* RX in callback mode */
3044     status = UART_read(handle, (void *)pRxBuf, MAX_TEST_BUFFER_SIZE);
3045     if (status < 0)
3046     {
3047         UART_test_log1 ("Error: UART_read() return %d!\n", status);
3048         goto Err;
3049     }
3051     /* Send out the data */
3052     status = UART_write(handle, (void *)pTxBuf, MAX_TEST_BUFFER_SIZE);
3053     if (status < 0)
3054     {
3055         UART_test_log1 ("Error: UART_write() return %d!\n", status);
3056         goto Err;
3057     }
3059     /* Wait for RX call back */
3060     if ((status = UART_osalPendLock(callbackSem, params.writeTimeout)) != SemaphoreP_OK)
3061     {
3062         UART_test_log1 ("Error: UART_osalPendLock() return %d!\n", status);
3063         goto Err;
3064     }
3066     /* Check if read data matches with write data */
3067     for (i = 0; i < MAX_TEST_BUFFER_SIZE; i++)
3068     {
3069         if (scanPrompt[i] != fifoTrgLvlData[i])
3070         {
3071             UART_test_log3 ("Error: UART_test_loopback_data: data fails at index %d (%c != %c)\n", i, scanPrompt[i], fifoTrgLvlData[i]);
3072             goto Err;
3073         }
3074     }
3075     ret = true;
3077 Err:
3078     if (callbackSem != NULL)
3079     {
3080         UART_osalDeleteBlockingLock(callbackSem);
3081         callbackSem = NULL;
3082     }
3083     if (handle != NULL)
3084     {
3085         UART_close(handle);
3086     }
3088     verifyLoopback = FALSE;
3089     return (ret);
3092 UART_Tests Uart_tests[] =
3094 #ifdef UART_DMA_ENABLE
3095     {UART_test_read_write, true, UART_TEST_ID_DMA, "\r\n UART DMA read write test in block mode"},
3096 #endif
3097     {UART_test_read_write, false, UART_TEST_ID_INT, "\r\n UART non-DMA read write test in block mode"},
3098 #ifdef UART_DMA_ENABLE
3099     {UART_test_callback, true, UART_TEST_ID_DMA_CB, "\r\n UART DMA read write test in callback mode"},
3100 #endif
3101     {UART_test_callback, false, UART_TEST_ID_CB, "\r\n UART non-DMA read write test in callback mode"},
3102 #ifdef UART_DMA_ENABLE
3103     {UART_test_timeout, true, UART_TEST_ID_DMA_TO, "\r\n UART DMA timeout test, wait for 10 seconds to timeout read"},
3104 #endif
3105     {UART_test_timeout, false, UART_TEST_ID_TO, "\r\n UART non-DMA timeout test, wait for 10 seconds to timeout read"},
3106 #if !defined(UART_API2_NOT_SUPPORTED)
3107 #ifdef UART_DMA_ENABLE
3108     {UART_test_rx_err, true, UART_TEST_ID_DMA_RXERR, "\r\n UART DMA RX error test, enter a break"},
3109 #endif
3110     {UART_test_rx_err, false, UART_TEST_ID_RXERR, "\r\n UART non-DMA RX error test, enter a break"},
3111 #endif
3112 #ifdef UART_DMA_ENABLE
3113     {UART_test_read_write_cancel, true, UART_TEST_ID_DMA_CANCEL, "\r\n UART DMA read write cancel test, enter less than 16 chars"},
3114 #endif
3115     {UART_test_read_write_cancel, false, UART_TEST_ID_CANCEL, "\r\n UART non-DMA read write cancel test, enter less than 16 chars"},
3116 #if defined (USE_BIOS) || defined (FREERTOS)
3117 #if !defined(UART_API2_NOT_SUPPORTED)
3118 #ifdef UART_DMA_ENABLE
3119     {UART_test_simultaneous_rw, true, UART_TEST_ID_DMA_RW, "\r\n UART DMA simultaneous read write test "},
3120 #endif
3121     {UART_test_simultaneous_rw, false, UART_TEST_ID_RW, "\r\n UART non-DMA simultaneous read write test "},
3122 #endif
3123 #endif
3124 #if defined(UART_DMA_ENABLE)
3125 #if !defined(UART_NO_FIFO)
3126     {UART_test_fifo_trglvl, true, UART_TEST_ID_DMA_TRGLVL, "\r\n UART DMA TX/RX FIFO trigger level test "},
3127 #endif
3128 #endif
3129     {UART_test_printf_scanf, false, UART_TEST_ID_PRINTF, "\r\n UART stdio printf and scanf test "},
3130 #if !defined(UART_NO_FIFO)
3131     {UART_test_fifo_trglvl, false, UART_TEST_ID_TRGLVL, "\r\n UART non-DMA TX/RX FIFO trigger level test "},
3132 #endif
3133     {UART_test_polling_timeout, false, UART_TEST_ID_POLL_TO, "\r\n UART polling timeout test, wait for 10 seconds to timeout read"},
3134     {UART_test_printf_scanf_stdio_params, false, UART_TEST_ID_STDIOPARAMS, "\r\n UART stdio printf and scanf test with STDIO params(Default) "},
3135     {UART_test_read_write_int_disable, false, UART_TEST_ID_INT_DISABLE, "\r\n UART read write test with interrupt disabled"},
3136     {UART_test_read_verify, false, UART_TEST_ID_RDVERIFY, "\r\n UART non-DMA read API test in loopback mode"},
3137 #ifdef UART_DMA_ENABLE
3138 #if !(defined(SOC_TPR12) || defined (SOC_AWR294X))
3139     {UART_test_multiple_instances, true, UART_TEST_ID_MULTI_INSTS, "\r\n UART DMA multiple instances loopback test "},
3140 #endif
3141 #endif
3142     {UART_test_api, false, UART_TEST_ID_API, "\r\n UART API Test"},
3143 #if (defined(SOC_TPR12) || defined (SOC_AWR294X)) && defined(SIM_BUILD)
3144     {UART_test_profile_tx, false, UART_TEST_ID_PROF_TX, "\r\n UART non-DMA/DMA Blocking/Polling transmit profiling"},
3145 #endif
3146 #ifdef UART_DMA_ENABLE
3147     {UART_test_loopback_data, true, UART_TEST_ID_DMA_LB_DATA, "\r\n UART DMA read write test with loopback"},
3148 #endif
3149     {UART_test_loopback_data, false, UART_TEST_ID_LB_DATA, "\r\n UART non-DMA read write test with loopback"},
3150     {NULL, }
3151 };
3153 void UART_test_print_test_desc(UART_Tests *test)
3156 #if !defined(SIM_BUILD)
3157     UART_Handle uart = NULL;
3158     UART_Params uartParams;
3159     char        testIdPrompt[16] = "\r\n UART UT ";
3160         char        crPrompt[16] = "\r\n";
3161     char        testId[16] = {0, };
3163     /* UART SoC init configuration */
3164     UART_initConfig(false);
3166     /* Initialize the default configuration params. */
3167     UART_Params_init(&uartParams);
3168     uartParams.parityType = uartParity;
3169     uart = UART_open(uartTestInstance, &uartParams);
3171     /* Print unit test ID */
3172     sprintf(testId, "%d", test->testId);
3173     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3174     UART_write(uart, (void *)(uintptr_t)testIdPrompt, sizeof(testIdPrompt));
3175     UART_write(uart, (void *)(uintptr_t)testId, sizeof(testId));
3176     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3178     /* Print test description */
3179     UART_write(uart, (void *)(uintptr_t)test->testDesc, sizeof(test->testDesc));
3180     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3182     UART_close(uart);
3183 #else
3184     printf("UART UT %d: %s\n", test->testId, test->testDesc);
3185 #endif
3188 void UART_test_print_test_result(UART_Tests *test, bool pass)
3190 #if !defined(SIM_BUILD)
3191     UART_Handle uart = NULL;
3192     UART_Params uartParams;
3193     char        testIdPrompt[16] = "\r\n UART UT ";
3194     char        crPrompt[16] = "\r\n";
3195     char        testId[16] = {0, };
3196     char        resultPass[16] = " PASSED";
3197     char        resultFail[16] = " FAILED";
3199     /* UART SoC init configuration */
3200     UART_initConfig(false);
3202     /* Initialize the default configuration params. */
3203     UART_Params_init(&uartParams);
3204     uartParams.parityType = uartParity;
3205     uart = UART_open(uartTestInstance, &uartParams);
3207     /* Print unit test ID */
3208     sprintf(testId, "%d", test->testId);
3209     UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
3210     UART_write(uart, (void *)(uintptr_t)testIdPrompt, strlen(testIdPrompt));
3211     UART_write(uart, (void *)(uintptr_t)testId, strlen(testId));
3212     if (pass == true)
3213     {
3214         UART_write(uart, (void *)(uintptr_t)resultPass, strlen(resultPass));
3215     }
3216     else
3217     {
3218         UART_write(uart, (void *)(uintptr_t)resultFail, strlen(resultFail));
3219     }
3221     UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
3223     UART_close(uart);
3224 #else
3225     printf("UART UT %d: %s\n", test->testId, pass?"PASSED":"FAILED");
3226 #endif
3229 void UART_test_print_test_results(bool pass)
3231     const char  resultPass[32] = "\r\n All tests have passed. \r\n";
3232     const char  resultFail[32] = "\r\n Some tests have failed. \r\n";
3234 #if !defined(SIM_BUILD)
3236     /* UART SoC init configuration */
3237     UART_initConfig(false);
3239     UART_stdioInit(uartTestInstance);
3241     if (pass == true)
3242     {
3243         UART_printStatus(resultPass);
3244     }
3245     else
3246     {
3247         UART_printStatus(resultFail);
3248     }
3249     UART_stdioDeInit();
3250 #else
3251     printf("%s", pass?resultPass:resultFail);
3252 #endif
3255 #if defined (USE_BIOS) || defined (FREERTOS)
3256 /*
3257  *  ======== taskFxn ========
3258  */
3259 void taskFxn(void *a0, void *a1)
3260 #else
3261 int main(void)
3262 #endif /* #if defined (USE_BIOS) || defined (FREERTOS) */
3264     bool testResult = false;
3265     uint32_t i;
3267 #if !(defined(USE_BIOS) || defined(FREERTOS))
3268     if (Board_initUART() == false)
3269     {
3270         return(0);
3271     }
3272 #endif
3274     UART_init();
3276     for (i = 0; ; i++)
3277     {
3278         if (Uart_tests[i].testFunc == NULL)
3279         {
3280             break;
3281         }
3282         UART_test_print_test_desc(&Uart_tests[i]);
3283         testResult = Uart_tests[i].testFunc(Uart_tests[i].dmaMode);
3284         UART_test_print_test_result(&Uart_tests[i], testResult);
3286         if (testResult == false)
3287         {
3288             break;
3289         }
3291     }
3293     UART_test_print_test_results(testResult);
3295     while (1)
3296     {
3297     }
3300 #if defined (USE_BIOS) || defined (FREERTOS)
3301 #define APP_TSK_STACK_MAIN              (16U * 1024U)
3302 static uint8_t  gAppTskStackMain[APP_TSK_STACK_MAIN] __attribute__((aligned(32)));
3303 /*
3304  *  ======== main ========
3305  */
3306 Int main()
3308     TaskP_Params taskParams;
3310         Uart_appC7xPreInit();
3312     if (Board_initUART() == false)
3313     {
3314         printf("\nBoard_initUART failed!\n");
3315         return(0);
3316     }
3318     /* Initialize the task params */
3319     TaskP_Params_init(&taskParams);
3320     /* Set the task priority higher than the default priority (1) */
3321     taskParams.priority =2;
3322     taskParams.stack        = gAppTskStackMain;
3323     taskParams.stacksize    = sizeof (gAppTskStackMain);
3325     TaskP_create(taskFxn, &taskParams);
3326     /* Start the scheduler to start the tasks executing. */
3327     OS_start();
3328     return(0);
3330 #endif /* #if defined (USE_BIOS) || defined (FREERTOS) */
3332 #ifdef UART_DMA_ENABLE
3333 #if !(defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X) || defined(SOC_TPR12) || defined (SOC_AWR294X))
3334 EDMA3_RM_Handle gEdmaHandle = NULL;
3336 /*
3337  * Initialize the edma driver and get the handle to the edma driver;
3338  */
3339 static EDMA3_RM_Handle UartApp_edmaInit(void)