f1537b8db54444aa51d35c40d0a53e842c565bd0
[processor-sdk/pdk.git] / packages / ti / drv / uart / test / src / main_uart_test.c
1 /**
2  * @file   main_test.c
3  *
4  * @brief  This file tests the UART driver APIs in Blocking mode.
5  */
6 /*
7  * Copyright (c) 2014 - 2018, Texas Instruments Incorporated
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * *  Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  *
17  * *  Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * *  Neither the name of Texas Instruments Incorporated nor the names of
22  *    its contributors may be used to endorse or promote products derived
23  *    from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
35  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  */
38 #include <stdio.h>
39 #include <string.h>
41 #ifdef USE_BIOS
42 /* XDCtools Header files */
43 #include <xdc/std.h>
44 #include <xdc/runtime/Error.h>
45 #include <xdc/runtime/System.h>
47 /* BIOS Header files */
48 #include <ti/sysbios/BIOS.h>
49 #include <ti/sysbios/knl/Task.h>
50 #endif /* #ifdef USE_BIOS */
52 /* CSL Header files */
53 #if defined(_TMS320C6X)
54 #include <ti/csl/csl_chip.h>
55 #endif
56 #include <ti/csl/soc.h>
57 #include <ti/csl/csl_types.h>
59 /* OSAL Header files */
60 #include <ti/osal/osal.h>
62 #if defined (USE_BIOS) || defined (FREERTOS)
63 #include <ti/osal/TaskP.h>
64 #endif
66 /* UART Header files */
67 #include <ti/drv/uart/UART.h>
68 #include <ti/drv/uart/UART_stdio.h>
69 #include <ti/drv/uart/src/UART_osal.h>
70 #include <ti/drv/uart/soc/UART_soc.h>
72 #include "UART_board.h"
74 #if defined(SOC_J721E) || defined(SOC_J7200)
75 #include <ti/csl/soc.h>
76 #endif
78 #if defined(SOC_J721E) || defined(SOC_AM65XX) || defined(SOC_J7200) || defined(SOC_AM64X)
79 #include <ti/drv/sciclient/sciclient.h>
80 #endif
82 #if defined(SOC_J721E) || defined(SOC_J7200)
83 #include <ti/csl/csl_clec.h>
84 #endif
86 #if defined (__C7100__)
87 #include <ti/csl/arch/csl_arch.h>
88 #endif
90 //#define CIO_DRV_CONSOLE
92 #ifdef CIO_DRV_CONSOLE
93 #define UART_test_log            printf
94 #define UART_test_log1           printf
95 #define UART_test_log2           printf
96 #define UART_test_log3           printf
97 #else
98 #define UART_test_log(x)
99 #define UART_test_log1(x,y)
100 #define UART_test_log2(x,y,z)
101 #define UART_test_log3(x,y,z,l)
102 #endif
105 #if defined(SOC_TPR12) || defined (SOC_AWR294X)
106 #if defined(SIM_BUILD)
107 #define UART_RX_LOOPBACK_ONLY
108 #endif
109 #define UART_API2_NOT_SUPPORTED
110 #define UART_NO_FIFO
111 #endif
113 void Uart_appC7xPreInit(void);
115 /* Define the UART test interface */
116 typedef struct UART_Tests_s
118     bool     (*testFunc)(bool);
119     bool     dmaMode;
120     int16_t  testId;
121     char     testDesc[80];
123 } UART_Tests;
125 /* UART test ID definitions */
126 #define UART_TEST_ID_DMA         0   /* UART DMA read write test in block mode */
127 #define UART_TEST_ID_INT         1   /* UART non-DMA read write test in block mode */
128 #define UART_TEST_ID_DMA_CB      2   /* UART DMA read write test in callback mode */
129 #define UART_TEST_ID_CB          3   /* UART non-DMA read write test in callback mode */
130 #define UART_TEST_ID_DMA_TO      4   /* UART DMA timeout test */
131 #define UART_TEST_ID_TO          5   /* UART non DMA timeout test */
132 #define UART_TEST_ID_DMA_RXERR   6   /* UART DMA RX error test */
133 #define UART_TEST_ID_RXERR       7   /* UART non-DMA RX error test */
134 #define UART_TEST_ID_DMA_CANCEL  8   /* UART DMA read write cancel test */
135 #define UART_TEST_ID_CANCEL      9   /* UART non-DMA read write cancel test */
136 #define UART_TEST_ID_DMA_RW      10  /* UART DMA simultaneous read write test */
137 #define UART_TEST_ID_RW          11  /* UART non-DMA simultaneous read write test */
138 #define UART_TEST_ID_DMA_TRGLVL  12  /* UART DMA TX/RX FIFO trigger level test */
139 #define UART_TEST_ID_PRINTF      13  /* UART stdio printf and scanf test */
140 #define UART_TEST_ID_TRGLVL      14  /* UART non-DMA TX/RX FIFO trigger level test */
141 #define UART_TEST_ID_POLL_TO     15  /* UART read write polling timeout test */
142 #define UART_TEST_ID_STDIOPARAMS 16  /* UART stdio printf and scanf test, with configurable params(Default params) */
143 #define UART_TEST_ID_INT_DISABLE 17  /* UART read write test with interrupt disabled */
144 #define UART_TEST_ID_RDVERIFY    18  /* UART non-DMA read API Test in loopback mode */
145 #define UART_TEST_ID_MULTI_INSTS 19  /* UART DMA multiple instances test in loopback mode */
146 #define UART_TEST_ID_API         20  /* UART API Test */
147 #define UART_TEST_ID_PROF_TX     21  /* UART non-DMA/DMA Blocking/Polling transmit polling */
148 #define UART_TEST_ID_DMA_LB_DATA 22  /* UART DMA data transfer test in loopback mode */
149 #define UART_TEST_ID_LB_DATA     23  /* UART non-DMA data transfer test in loopback mode */
151 /* Length of the input in number of characters */
152 #define UART_TEST_READ_LEN     (16U)
153 #define UART_RDVERIFY_READ_LEN (4U)
155 /* Timeout value of read and write */
156 #ifdef SIM_BUILD
157 #define UART_TEST_TIMEOUT      (50U)
158 #else
159 #define UART_TEST_TIMEOUT      (10000U)
160 #endif
162 /* Max number of instances to test in multiple instance test case */
163 #define UART_TEST_NUM_INSTS    (2U)
164 /* MAX Data Pattern Test Size for the Data Tests: */
165 #define MAX_TEST_BUFFER_SIZE   256
167 #if defined(CSL_CACHE_L2_LINESIZE)
168 #define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L2_LINESIZE
169 #elif defined(CSL_CACHE_L1D_LINESIZE)
170 #define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L1D_LINESIZE
171 #else
172 #define UART_TEST_CACHE_LINE_SIZE (128U)
173 #endif
175 char scanPrompt[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
176 char echoPrompt[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\n\r Data entered is as follows \r\n";
177 char dataPrint[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character \r\n";
178 char readTimeoutPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Read timed out \r\n";
179 char breakErrPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Received a break condition error \r\n";
180 char rdCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous read canceled \r\n";
181 char wrCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous write canceled \r\n";
182 char fifoTrgLvlData[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) =
183                         "0123456789112345678921234567893123456789412345678951234567896123456789712345678981234567899123456789"
184                         "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789abcedef12345"
185                         "6789ABCDEF012345678901234567899876543210deadbeef89512345";
186 char stdioPrint[64] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character and press ENTER \r\n";
188 UART_Transaction  callbackTransaction;
189 SemaphoreP_Handle callbackSem = NULL;
191 uint32_t uartTestInstance;
193 uint32_t verifyLoopback = FALSE;
195 uint32_t verifyRS485 = FALSE;
197 UART_PAR uartParity = UART_PAR_NONE;
199 /* Global Variable which holds the UART Handle */
200 UART_Handle     gUARTHandle = NULL;
202 #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
203 #ifdef UART_DMA_ENABLE
204 /*
205  * Ring parameters
206  */
207 /** \brief Number of ring entries - we can prime this much memcpy operations */
208 #define UDMA_TEST_APP_RING_ENTRIES      (1U)
209 /** \brief Size (in bytes) of each ring entry (Size of pointer - 64-bit) */
210 #define UDMA_TEST_APP_RING_ENTRY_SIZE   (sizeof(uint64_t))
211 /** \brief Total ring memory */
212 #define UDMA_TEST_APP_RING_MEM_SIZE     (UDMA_TEST_APP_RING_ENTRIES * \
213                                          UDMA_TEST_APP_RING_ENTRY_SIZE)
214 /** \brief This ensures every channel memory is aligned */
215 #define UDMA_TEST_APP_RING_MEM_SIZE_ALIGN ((UDMA_TEST_APP_RING_MEM_SIZE + UDMA_CACHELINE_ALIGNMENT) & ~(UDMA_CACHELINE_ALIGNMENT - 1U))
217 /**
218  *  \brief UDMA host mode buffer descriptor memory size.
219  *  Make it multiple of UART_TEST_CACHE_LINE_SIZE alignment
220  */
221 /** \brief UDMA host mode buffer descriptor memory size. */
222 #define UDMA_TEST_APP_DESC_SIZE         (sizeof(CSL_UdmapCppi5HMPD))
223 /** \brief This ensures every channel memory is aligned */
224 #define UDMA_TEST_APP_DESC_SIZE_ALIGN   ((UDMA_TEST_APP_DESC_SIZE + UDMA_CACHELINE_ALIGNMENT) & ~(UDMA_CACHELINE_ALIGNMENT - 1U))
226 /*
227  * UDMA driver objects
228  */
229 struct Udma_DrvObj      gUdmaDrvObj;
230 struct Udma_ChObj       gUdmaTxChObj;
231 struct Udma_ChObj       gUdmaRxChObj;
232 struct Udma_EventObj    gUdmaTxCqEventObj;
233 struct Udma_EventObj    gUdmaRxCqEventObj;
235 Udma_DrvHandle          gDrvHandle = NULL;
236 /*
237  * UDMA Memories
238  */
239 static uint8_t gTxRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
240 static uint8_t gTxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
241 static uint8_t gTdTxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
242 static uint8_t gUdmaTxHpdMem[UDMA_TEST_APP_DESC_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
243 static uint8_t gRxRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
244 static uint8_t gRxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
245 static uint8_t gTdRxCompRingMem[UDMA_TEST_APP_RING_MEM_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
246 static uint8_t gUdmaRxHpdMem[UDMA_TEST_APP_DESC_SIZE_ALIGN] __attribute__((aligned(UDMA_CACHELINE_ALIGNMENT)));
247 static UART_dmaInfo gUdmaInfo;
249 Udma_DrvHandle UartApp_udmaInit(UART_HwAttrs *cfg)
251     int32_t         retVal = UDMA_SOK;
252     Udma_InitPrms   initPrms;
253     uint32_t        instId;
255     if (gDrvHandle == NULL)
256     {
257         /* UDMA driver init */
258 #if defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM65XX)
259 #if defined (BUILD_MCU1_0) || defined (BUILD_MCU1_1)
260         instId = UDMA_INST_ID_MCU_0;
261 #else
262         instId = UDMA_INST_ID_MAIN_0;
263 #endif
264 #endif
266 #if defined(SOC_AM64X)
267         instId = UDMA_INST_ID_PKTDMA_0;
268 #endif
270         UdmaInitPrms_init(instId, &initPrms);
272         retVal = Udma_init(&gUdmaDrvObj, &initPrms);
273         if(UDMA_SOK == retVal)
274         {
275             gDrvHandle = &gUdmaDrvObj;
276         }
277     }
279     if(gDrvHandle != NULL)
280     {
281         gDrvHandle = &gUdmaDrvObj;
283         gUdmaInfo.txChHandle     = (void *)&gUdmaTxChObj;
284         gUdmaInfo.rxChHandle     = (void *)&gUdmaRxChObj;
285         gUdmaInfo.txRingMem      = (void *)&gTxRingMem[0];
286         gUdmaInfo.cqTxRingMem    = (void *)&gTxCompRingMem[0];
287         gUdmaInfo.tdCqTxRingMem  = (void *)&gTdTxCompRingMem[0];
288         gUdmaInfo.rxRingMem      = (void *)&gRxRingMem[0];
289         gUdmaInfo.cqRxRingMem    = (void *)&gRxCompRingMem[0];
290         gUdmaInfo.tdCqRxRingMem  = (void *)&gTdRxCompRingMem[0];
291         gUdmaInfo.txHpdMem       = (void *)&gUdmaTxHpdMem[0];
292         gUdmaInfo.rxHpdMem       = (void *)&gUdmaRxHpdMem[0];
293         gUdmaInfo.txEventHandle  = (void *)&gUdmaTxCqEventObj;
294         gUdmaInfo.rxEventHandle  = (void *)&gUdmaRxCqEventObj;
295         cfg->dmaInfo             = &gUdmaInfo;
296     }
298     return (gDrvHandle);
301 int32_t UART_udma_deinit(void)
303     int32_t         retVal = UDMA_SOK;
305     if (gDrvHandle != NULL)
306     {
307         retVal = Udma_deinit(gDrvHandle);
308         if(UDMA_SOK == retVal)
309         {
310             gDrvHandle = NULL;
311         }
312     }
314     return (retVal);
316 #endif
317 #endif /* #if defined(SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X) */
319 #if defined(SOC_AM64X) && defined(BUILD_MCU)
320 int32_t UART_configClk(uint32_t freq)
322     int32_t retVal = CSL_PASS;
323     uint64_t uartClk;
324     uint32_t parentID;
325     uint32_t clkID[] = {
326                            TISCI_DEV_UART0_FCLK_CLK,
327                            TISCI_DEV_UART1_FCLK_CLK,
328                            TISCI_DEV_UART2_FCLK_CLK,
329                            TISCI_DEV_UART3_FCLK_CLK,
330                            TISCI_DEV_UART4_FCLK_CLK,
331                            TISCI_DEV_UART5_FCLK_CLK,
332                            TISCI_DEV_UART6_FCLK_CLK,
333                        };
334     uint32_t modID[] = {
335                            TISCI_DEV_UART0,
336                            TISCI_DEV_UART1,
337                            TISCI_DEV_UART2,
338                            TISCI_DEV_UART3,
339                            TISCI_DEV_UART4,
340                            TISCI_DEV_UART5,
341                            TISCI_DEV_UART6,
342                        };
344     retVal = Sciclient_pmModuleClkRequest(modID[uartTestInstance],
345                                           clkID[uartTestInstance],
346                                           TISCI_MSG_VALUE_CLOCK_SW_STATE_REQ,
347                                           TISCI_MSG_FLAG_AOP,SCICLIENT_SERVICE_WAIT_FOREVER);
348     if (retVal == CSL_PASS)
349     {
350         if (freq == UART_MODULE_CLK_48M)
351         {
352             parentID = TISCI_DEV_UART0_FCLK_CLK_PARENT_USART_PROGRAMMABLE_CLOCK_DIVIDER_OUT0;
353         }
354         else
355         {
356             parentID = TISCI_DEV_UART0_FCLK_CLK_PARENT_HSDIV4_16FFT_MAIN_1_HSDIVOUT1_CLK;
357         }
358         retVal = Sciclient_pmSetModuleClkParent(modID[uartTestInstance],
359                                                 clkID[uartTestInstance],
360                                                 parentID,
361                                                 SCICLIENT_SERVICE_WAIT_FOREVER);
362     }
364     if (retVal == CSL_PASS)
365     {
366         uartClk = (uint64_t)freq;
367         retVal = Sciclient_pmSetModuleClkFreq(modID[uartTestInstance],
368                                               clkID[uartTestInstance],
369                                               uartClk,
370                                               TISCI_MSG_FLAG_AOP,
371                                               SCICLIENT_SERVICE_WAIT_FOREVER);
372     }
374     if (retVal == CSL_PASS)
375     {
376         uartClk = 0;
377         retVal = Sciclient_pmGetModuleClkFreq(modID[BOARD_OSPI_NOR_INSTANCE],
378                                               clkID[BOARD_OSPI_NOR_INSTANCE],
379                                               &uartClk,
380                                               SCICLIENT_SERVICE_WAIT_FOREVER);
381     }
383     if (retVal == CSL_PASS)
384     {
385         if ((uint32_t)uartClk != freq)
386         {
387             retVal = CSL_EFAIL;
388         }
389     }
391     return (retVal);
393 #endif
394 /*
395  *  ======== UART init config ========
396  */
397 static void UART_initConfig(bool dmaMode)
399     UART_HwAttrs uart_cfg;
401     /* Get the default UART init configurations */
402     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
404 #ifdef UART_DMA_ENABLE
405     if (dmaMode == true)
406     {
407 #if defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
408         uart_cfg.edmaHandle = UartApp_udmaInit(&uart_cfg);
409 #else
410         uart_cfg.edmaHandle = UartApp_edmaInit();
411     #if defined(SOC_TPR12) || defined (SOC_AWR294X)
412         uart_cfg.paramSetId = EDMA_NUM_DMA_CHANNELS;
413     #endif
414 #endif
415         uart_cfg.dmaMode    = TRUE;
416     }
417     else
418 #endif
419     {
420         uart_cfg.edmaHandle = NULL;
421         uart_cfg.dmaMode    = FALSE;
422     }
424     uart_cfg.loopback   = verifyLoopback;
425 #if defined(SOC_AM64X) && defined(BUILD_MCU)
426     if (verifyRS485 == TRUE)
427     {
428         uart_cfg.frequency = UART_MODULE_CLK_160M;
429     }
430     else
431     {
432         uart_cfg.frequency = UART_MODULE_CLK_48M;
433     }
434     uart_cfg.dirEnable = verifyRS485;
435     UART_configClk(uart_cfg.frequency);
436 #endif
438     /* Set the DMA enabled UART init configurations */
439     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
442 void UART_getTestInstNum(uint32_t *instNum, bool *boardAM570x)
444 #if defined (idkAM571x)
445     Board_STATUS  boardStatus;
446     Board_IDInfo  id;
447 #endif
449     *instNum = UART_INSTANCE;
450     *boardAM570x = false;
452 #if defined (idkAM571x)
453     boardStatus = Board_getIDInfo(&id);
454     if (boardStatus != BOARD_SOK)
455     {
456         return;
457     }
459     /* Check if is DRA (AM570x) SoC */
460     if ((id.boardName[0] == 'D') &&
461         (id.boardName[1] == 'R') &&
462         (id.boardName[2] == 'A'))
463     {
464         *boardAM570x = true;
465         *instNum = 0;
466     }
467 #endif
470 bool Board_initUART(void)
472     Board_initCfg boardCfg;
473     Board_STATUS  boardStatus;
474     bool          boardAM570x;
476 #if defined(evmK2E) || defined(evmC6678)
477     boardCfg = BOARD_INIT_MODULE_CLOCK;
478 #else
479     boardCfg = BOARD_INIT_PINMUX_CONFIG |
480         BOARD_INIT_MODULE_CLOCK;
481 #endif
483     boardStatus = Board_init(boardCfg);
484     if (boardStatus != BOARD_SOK)
485     {
486         return (false);
487     }
489     UART_getTestInstNum(&uartTestInstance, &boardAM570x);
491 /* --- TODO: move this into the board library --- */
492 /* For SYSBIOS only */
493 #ifndef BAREMETAL
494 #if defined (SOC_J721E)
495 /* set up C7x CLEC for DMTimer0 */
496 #if defined (BUILD_C7X_1)
497     CSL_ClecEventConfig   cfgClec;
498     CSL_CLEC_EVTRegs     *clecBaseAddr = (CSL_CLEC_EVTRegs *)CSL_COMPUTE_CLUSTER0_CLEC_REGS_BASE;
499     uint32_t input         = CSLR_COMPUTE_CLUSTER0_GIC500SS_SPI_TIMER0_INTR_PEND_0 + 992; /* Used for Timer Interrupt */
501     /* Configure CLEC for DMTimer0, SYS/BIOS uses interrupt 14 for DMTimer0 by default */
502     cfgClec.secureClaimEnable = FALSE;
503     cfgClec.evtSendEnable     = TRUE;
504     cfgClec.rtMap             = CSL_CLEC_RTMAP_CPU_ALL;
505     cfgClec.extEvtNum         = 0;
506     cfgClec.c7xEvtNum         = 14;
507     CSL_clecConfigEvent(clecBaseAddr, input, &cfgClec);
508 #endif /* for C7X cores */
510 /* set up C66x Interrupt Router for DMTimer0 for C66x */
511 #if defined (BUILD_DSP_1) || defined (BUILD_DSP_2)
512     int32_t                               retVal;
513     struct tisci_msg_rm_irq_set_req      rmIrqReq;
514     struct tisci_msg_rm_irq_set_resp     rmIrqResp;
515     int32_t                              dst_id;
517 #if defined (BUILD_DSP_1)
518     dst_id = TISCI_DEV_C66SS0_CORE0;
519 #endif
520 #if defined (BUILD_DSP_2)
521     dst_id = TISCI_DEV_C66SS1_CORE0;
522 #endif
524     /* Set up C66x interrupt router for DMTimer0 */
525     memset (&rmIrqReq, 0, sizeof(rmIrqReq));
526     rmIrqReq.secondary_host = TISCI_MSG_VALUE_RM_UNUSED_SECONDARY_HOST;
527     rmIrqReq.src_id = TISCI_DEV_TIMER0;
528     rmIrqReq.src_index = 0; /* set to 0 for non-event based interrupt */
530     /* Set the destination interrupt */
531     rmIrqReq.valid_params |= TISCI_MSG_VALUE_RM_DST_ID_VALID;
532     rmIrqReq.valid_params |= TISCI_MSG_VALUE_RM_DST_HOST_IRQ_VALID;
534     /* Set the destination based on the core */
535     rmIrqReq.dst_id       = dst_id;
536 /* rmIrqReq.dst_host_irq has to match the DMTimer.timerSettings[0].eventId defined in sysbios_c66.cfg */
537 #if defined (BUILD_DSP_1)
538     rmIrqReq.dst_host_irq = 21; /* DMSC dest event, input to C66x INTC  */
539 #endif
540 #if defined (BUILD_DSP_2)
541     rmIrqReq.dst_host_irq = 20; /* DMSC dest event, input to C66x INTC  */
542 #endif
544     /* Config event */
545     retVal = Sciclient_rmIrqSet(
546                 (const struct tisci_msg_rm_irq_set_req *)&rmIrqReq,
547                 &rmIrqResp,
548                 SCICLIENT_SERVICE_WAIT_FOREVER);
549     if(0U != retVal)
550     {
551        return (false);
552     }
553 #endif /* for C66X cores */
554 #endif /* for SOC_J721E || SOC_J7200 */
555 #endif /* for SYSBIOS */
556 /* --- TODO: move this into the board library --- */
558 #if defined (SOC_AM572x) || defined (SOC_AM571x) || defined (SOC_AM574x)
559     CSL_l4per_cm_core_componentRegs *l4PerCmReg =
560         (CSL_l4per_cm_core_componentRegs *) CSL_MPU_L4PER_CM_CORE_REGS;
562     if (boardAM570x)
563     {
564 #if defined (_TMS320C6X)
565         UART_HwAttrs cfg;
567         /*
568          * AM5 DSP does not have a default Xbar connection for UART
569          * interrupt, need the following Xbar interrupt configuration
570          */
572         /* Use reserved DSP1_IRQ_34 */
573         CSL_xbarDspIrqConfigure(1,
574                                 CSL_XBAR_INST_DSP1_IRQ_34,
575                                 CSL_XBAR_UART1_IRQ);
577         /* configure Xbar for UART2 instance */
578         CSL_xbarDspIrqConfigure(1,
579                                 CSL_XBAR_INST_DSP1_IRQ_35,
580                                 CSL_XBAR_UART2_IRQ);
581         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
582         cfg.eventId = 35;
583         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
584 #endif
586 #if defined(__TI_ARM_V7M4__)
587         UART_HwAttrs cfg;
589         /*
590          * AM571/AM570 IPU does not have a default Xbar connection for UART 1
591          * interrupt, need to use a reserved IRQ Xbar instance for Xbar interrupt
592          * configuration
593          */
595         /* Use reserved XBAR_INST_IPU1_IRQ_24 */
596         CSL_xbarIpuIrqConfigure(1,
597                                 CSL_XBAR_INST_IPU1_IRQ_24,
598                                 CSL_XBAR_UART1_IRQ);
600         /* configure Xbar for UART2 instance */
601         CSL_xbarIpuIrqConfigure(1,
602                                 CSL_XBAR_INST_IPU1_IRQ_25,
603                                 CSL_XBAR_UART2_IRQ);
604         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
605         cfg.intNum = 25;
606         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
607 #endif
609         /* enable UART2 clock */
610         CSL_FINST(l4PerCmReg->CM_L4PER_UART2_CLKCTRL_REG,
611                   L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_MODULEMODE,
612                   ENABLE);
614         while(CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_IDLEST_FUNC !=
615               CSL_FEXT(l4PerCmReg->CM_L4PER_UART2_CLKCTRL_REG,
616               L4PER_CM_CORE_COMPONENT_CM_L4PER_UART2_CLKCTRL_REG_IDLEST));
617     }
618     else
619     {
620 #if defined (_TMS320C6X)
621         UART_HwAttrs cfg;
623         CSL_xbarDspIrqConfigure(1,
624                                 CSL_XBAR_INST_DSP1_IRQ_34,
625                                 CSL_XBAR_UART3_IRQ);
627         /* configure Xbar for UART4 instance */
628         CSL_xbarDspIrqConfigure(1,
629                                 CSL_XBAR_INST_DSP1_IRQ_35,
630                                 CSL_XBAR_UART4_IRQ);
631         UART_socGetInitCfg(uartTestInstance + 1, &cfg);
632         cfg.eventId = 35;
633         UART_socSetInitCfg(uartTestInstance + 1, &cfg);
634 #endif
636 #if defined(__TI_ARM_V7M4__)
637         /*
638          * AM57x IPU does not have a default Xbar connection for UART 4
639          * interrupt, need to use a reserved IRQ Xbar instance for Xbar interrupt
640          * configuration
641          */
642         /* Use reserved XBAR_INST_IPU1_IRQ_24 */
643         CSL_xbarIpuIrqConfigure(1,
644                                 CSL_XBAR_INST_IPU1_IRQ_24,
645                                 CSL_XBAR_UART4_IRQ);
646 #endif
648         /* enable UART4 clock */
649         CSL_FINST(l4PerCmReg->CM_L4PER_UART4_CLKCTRL_REG,
650                   L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_MODULEMODE,
651                   ENABLE);
653         while(CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_IDLEST_FUNC !=
654               CSL_FEXT(l4PerCmReg->CM_L4PER_UART4_CLKCTRL_REG,
655               L4PER_CM_CORE_COMPONENT_CM_L4PER_UART4_CLKCTRL_REG_IDLEST));
656     }
657 #endif
659 #if defined (SOC_AM335X) || defined (SOC_AM437X)
660     /* enable UART clock */
661     PRCMModuleEnable(42U, uartTestInstance + 1U, 0U);
662 #endif
663     return (true);
666 /**
667  *  @b Description
668  *  @n
669  *      Utility function which converts a local GEM L2 memory address
670  *      to global memory address.
671  *
672  *  @param[in]  addr
673  *      Local address to be converted
674  *
675  *  @retval
676  *      Computed L2 global Address
677  */
678 static uintptr_t l2_global_address (uintptr_t addr)
680 #if defined(SOC_K2H) || defined(SOC_K2K) || defined(SOC_K2L) || defined(SOC_K2E) || defined(SOC_K2G) || defined(SOC_C6678) || defined(SOC_C6657) || \
681     defined(DEVICE_K2H) || defined(DEVICE_K2K) || defined(DEVICE_K2L) || defined(DEVICE_K2E) || defined(DEVICE_K2G) || defined(DEVICE_C6678) || defined(DEVICE_C6657)
682 #ifdef _TMS320C6X
683     uint32_t corenum;
685     /* Get the core number. */
686     corenum = CSL_chipReadReg (CSL_CHIP_DNUM);
688     /* Compute the global address. */
689     return (addr + (0x10000000 + (corenum * 0x1000000)));
690 #else
691     return addr;
692 #endif
693 #elif defined (SOC_TPR12) || defined (SOC_AWR294X)
694     return ((uintptr_t)CSL_locToGlobAddr(addr));
695 #else
696     return addr;
697 #endif
701 void UART_callback(UART_Handle handle, void *buf, size_t count)
703     UART_osalPostLock(callbackSem);
706 void UART_callback2(UART_Handle handle, UART_Transaction *transaction)
708     UART_osalPostLock(callbackSem);
711 #if !(defined(SOC_TPR12) || defined (SOC_AWR294X))
713 #define UART_NUM_TRIG_LVL           (4U)
715 /*
716  *  ======== UART_initConfigTrgLvl ========
717  */
718 static void UART_initConfigTrgLvl(uint32_t dmaMode,
719                                   uint32_t txTrigLvl,
720                                   uint32_t rxTrigLvl)
722     UART_HwAttrs uart_cfg;
724     /* Get the default UART init configurations */
725     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
727 #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) ||\
728     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)
729     uart_cfg.txTrigLvl  = txTrigLvl;
730 #else
731     uart_cfg.txTrigLvl  = (UART_TxTrigLvl)txTrigLvl;
732 #endif
733     uart_cfg.rxTrigLvl  = (UART_RxTrigLvl)rxTrigLvl;
734     uart_cfg.loopback   = TRUE;
735 #ifdef UART_DMA_ENABLE
736     if (dmaMode == true)
737     {
738 #if defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X)
739         uart_cfg.edmaHandle = UartApp_udmaInit(&uart_cfg);
740 #else
741         uart_cfg.edmaHandle = UartApp_edmaInit();
742 #endif
743         uart_cfg.dmaMode    = TRUE;
744     }
745     else
746 #endif
747     {
748         uart_cfg.edmaHandle = NULL;
749         uart_cfg.dmaMode    = FALSE;
750     }
752     /* Set the TX/RX FIFO trigger levels */
753     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
756 bool UART_test_trglvl_xfer(UART_Handle uart, uint32_t dmaMode, uint32_t xferSize)
758     SemaphoreP_Params semParams;
759     UART_Transaction  transaction;
760     uintptr_t          addrFifoTrgLvlData, addrScanPrompt;
761     uint32_t          i;
762     bool              ret = false;
764     if (xferSize == 0)
765     {
766         return true;
767     }
768     /* Create call back semaphore */
769     UART_osalSemParamsInit(&semParams);
770     semParams.mode = SemaphoreP_Mode_BINARY;
771     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
773     if (dmaMode)
774     {
775         addrFifoTrgLvlData = l2_global_address((uintptr_t)fifoTrgLvlData);
776         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
777     }
778     else
779     {
780         addrFifoTrgLvlData = (uintptr_t)fifoTrgLvlData;
781         addrScanPrompt = (uintptr_t)scanPrompt;
782     }
784     /* Read in call back mode */
785     memset(scanPrompt, 0, sizeof(scanPrompt));
786     if (dmaMode)
787     {
788         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
789     }
791     UART_transactionInit(&callbackTransaction);
792     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
793     callbackTransaction.count = xferSize;
794     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
795     {
796         goto Err;
797     }
799     /* Write in blocking mode */
800     UART_transactionInit(&transaction);
801     transaction.buf = (void *)(uintptr_t)addrFifoTrgLvlData;
802     transaction.count = xferSize;
803     if (UART_write2(uart, &transaction) == UART_ERROR)
804     {
805         goto Err;
806     }
808     /* Wait for read callback */
809     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
810     {
811         goto Err;
812     }
814     /* Check if read data matches with write data */
815     for (i = 0; i < xferSize; i++)
816     {
817         if (scanPrompt[i] != fifoTrgLvlData[i])
818         {
819             goto Err;
820         }
821     }
822     ret = true;
824 Err:
825     if (callbackSem)
826     {
827             UART_osalDeleteBlockingLock(callbackSem);
828             callbackSem = NULL;
829     }
830     return (ret);
833 bool UART_test_trglvl(uint32_t dmaMode,
834                       int32_t txTrigLvl,
835                       int32_t rxTrigLvl)
837     UART_Handle       uart = NULL;
838     UART_Params       uartParams;
839     bool              ret = false;
840     int32_t           i;
842     /* UART SoC init configuration */
843     UART_initConfigTrgLvl(dmaMode, (uint32_t)(uintptr_t)txTrigLvl, (uint32_t)(uintptr_t)rxTrigLvl);
845     /* Read in callback mode and write in blocking mode */
846     UART_Params_init(&uartParams);
847     uartParams.readCallback = UART_callback;
848     uartParams.readMode = UART_MODE_CALLBACK;
849     uartParams.parityType = uartParity;
851     for ( i = -1; i < 2; i++)
852     {
853         uart = UART_open(uartTestInstance, &uartParams);
854         if (uart == NULL)
855         {
856             goto Err;
857         }
858         if (UART_test_trglvl_xfer(uart, dmaMode, (uint32_t)(uintptr_t)(txTrigLvl + i)) == false)
859         {
860             goto Err;
861         }
862         if (uart)
863         {
864             UART_close(uart);
865             uart = NULL;
866         }
868         uart = UART_open(uartTestInstance, &uartParams);
869         if (uart == NULL)
870         {
871             goto Err;
872         }
874         if (UART_test_trglvl_xfer(uart, dmaMode, (uint32_t)(uintptr_t)(rxTrigLvl + i)) == false)
875         {
876             goto Err;
877         }
879         if (uart)
880         {
881             UART_close(uart);
882             uart = NULL;
883         }
884     }
886     ret = true;
888 Err:
889     if (uart)
890     {
891         UART_close(uart);
892     }
893     return (ret);
896 /*
897  *  ======== UART DMA TX/RX FIFO trigger level test ========
898  */
899 static bool UART_test_fifo_trglvl(bool dmaMode)
901     bool     ret = true;
902     uint32_t i;
903 #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)
904     UART_TxTrigLvl txTrgLvl[UART_NUM_TRIG_LVL] =
905     {
906         UART_TXTRIGLVL_8,
907         UART_TXTRIGLVL_16,
908         UART_TXTRIGLVL_32,
909         UART_TXTRIGLVL_56
910     };
912     UART_RxTrigLvl rxTrgLvl[UART_NUM_TRIG_LVL] =
913     {
914         UART_RXTRIGLVL_8,
915         UART_RXTRIGLVL_16,
916         UART_RXTRIGLVL_56,
917         UART_RXTRIGLVL_60
918     };
919 #else
920     uint32_t txTrgLvl[UART_NUM_TRIG_LVL] =
921     {
922         2,
923         4,
924         8,
925         16
926     };
928     UART_RxTrigLvl rxTrgLvl[UART_NUM_TRIG_LVL] =
929     {
930         UART_RXTRIGLVL_1,
931         UART_RXTRIGLVL_4,
932         UART_RXTRIGLVL_8,
933         UART_RXTRIGLVL_14
934     };
935 #endif
936     for (i = 0; i < UART_NUM_TRIG_LVL; i++)
937     {
938         if (UART_test_trglvl(dmaMode, (int32_t)txTrgLvl[i], (int32_t)rxTrgLvl[i]) == false)
939         {
940             ret = false;
941             break;
942         }
943     }
945     return (ret);
948 #endif /* TPR12: no UART fifo */
949 /*
950  *  ======== UART stdio printf/scanf test ========
951  *
952  *  The test function tests stdio driver printf/scanf APIs
953  */
954 static bool UART_test_printf_scanf(bool dmaMode)
956     bool    ret = false;
958     if (uartParity == UART_PAR_NONE)
959     {
960         /* UART SoC init configuration */
961         UART_initConfig(dmaMode);
963         UART_stdioInit(uartTestInstance);
965         UART_printf(stdioPrint);
967 #ifndef UART_RX_LOOPBACK_ONLY
968         memset(scanPrompt, 0, sizeof(scanPrompt));
969         if (UART_scanFmt(scanPrompt) != S_PASS)
970         {
971             goto Err;
972         }
973         ret = true;
975 Err:
976 #else
977         ret = true;
978 #endif
979         UART_stdioDeInit();
980     }
981     else
982     {
983         /*
984          * bypass this test if the parity is not the default setting
985          * (UART_PAR_NONE), since UART_stdioInit() only allows default
986          * UART parameter settings.
987          */
988         ret = true;
989     }
991     return (ret);
994 /*
995  *  ======== UART stdio printf/scanf test with param config (default) ========
996  *
997  *  The test function tests stdio driver printf/scanf APIs with default params config.
998  */
999 static bool UART_test_printf_scanf_stdio_params(bool dmaMode)
1001     bool    ret = false;
1002     UART_Params params;
1004     /* UART SoC init configuration */
1005     UART_initConfig(dmaMode);
1007     /* UART params */
1008     UART_Params_init(&params);
1009     params.parityType = uartParity;
1011     UART_stdioInit2(uartTestInstance,&params);
1013     UART_printf(stdioPrint);
1015     memset(scanPrompt, 0, sizeof(scanPrompt));
1016 #ifndef UART_RX_LOOPBACK_ONLY
1017     if (UART_scanFmt(scanPrompt) != S_PASS)
1018     {
1019         goto Err;
1020     }
1021     ret = true;
1023 Err:
1024 #else
1025     ret = true;
1026 #endif
1027     UART_stdioDeInit();
1028     return (ret);
1031 #if !defined(UART_API2_NOT_SUPPORTED)
1032 #ifdef USE_BIOS
1033 /* Use a global variable to sync the read task and the write task */
1034 volatile bool taskSyncFlag;
1035 Void UART_simultaneous_rw_write(UArg a0, UArg a1)
1037         UART_Handle      uart = (UART_Handle)a0;
1038         bool             dmaMode = (bool)a1;
1039     uintptr_t         addrDataPrint;
1040     UART_Transaction transaction;
1042         if (dmaMode)
1043     {
1044         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1045     }
1046     else
1047     {
1048         addrDataPrint = (uintptr_t)dataPrint;
1049     }
1051     UART_transactionInit(&transaction);
1053     while (taskSyncFlag == true)
1054         {
1055         transaction.buf = (void *)(uintptr_t)addrDataPrint;
1056             transaction.count = strlen(dataPrint);
1057             UART_write2(uart, &transaction);
1058             Osal_delay(100);
1059         }
1061     /* resume the read test task */
1062     taskSyncFlag = true;
1064     Task_exit ();
1067 /*
1068  *  ======== UART simultaneous read/write test ========
1069  *
1070  *  The read task creates a write task which will continuously
1071  *  writes the data out to the console, while at the same time
1072  *  the read task reads the data from the console input.
1073  *
1074  *  Note:
1075  *  In blocking/interrupt mode, if the write size is less than
1076  *  the TX FIFO size (64 bytes), the driver will just copy
1077  *  the write data to the TX FIFO and will not use interrupt
1078  *  and write semaphore. The read task should have a higher
1079  *  priority than the write task to resume the task by the
1080  *  scheduler once it gets the read semaphore.
1081  *
1082  */
1083 static bool UART_test_simultaneous_rw(bool dmaMode)
1085     UART_Handle      uart = NULL;
1086     UART_Params      uartParams;
1087     uintptr_t         addrScanPrompt, addrEchoPrompt;
1088     UART_Transaction transaction;
1089     Task_Handle      writeTask;
1090     Task_Params      writeTaskParams;
1091     Error_Block      eb;
1092     bool             ret = false;
1094     /* UART SoC init configuration */
1095     UART_initConfig(dmaMode);
1097     /* Initialize the default configuration params. */
1098     UART_Params_init(&uartParams);
1099     uartParams.parityType = uartParity;
1101     uart = UART_open(uartTestInstance, &uartParams);
1102     if (uart == NULL)
1103     {
1104         goto Err;
1105     }
1107     /* run the write teas when task is created */
1108     taskSyncFlag = true;
1110     Error_init(&eb);
1112     /* Initialize the task params */
1113     Task_Params_init(&writeTaskParams);
1114     writeTaskParams.arg0 = (UArg)uart;
1115     writeTaskParams.arg1 = (UArg)dmaMode;
1116 #if defined (__C7100__)
1117     writeTaskParams.stackSize = 1024*16;
1118 #else
1119     writeTaskParams.stackSize = 1024*8;
1120 #endif
1121     /*
1122      * Set the write task priority to the default priority (1)
1123      * lower than the read task priority (2)
1124      */
1125     writeTaskParams.priority = 1;
1127     /* Create the UART write task */
1128     writeTask = Task_create((Task_FuncPtr)UART_simultaneous_rw_write, &writeTaskParams, &eb);
1129     if (writeTask == NULL)
1130     {
1131         System_abort("Task create failed");
1132         goto Err;
1133     }
1135     if (dmaMode)
1136     {
1137         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1138         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1139     }
1140     else
1141     {
1142         addrScanPrompt = (uintptr_t)scanPrompt;
1143         addrEchoPrompt = (uintptr_t)echoPrompt;
1144     }
1146     memset(scanPrompt, 0, sizeof(scanPrompt));
1147     if (dmaMode)
1148     {
1149         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1150     }
1151     UART_transactionInit(&transaction);
1152     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1153     transaction.count = UART_TEST_READ_LEN;
1154     if (UART_read2(uart, &transaction) == UART_ERROR)
1155     {
1156         taskSyncFlag = false;
1157         goto Err;
1158     }
1159     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
1160         (transaction.count != UART_TEST_READ_LEN))
1161     {
1162         taskSyncFlag = false;
1163         goto Err;
1164     }
1166     /* stop the write test task */
1167     taskSyncFlag = false;
1169     /* Wait for the write task complete and exit */
1170     while (taskSyncFlag == false)
1171     {
1172         Osal_delay(100);
1173     }
1174     taskSyncFlag = false;
1176     UART_transactionInit(&transaction);
1177     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1178     transaction.count = strlen(echoPrompt);
1179     if (UART_write2(uart, &transaction) == UART_ERROR)
1180     {
1181         goto Err;
1182     }
1184     UART_transactionInit(&transaction);
1185     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1186     transaction.count = UART_TEST_READ_LEN;
1187     if (UART_write2(uart, &transaction) == UART_ERROR)
1188     {
1189         goto Err;
1190     }
1192     Osal_delay(5000);
1194     ret = true;
1196 Err:
1197     if (uart)
1198     {
1199         UART_close(uart);
1200     }
1202     return (ret);
1204 #endif
1205 #endif
1207 /*
1208  *  ======== UART read cancel test ========
1209  *
1210  *  The test function uses console intput to simulate/test the
1211  *  read cancel in callback mode. In a real use case, user can
1212  *  read a large file from the console and cancel the read before
1213  *  the read is complete.
1214  *
1215  */
1216 static bool UART_test_read_write_cancel(bool dmaMode)
1218     UART_Handle       uart = NULL;
1219     UART_Params       uartParams;
1220     SemaphoreP_Params semParams;
1221     UART_Transaction  transaction;
1222     uintptr_t          addrRdCancelPrompt, addrWrCancelPrompt;
1223     uintptr_t          addrDataPrint, addrEchoPrompt, addrScanPrompt;
1224     bool              ret = false;
1226     /* Create call back semaphore */
1227     UART_osalSemParamsInit(&semParams);
1228     semParams.mode = SemaphoreP_Mode_BINARY;
1229     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
1231     /* UART SoC init configuration */
1232     UART_initConfig(dmaMode);
1234     /* Set callback mode for read */
1235     UART_Params_init(&uartParams);
1236     uartParams.readCallback = UART_callback;
1237     uartParams.readMode = UART_MODE_CALLBACK;
1238     uartParams.parityType = uartParity;
1240     if (dmaMode)
1241     {
1242         addrRdCancelPrompt = l2_global_address((uintptr_t)rdCancelPrompt);
1243         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1244         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1245         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1246     }
1247     else
1248     {
1249         addrRdCancelPrompt = (uintptr_t)rdCancelPrompt;
1250         addrDataPrint = (uintptr_t)dataPrint;
1251         addrEchoPrompt = (uintptr_t)echoPrompt;
1252         addrScanPrompt = (uintptr_t)scanPrompt;
1253     }
1255     uart = UART_open(uartTestInstance, &uartParams);
1256     if (uart == NULL)
1257     {
1258         goto Err;
1259     }
1261     /* Test receive error */
1263     /* Perform the first read, which will be cancelled before completion */
1264     memset(scanPrompt, 0, sizeof(scanPrompt));
1265     if (dmaMode)
1266     {
1267         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1268     }
1270     UART_transactionInit(&callbackTransaction);
1271     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1272     callbackTransaction.count = UART_TEST_READ_LEN;
1273 #if !defined(UART_API2_NOT_SUPPORTED)
1274     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1275 #else
1276     if (UART_read(uart, callbackTransaction.buf, UART_TEST_READ_LEN) == UART_ERROR)
1277 #endif
1278     {
1279         goto Err;
1280     }
1281     /* Delay for 10 seconds to allow user to enter chars */
1282 #if !defined(SIM_BUILD)
1283     Osal_delay(10000);
1284 #else
1285     Osal_delay(100);
1286 #endif
1287     /* Cancel the read before the read transfer is completed */
1288     UART_readCancel(uart);
1289     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1290     {
1291         goto Err;
1292     }
1294     /* Print read cancelled prompt */
1295     UART_transactionInit(&transaction);
1296     transaction.buf = (void *)(uintptr_t)addrRdCancelPrompt;
1297     transaction.count = strlen(rdCancelPrompt);
1298 #if !defined(UART_API2_NOT_SUPPORTED)
1299     if (UART_write2(uart, &transaction) == UART_ERROR)
1300 #else
1301     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1302 #endif
1303     {
1304         goto Err;
1305     }
1307     UART_transactionInit(&transaction);
1308     transaction.buf = (void *)(uintptr_t)addrDataPrint;
1309     transaction.count = strlen(dataPrint);
1310 #if !defined(UART_API2_NOT_SUPPORTED)
1311     if (UART_write2(uart, &transaction) == UART_ERROR)
1312 #else
1313     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1314 #endif
1315     {
1316         goto Err;
1317     }
1319     /* Perform the 2nd read, which will be completed */
1320     memset(scanPrompt, 0, sizeof(scanPrompt));
1321     if (dmaMode)
1322     {
1323         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1324     }
1326 #if !defined(UART_RX_LOOPBACK_ONLY)
1327     UART_transactionInit(&callbackTransaction);
1328     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1329     callbackTransaction.count = UART_TEST_READ_LEN;
1330 #if !defined(UART_API2_NOT_SUPPORTED)
1331     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1332 #else
1333     if (UART_read(uart, callbackTransaction.buf, UART_TEST_READ_LEN) == UART_ERROR)
1334 #endif
1335     {
1336         goto Err;
1337     }
1338     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1339     {
1340         goto Err;
1341     }
1342 #endif
1343     UART_transactionInit(&transaction);
1344     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1345     transaction.count = strlen(echoPrompt);
1346 #if !defined(UART_API2_NOT_SUPPORTED)
1347     if (UART_write2(uart, &transaction) == UART_ERROR)
1348 #else
1349     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1350 #endif
1351     {
1352         goto Err;
1353     }
1355     /* Print the 2nd read chars, should NOT contain any chars
1356      * in the first cancelled read
1357      */
1358     UART_transactionInit(&transaction);
1359     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1360     transaction.count = sizeof(scanPrompt);
1361 #if !defined(UART_API2_NOT_SUPPORTED)
1362     if (UART_write2(uart, &transaction) == UART_ERROR)
1363 #else
1364     if (UART_write(uart, transaction.buf, transaction.count) == UART_ERROR)
1365 #endif
1366     {
1367         goto Err;
1368     }
1370     UART_close(uart);
1372     /* write cancel test */
1374     /* Set callback mode for write */
1375     UART_Params_init(&uartParams);
1376     uartParams.writeCallback = UART_callback;
1377     uartParams.writeMode = UART_MODE_CALLBACK;
1378     uartParams.parityType = uartParity;
1380     if (dmaMode)
1381     {
1382         addrWrCancelPrompt = l2_global_address((uintptr_t)wrCancelPrompt);
1383     }
1384     else
1385     {
1386         addrWrCancelPrompt = (uintptr_t)wrCancelPrompt;
1387     }
1389     uart = UART_open(uartTestInstance, &uartParams);
1390     if (uart == NULL)
1391     {
1392         goto Err;
1393     }
1395     /* Perform the 1st write */
1396     UART_transactionInit(&callbackTransaction);
1397     callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
1398     callbackTransaction.count = strlen(wrCancelPrompt);
1399 #if !defined(UART_API2_NOT_SUPPORTED)
1400     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1401 #else
1402     if (UART_write(uart, callbackTransaction.buf, callbackTransaction.count) == UART_ERROR)
1403 #endif
1404     {
1405         goto Err;
1406     }
1407     /* Cancel the 1st write */
1408     UART_writeCancel(uart);
1409     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1410     {
1411         goto Err;
1412     }
1414     /* Perform the 2nd write */
1415     UART_transactionInit(&callbackTransaction);
1416     callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
1417     callbackTransaction.count = strlen(wrCancelPrompt);
1418 #if !defined(UART_API2_NOT_SUPPORTED)
1419     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1420 #else
1421     if (UART_write(uart, callbackTransaction.buf, callbackTransaction.count) == UART_ERROR)
1422 #endif
1423     {
1424         goto Err;
1425     }
1426     /* Cancel the write */
1427     UART_writeCancel(uart);
1428     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1429     {
1430         goto Err;
1431     }
1432     ret = true;
1434 Err:
1435     if (uart)
1436     {
1437         UART_close(uart);
1438     }
1440     if (callbackSem)
1441     {
1442         UART_osalDeleteBlockingLock(callbackSem);
1443         callbackSem = NULL;
1444     }
1446     return (ret);
1449 #if !defined(UART_API2_NOT_SUPPORTED)
1450 /*
1451  *  ======== UART receive error test ========
1452  *
1453  *  The test function tests receive error (e.g. break condition)
1454  */
1455 static bool UART_test_rx_err(bool dmaMode)
1457     UART_Handle      uart = NULL;
1458     UART_Params      uartParams;
1459     UART_Transaction transaction;
1460     uintptr_t         addrScanPrompt, addrBreakErrPrompt;
1461     bool             ret = false;
1463     /* UART SoC init configuration */
1464     UART_initConfig(dmaMode);
1466     /* Initialize the default configuration params. */
1467     UART_Params_init(&uartParams);
1468     uartParams.parityType = uartParity;
1470     if (dmaMode)
1471     {
1472         addrBreakErrPrompt = l2_global_address((uintptr_t)breakErrPrompt);
1473         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1474     }
1475     else
1476     {
1477         addrBreakErrPrompt = (uintptr_t)breakErrPrompt;
1478         addrScanPrompt = (uintptr_t)scanPrompt;
1479     }
1481     uart = UART_open(uartTestInstance, &uartParams);
1482     if (uart == NULL)
1483     {
1484         goto Err;
1485     }
1487     /* Test receive error */
1488     memset(scanPrompt, 0, sizeof(scanPrompt));
1489     if (dmaMode)
1490     {
1491         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1492     }
1493     UART_transactionInit(&transaction);
1494     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
1495     transaction.count = UART_TEST_READ_LEN;
1496     if (UART_read2(uart, &transaction) == UART_ERROR)
1497     {
1498         if (transaction.status == UART_TRANSFER_STATUS_ERROR_BI)
1499         {
1500             UART_transactionInit(&transaction);
1501             transaction.buf = (void *)(uintptr_t)addrBreakErrPrompt;
1502             transaction.count = strlen(breakErrPrompt);
1503             if (UART_write2(uart, &transaction) == UART_ERROR)
1504             {
1505                 goto Err;
1506             }
1507         }
1508         else
1509         {
1510             goto Err;
1511         }
1512     }
1514     ret = true;
1516 Err:
1517     if (uart)
1518     {
1519         UART_close(uart);
1520     }
1522     return (ret);
1525 #endif
1527 /*
1528  *  ======== UART timeout test ========
1529  *
1530  *  The test function tests read/write with OS timeout
1531  */
1532 static bool UART_test_timeout(bool dmaMode)
1534     UART_Handle      uart = NULL;
1535     UART_Params      uartParams;
1536     UART_Transaction transaction;
1537     uintptr_t         addrScanPrompt, addrReadTimeoutPrompt;
1538     bool             ret = false;
1540     /* UART SoC init configuration */
1541     UART_initConfig(dmaMode);
1543     /* Initialize the default configuration params. */
1544     UART_Params_init(&uartParams);
1545     uartParams.parityType = uartParity;
1546     uartParams.readTimeout = UART_TEST_TIMEOUT;
1548     if (dmaMode)
1549     {
1550         addrReadTimeoutPrompt = l2_global_address((uintptr_t)readTimeoutPrompt);
1551         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1552     }
1553     else
1554     {
1555         addrReadTimeoutPrompt = (uintptr_t)readTimeoutPrompt;
1556         addrScanPrompt = (uintptr_t)scanPrompt;
1557     }
1559     uart = UART_open(uartTestInstance, &uartParams);
1560     if (uart == NULL)
1561     {
1562         goto Err;
1563     }
1565     /* Test read timeout */
1566     memset(scanPrompt, 0, sizeof(scanPrompt));
1567     if (dmaMode)
1568     {
1569         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1570     }
1571     UART_transactionInit(&transaction);
1572     transaction.buf = (void *)(uintptr_t)scanPrompt;
1573     transaction.count = UART_TEST_READ_LEN;
1574     transaction.timeout = UART_TEST_TIMEOUT;
1575 #if !defined(UART_API2_NOT_SUPPORTED)
1576     if (UART_read2(uart, &transaction) == UART_ERROR)
1577 #else
1578     if (UART_read(uart, transaction.buf, transaction.count) == UART_ERROR)
1579 #endif
1580     {
1581         UART_transactionInit(&transaction);
1582         transaction.buf = (void *)(uintptr_t)addrReadTimeoutPrompt;
1583         transaction.count = strlen(readTimeoutPrompt);
1584         transaction.timeout = UART_TEST_TIMEOUT;
1585         if (UART_write2(uart, &transaction) == UART_ERROR)
1586         {
1587             goto Err;
1588         }
1589     }
1591     ret = true;
1593 Err:
1594     if (uart)
1595     {
1596         UART_close(uart);
1597     }
1599     return (ret);
1602 /*
1603  *  ======== UART polling timeout test ========
1604  *
1605  *  The test function tests read/write with OS timeout in polling mode
1606  */
1607 static bool UART_test_polling_timeout(bool dmaMode)
1609     UART_Handle      uart = NULL;
1610     UART_Params      uartParams;
1611     bool             ret = false;
1612     uint32_t         rdSize = UART_TEST_READ_LEN;
1613     uint32_t         wrSize = strlen(readTimeoutPrompt);
1615     /* UART SoC init configuration */
1616     UART_initConfig(dmaMode);
1618     /* Initialize the default configuration params. */
1619     UART_Params_init(&uartParams);
1620     uartParams.parityType = uartParity;
1622     /* timeout is 0 for both read and write */
1623     uartParams.readTimeout  = UART_NO_WAIT;
1624     uartParams.writeTimeout = UART_NO_WAIT;
1625     uart = UART_open(uartTestInstance, &uartParams);
1626     if (uart == NULL)
1627     {
1628         goto Err;
1629     }
1631     memset(scanPrompt, 0, sizeof(scanPrompt));
1632     if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1633     {
1634         if (UART_writePolling(uart, (const void *)readTimeoutPrompt, wrSize) != wrSize)
1635         {
1636             ret = true;
1637         }
1638     }
1640     if (ret == true)
1641     {
1642         ret = false;
1644         UART_close(uart);
1646         /* timeout is 5 seconds for both read and write */
1647         uartParams.readTimeout  = UART_TEST_TIMEOUT;
1648         uartParams.writeTimeout = UART_TEST_TIMEOUT;
1649         uart = UART_open(uartTestInstance, &uartParams);
1650         if (uart == NULL)
1651         {
1652             goto Err;
1653         }
1655         /* Test read timeout */
1656         memset(scanPrompt, 0, sizeof(scanPrompt));
1657         if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1658         {
1659             UART_writePolling(uart, (const void *)readTimeoutPrompt, wrSize);
1660             ret = true;
1661         }
1662     }
1664     if (ret == true)
1665     {
1666         ret = false;
1668         UART_close(uart);
1670         /* timeout is 5 seconds for both read and write */
1671         uartParams.readTimeout  = UART_WAIT_FOREVER;
1672         uartParams.writeTimeout = UART_WAIT_FOREVER;
1673         uart = UART_open(uartTestInstance, &uartParams);
1674         if (uart == NULL)
1675         {
1676             goto Err;
1677         }
1679         wrSize = strlen(dataPrint);
1680         UART_writePolling(uart, (const void *)dataPrint, wrSize);
1682         memset(scanPrompt, 0, sizeof(scanPrompt));
1684 #if !defined(UART_RX_LOOPBACK_ONLY)
1685         if (UART_readPolling(uart, (void *)(uintptr_t)scanPrompt, rdSize) != rdSize)
1686         {
1687             goto Err;
1688         }
1689 #endif
1690         wrSize = strlen(echoPrompt);
1691         UART_writePolling(uart, (const void *)echoPrompt, wrSize);
1692         UART_writePolling(uart, (const void *)scanPrompt, rdSize);
1694         ret = true;
1695     }
1697 Err:
1698     if (uart)
1699     {
1700         UART_close(uart);
1701     }
1703     return (ret);
1706 /*
1707  *  ======== UART callback test ========
1708  *
1709  *  The test function tests the read/write in callback mode
1710  */
1711 static bool UART_test_callback(bool dmaMode)
1713     UART_Handle       uart = NULL;
1714     UART_Params       uartParams;
1715     SemaphoreP_Params semParams;
1716     uintptr_t          addrScanPrompt, addrDataPrint, addrEchoPrompt;
1717     bool              ret = false;
1719     /* Create call back semaphore */
1720     UART_osalSemParamsInit(&semParams);
1721     semParams.mode = SemaphoreP_Mode_BINARY;
1722     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
1724     /* Test read/write API's in callback mode */
1726     /* UART SoC init configuration */
1727     UART_initConfig(dmaMode);
1729     /* Set callback mode for both read and write */
1730     UART_Params_init(&uartParams);
1731     uartParams.readCallback = UART_callback;
1732     uartParams.readMode = UART_MODE_CALLBACK;
1733     uartParams.writeCallback = UART_callback;
1734     uartParams.writeMode = UART_MODE_CALLBACK;
1735     uartParams.parityType = uartParity;
1737     uart = UART_open(uartTestInstance, &uartParams);
1738     if (uart == NULL)
1739     {
1740         goto Err;
1741     }
1743     if (dmaMode)
1744     {
1745         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
1746         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
1747         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
1748     }
1749     else
1750     {
1751         addrScanPrompt = (uintptr_t)scanPrompt;
1752         addrDataPrint = (uintptr_t)dataPrint;
1753         addrEchoPrompt = (uintptr_t)echoPrompt;
1754     }
1756     /* Write DMA or non-DMA test prompt */
1757     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
1758     {
1759         goto Err;
1760     }
1761     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1762     {
1763         goto Err;
1764     }
1766     memset(scanPrompt, 0, sizeof(scanPrompt));
1767     if (dmaMode)
1768     {
1769         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1770     }
1772 #if !defined(UART_RX_LOOPBACK_ONLY)
1774     if (UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN) == UART_ERROR)
1775     {
1776         goto Err;
1777     }
1778     if (UART_osalPendLock(callbackSem, uartParams.readTimeout) != SemaphoreP_OK)
1779     {
1780         goto Err;
1781     }
1783 #endif
1785     if (UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt)) == UART_ERROR)
1786     {
1787         goto Err;
1788     }
1789     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1790     {
1791         goto Err;
1792     }
1794     if (UART_write(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN) == UART_ERROR)
1795     {
1796         goto Err;
1797     }
1798     if (UART_osalPendLock(callbackSem, uartParams.writeTimeout) != SemaphoreP_OK)
1799     {
1800         goto Err;
1801     }
1803     UART_close(uart);
1804     uart = NULL;
1806     /* Test read2/write2 API's in callback mode */
1807 #if !defined(UART_API2_NOT_SUPPORTED)
1808     uartParams.readCallback2 = UART_callback2;
1809     uartParams.writeCallback2 = UART_callback2;
1810     uartParams.readCallback = NULL;
1811     uartParams.writeCallback = NULL;
1813     uart = UART_open(uartTestInstance, &uartParams);
1814     if (uart == NULL)
1815     {
1816         goto Err;
1817     }
1819     UART_transactionInit(&callbackTransaction);
1820     callbackTransaction.buf = (void *)(uintptr_t)addrDataPrint;
1821     callbackTransaction.count = strlen(dataPrint);
1822     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1823     {
1824         goto Err;
1825     }
1826     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1827     {
1828         goto Err;
1829     }
1831     memset(scanPrompt, 0, sizeof(scanPrompt));
1832     if (dmaMode)
1833     {
1834         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
1835     }
1837 #if !defined(UART_RX_LOOPBACK_ONLY)
1838     UART_transactionInit(&callbackTransaction);
1839     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1840     callbackTransaction.count = UART_TEST_READ_LEN;
1841     if (UART_read2(uart, &callbackTransaction) == UART_ERROR)
1842     {
1843         goto Err;
1844     }
1845     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1846     {
1847         goto Err;
1848     }
1849 #endif
1851     UART_transactionInit(&callbackTransaction);
1852     callbackTransaction.buf = (void *)(uintptr_t)addrEchoPrompt;
1853     callbackTransaction.count = strlen(echoPrompt);
1854     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1855     {
1856         goto Err;
1857     }
1858     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1859     {
1860         goto Err;
1861     }
1863     UART_transactionInit(&callbackTransaction);
1864     callbackTransaction.buf = (void *)(uintptr_t)addrScanPrompt;
1865     callbackTransaction.count = UART_TEST_READ_LEN;
1866     if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
1867     {
1868         goto Err;
1869     }
1870     if (UART_osalPendLock(callbackSem, callbackTransaction.timeout) != SemaphoreP_OK)
1871     {
1872         goto Err;
1873     }
1875 #endif
1876     ret = true;
1878 Err:
1879     if (uart)
1880     {
1881         UART_close(uart);
1882     }
1883     if (callbackSem)
1884     {
1885         UART_osalDeleteBlockingLock(callbackSem);
1886         callbackSem = NULL;
1887     }
1888     return (ret);
1891 #if defined (SOC_AM64X) && defined(BUILD_MCU)
1892 /* RS-485 Direction Enable loopback test */
1893 static bool UART_test_rs485(bool dmaMode)
1895     UART_Handle      uart = NULL;
1896     UART_Params      uartParams;
1897     int16_t          length = 0;
1898     bool             ret = true;
1899     uint8_t rBuff[UART_TEST_READ_LEN], tBuff[]="aaaabbbbccccddddeeee";
1901     /* UART SoC init configuration */
1902     verifyRS485    = TRUE;
1903     verifyLoopback = TRUE;
1904     UART_initConfig(dmaMode);
1906     UART_Params_init(&uartParams);
1907     uart = UART_open(uartTestInstance, &uartParams);
1908     if (uart == NULL)
1909     {
1910         goto Err;
1911     }
1913     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
1914     {
1915         goto Err;
1916     }
1918     memset(rBuff, 0, UART_TEST_READ_LEN);
1919     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
1920     for(length=0; length<UART_TEST_READ_LEN; length++)
1921     {
1922         if(tBuff[length] != rBuff[length])
1923         {
1924             ret = false;
1925             break;
1926         }
1927     }
1928     UART_close(uart);
1930 Err:
1931     if (uart != NULL)
1932     {
1933         UART_close(uart);
1934     }
1936     verifyRS485    = FALSE;
1937     verifyLoopback = FALSE;
1938     return (ret);
1940 #endif
1942 /*
1943  *  ========== UART read API test ==========
1944  *
1945  *  The test function for UART_read API
1946  *  in loopback mode
1947  */
1948 static bool UART_test_read_verify(bool dmaMode)
1950     UART_Handle      uart = NULL;
1951     UART_Params      uartParams;
1952     int16_t          length = 0;
1953     bool             ret = false;
1954     uint8_t rBuff[UART_TEST_READ_LEN], tBuff[]="aaaabbbbccccddddeeee";
1955 #if defined(UART_NO_FIFO)
1956     int i;
1957 #endif
1959     verifyLoopback = TRUE;
1960     /* UART SoC init configuration */
1961     UART_initConfig(dmaMode);
1963     /* Initialize the default configuration params. */
1964     UART_Params_init(&uartParams);
1965     uartParams.parityType = uartParity;
1967     uart = UART_open(uartTestInstance, &uartParams);
1969     if (uart == NULL)
1970     {
1971         goto Err;
1972     }
1974 #if !defined(UART_NO_FIFO)
1976     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
1977     {
1978         goto Err;
1979     }
1981     length = UART_read(uart, (void *)&rBuff[0], UART_RDVERIFY_READ_LEN);
1983     if (UART_write(uart, (void *)&tBuff[15], UART_RDVERIFY_READ_LEN) == UART_ERROR)
1984     {
1985         goto Err;
1986     }
1988     length = UART_read(uart, (void *)&rBuff[4], UART_RDVERIFY_READ_LEN);
1989     length = UART_read(uart, (void *)&rBuff[8], UART_RDVERIFY_READ_LEN);
1990     length = UART_read(uart, (void *)&rBuff[12], UART_RDVERIFY_READ_LEN);
1991 #else
1992     memset(rBuff, 0, UART_TEST_READ_LEN);
1993     for (i =0; i < UART_TEST_READ_LEN;i++)
1994     {
1995         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
1996         {
1997             goto Err;
1998         }
2000         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2001     }
2003 #endif
2005     ret = true;
2006     for(length=0; length<UART_TEST_READ_LEN; length++)
2007     {
2008         if(tBuff[length] != rBuff[length])
2009         {
2010             ret = false;
2011             break;
2012         }
2013     }
2014     UART_close(uart);
2016     /* stop bit loopback test */
2017     UART_Params_init(&uartParams);
2018     uartParams.stopBits = UART_STOP_TWO;
2019     uart = UART_open(uartTestInstance, &uartParams);
2020     if (uart == NULL)
2021     {
2022         goto Err;
2023     }
2025 #if !defined(UART_NO_FIFO)
2026     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2027     {
2028         goto Err;
2029     }
2031     memset(rBuff, 0, UART_TEST_READ_LEN);
2032     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2033 #else
2034     memset(rBuff, 0, UART_TEST_READ_LEN);
2035     for (i =0; i < UART_TEST_READ_LEN;i++)
2036     {
2037         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2038         {
2039             goto Err;
2040         }
2042         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2043     }
2044 #endif
2045     for(length=0; length<UART_TEST_READ_LEN; length++)
2046     {
2047         if(tBuff[length] != rBuff[length])
2048         {
2049             ret = false;
2050             break;
2051         }
2052     }
2053     UART_close(uart);
2055     /* char length loopback test */
2056     UART_Params_init(&uartParams);
2057     uartParams.dataLength = UART_LEN_5;
2058     uart = UART_open(uartTestInstance, &uartParams);
2059     if (uart == NULL)
2060     {
2061         goto Err;
2062     }
2064 #if !defined(UART_NO_FIFO)
2065     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2066     {
2067         goto Err;
2068     }
2070     memset(rBuff, 0, UART_TEST_READ_LEN);
2071     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2072 #else
2073     memset(rBuff, 0, UART_TEST_READ_LEN);
2074     for (i =0; i < UART_TEST_READ_LEN;i++)
2075     {
2076         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2077         {
2078             goto Err;
2079         }
2081         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2082     }
2083 #endif
2084     for(length=0; length<UART_TEST_READ_LEN; length++)
2085     {
2086         if ((tBuff[length] & ((1 << (uartParams.dataLength + 5)) - 1)) != rBuff[length])
2087         {
2088             ret = false;
2089             break;
2090         }
2091     }
2092     UART_close(uart);
2094     /* parity loopback test */
2095     UART_Params_init(&uartParams);
2096     uartParams.parityType = UART_PAR_EVEN;
2097     uart = UART_open(uartTestInstance, &uartParams);
2098     if (uart == NULL)
2099     {
2100         goto Err;
2101     }
2102 #if !defined(UART_NO_FIFO)
2103     if (UART_write(uart, (void *)&tBuff[0], UART_TEST_READ_LEN) == UART_ERROR)
2104     {
2105         goto Err;
2106     }
2108     memset(rBuff, 0, UART_TEST_READ_LEN);
2109     UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
2110 #else
2111     memset(rBuff, 0, UART_TEST_READ_LEN);
2112     for (i =0; i < UART_TEST_READ_LEN;i++)
2113     {
2114         if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
2115         {
2116             goto Err;
2117         }
2119         length += UART_readPolling(uart, (void *)&rBuff[i], 1);
2120     }
2121 #endif
2122     for(length=0; length<UART_TEST_READ_LEN; length++)
2123     {
2124         if(tBuff[length] != rBuff[length])
2125         {
2126             ret = false;
2127             break;
2128         }
2129     }
2130     UART_close(uart);
2131     uart = NULL;
2133 #if defined (SOC_AM64X) && defined(BUILD_MCU)
2134     if (UART_test_rs485(dmaMode) == false)
2135     {
2136         ret = false;
2137     }
2138 #endif
2139 Err:
2140     if (uart != NULL)
2141     {
2142         UART_close(uart);
2143     }
2145     verifyLoopback = FALSE;
2146     return (ret);
2149 /*
2150  *  ======== UART read/write test ========
2151  *
2152  *  The test function tests read/write in blocking mode
2153  */
2154 static bool UART_test_read_write(bool dmaMode)
2156     UART_Handle      uart = NULL;
2157     UART_Params      uartParams;
2158     int              length = 0;
2159     uintptr_t        addrDataPrint, addrScanPrompt, addrEchoPrompt;
2160 #if !defined(UART_API2_NOT_SUPPORTED)
2161     UART_Transaction transaction;
2162 #endif
2163     bool             ret = false;
2165     /* UART SoC init configuration */
2166     UART_initConfig(dmaMode);
2168     /* Initialize the default configuration params. */
2169     UART_Params_init(&uartParams);
2170     uartParams.parityType = uartParity;
2172     uart = UART_open(uartTestInstance, &uartParams);
2174     if (uart == NULL)
2175     {
2176         goto Err;
2177     }
2179     if (dmaMode)
2180     {
2181         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
2182         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
2183         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
2184     }
2185     else
2186     {
2187         addrDataPrint = (uintptr_t)dataPrint;
2188         addrScanPrompt = (uintptr_t)scanPrompt;
2189         addrEchoPrompt = (uintptr_t)echoPrompt;
2190     }
2192     /* Test read/write API's in blocking mode */
2193     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
2194     {
2195         goto Err;
2196     }
2198     memset(scanPrompt, 0, sizeof(scanPrompt));
2199     if (dmaMode)
2200     {
2201         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2202     }
2203 #ifndef UART_RX_LOOPBACK_ONLY
2204     length = UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN);
2205     if (length != UART_TEST_READ_LEN)
2206     {
2207         goto Err;
2208     }
2209 #endif
2211     UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
2213     UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
2214     UART_close(uart);
2216 #if !defined(UART_API2_NOT_SUPPORTED)
2217     uart = UART_open(uartTestInstance, &uartParams);
2218     if (uart == NULL)
2219     {
2220         goto Err;
2221     }
2223     /* Test read2/write2 API's in blocking mode */
2224     UART_transactionInit(&transaction);
2225     transaction.buf = (void *)(uintptr_t)addrDataPrint;
2226     transaction.count = strlen(dataPrint);
2227     if (UART_write2(uart, &transaction) == UART_ERROR)
2228     {
2229         goto Err;
2230     }
2232     memset(scanPrompt, 0, sizeof(scanPrompt));
2233     if (dmaMode)
2234     {
2235         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2236     }
2237     UART_transactionInit(&transaction);
2238     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2239     transaction.count = UART_TEST_READ_LEN;
2240     if (UART_read2(uart, &transaction) == UART_ERROR)
2241     {
2242         goto Err;
2243     }
2244     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
2245         (transaction.count != UART_TEST_READ_LEN))
2246     {
2247         goto Err;
2248     }
2250     UART_transactionInit(&transaction);
2251     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
2252     transaction.count = strlen(echoPrompt);
2253     if (UART_write2(uart, &transaction) == UART_ERROR)
2254     {
2255         goto Err;
2256     }
2258     UART_transactionInit(&transaction);
2259     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2260     transaction.count = UART_TEST_READ_LEN;
2261     if (UART_write2(uart, &transaction) == UART_ERROR)
2262     {
2263         goto Err;
2264     }
2266 #else
2267     uart = NULL;
2268 #endif
2270     ret = true;
2272 Err:
2273     if (uart)
2274     {
2275         UART_close(uart);
2276     }
2278     return (ret);
2281 /*
2282  *  ======== UART read/write test with interrupt disabled ========
2283  *
2284  *  The test function tests read/write with interrupt disabled
2285  */
2286 static bool UART_test_read_write_int_disable(bool dmaMode)
2288     UART_Handle      uart = NULL;
2289     UART_Params      uartParams;
2290     int              length = 0;
2291     uintptr_t         addrDataPrint, addrScanPrompt, addrEchoPrompt;
2292     UART_Transaction transaction;
2293     bool             ret = false;
2294     UART_HwAttrs uart_cfg;
2296     /* UART SoC init configuration */
2297     UART_initConfig(dmaMode);
2299     /* Initialize the default configuration params. */
2300     UART_Params_init(&uartParams);
2301     uartParams.parityType = uartParity;
2303     /* Get the default UART init configurations */
2304     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
2306     uart_cfg.enableInterrupt=0; /* Disabling interrupt forcefully */
2308     /* Get the default UART init configurations */
2309     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
2311     uart = UART_open(uartTestInstance, &uartParams);
2313     if (uart == NULL)
2314     {
2315         goto Err;
2316     }
2318     if (dmaMode)
2319     {
2320         addrDataPrint = l2_global_address((uintptr_t)dataPrint);
2321         addrScanPrompt = l2_global_address((uintptr_t)scanPrompt);
2322         addrEchoPrompt = l2_global_address((uintptr_t)echoPrompt);
2323     }
2324     else
2325     {
2326         addrDataPrint = (uintptr_t)dataPrint;
2327         addrScanPrompt = (uintptr_t)scanPrompt;
2328         addrEchoPrompt = (uintptr_t)echoPrompt;
2329     }
2331     /* Test read/write API's in blocking mode */
2332     if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
2333     {
2334         goto Err;
2335     }
2337     memset(scanPrompt, 0, sizeof(scanPrompt));
2338     if (dmaMode)
2339     {
2340         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2341     }
2343 #if !defined(UART_RX_LOOPBACK_ONLY)
2344     length = UART_read(uart, (void *)(uintptr_t)addrScanPrompt, UART_TEST_READ_LEN);
2345     if (length != UART_TEST_READ_LEN)
2346     {
2347         goto Err;
2348     }
2349 #endif
2350     UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
2352     UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
2353     UART_close(uart);
2355     uart = UART_open(uartTestInstance, &uartParams);
2356     if (uart == NULL)
2357     {
2358         goto Err;
2359     }
2361 #if !defined(UART_API_NOT_SUPPORTED)
2362     /* Test read2/write2 API's in blocking mode */
2363     UART_transactionInit(&transaction);
2364     transaction.buf = (void *)(uintptr_t)addrDataPrint;
2365     transaction.count = strlen(dataPrint);
2366     if (UART_write2(uart, &transaction) == UART_ERROR)
2367     {
2368         goto Err;
2369     }
2371     memset(scanPrompt, 0, sizeof(scanPrompt));
2372     if (dmaMode)
2373     {
2374         CacheP_wbInv((void *)(uintptr_t)addrScanPrompt, (int32_t)sizeof(scanPrompt));
2375     }
2376     UART_transactionInit(&transaction);
2377     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2378     transaction.count = UART_TEST_READ_LEN;
2379     if (UART_read2(uart, &transaction) == UART_ERROR)
2380     {
2381         goto Err;
2382     }
2383     if ((transaction.status != UART_TRANSFER_STATUS_SUCCESS) ||
2384         (transaction.count != UART_TEST_READ_LEN))
2385     {
2386         goto Err;
2387     }
2389     UART_transactionInit(&transaction);
2390     transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
2391     transaction.count = strlen(echoPrompt);
2392     if (UART_write2(uart, &transaction) == UART_ERROR)
2393     {
2394         goto Err;
2395     }
2397     UART_transactionInit(&transaction);
2398     transaction.buf = (void *)(uintptr_t)addrScanPrompt;
2399     transaction.count = UART_TEST_READ_LEN;
2400     if (UART_write2(uart, &transaction) == UART_ERROR)
2401     {
2402         goto Err;
2403     }
2405 #endif
2406     ret = true;
2408 Err:
2409     if (uart)
2410     {
2411         UART_close(uart);
2412     }
2414     /* Get the default UART init configurations */
2415     UART_socGetInitCfg(uartTestInstance, &uart_cfg);
2416     uart_cfg.enableInterrupt=1; /* Re-enabling interrupt for the remaining the tests */
2417     /* Get the default UART init configurations */
2418     UART_socSetInitCfg(uartTestInstance, &uart_cfg);
2420     return (ret);
2423 #ifdef UART_DMA_ENABLE
2424 #if !(defined(SOC_TPR12) || defined (SOC_AWR294X))
2425 static uint32_t UART_getMaxNumInst(uint32_t numInst)
2427     uint32_t     i = 0;
2428 #if defined (SOC_AM572x) || defined (SOC_AM571x) || defined (SOC_AM574x) || defined (SOC_AM335X) || defined (SOC_AM437X)
2429     UART_HwAttrs uart_cfg;
2431     for (i = 0; i < numInst; i++)
2432     {
2433         memset(&uart_cfg, 0, sizeof(UART_HwAttrs));
2434         UART_socGetInitCfg(i, &uart_cfg);
2436         if (uart_cfg.baseAddr == 0)
2437         {
2438             break;
2439         }
2440     }
2441 #endif
2442     return (i);
2444 SemaphoreP_Handle MiCbSem[UART_TEST_NUM_INSTS] = {NULL, };
2445 UART_Handle       MiUartHandle[UART_TEST_NUM_INSTS] = {NULL, };
2446 void UART_miCallback(UART_Handle handle, void *buf, size_t count)
2448     uint32_t i;
2450     for (i = 0; i < UART_TEST_NUM_INSTS; i++)
2451     {
2452         if (MiUartHandle[i] == handle)
2453         {
2454             UART_osalPostLock(MiCbSem[i]);
2455             break;
2456         }
2457     }
2460 /*
2461  *  ========== UART multiple instances test ==========
2462  *
2463  *  The test function for UART read/write on multiple instances
2464  *  in loopback mode
2465  */
2466 #if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
2467 #pragma DATA_ALIGN (MiRxBuf, UART_TEST_CACHE_LINE_SIZE)
2468 char MiRxBuf[UART_TEST_NUM_INSTS][UART_TEST_CACHE_LINE_SIZE];
2469 #pragma DATA_ALIGN (MiTxBuf, UART_TEST_CACHE_LINE_SIZE)
2470 char MiTxBuf[UART_TEST_CACHE_LINE_SIZE];
2471 #else
2472 char MiRxBuf[UART_TEST_NUM_INSTS][UART_TEST_CACHE_LINE_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2473 char MiTxBuf[UART_TEST_CACHE_LINE_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2474 #endif
2476 static bool UART_test_multiple_instances(bool dmaMode)
2478     UART_Params       uartParams;
2479     bool              ret = false;
2480     uint32_t          i, j;
2481     uintptr_t          bufAddr;
2482     uint32_t          uartTestStartInst = uartTestInstance;
2483     uint32_t          numUartTestInstances;
2484     SemaphoreP_Params semParams;
2486     /* enable the loopback */
2487     verifyLoopback = TRUE;
2489     /* Get the max number of instances for testing */
2490     numUartTestInstances = UART_getMaxNumInst(UART_TEST_NUM_INSTS);
2492     for (i = 0; i < numUartTestInstances; i++)
2493     {
2494         /* UART SoC init configuration */
2495         UART_initConfig(dmaMode);
2497         /* Create call back semaphores */
2498         UART_osalSemParamsInit(&semParams);
2499         semParams.mode = SemaphoreP_Mode_BINARY;
2500         MiCbSem[i] = UART_osalCreateBlockingLock(0, &semParams);
2502         /* Set callback mode for read */
2503         UART_Params_init(&uartParams);
2504         uartParams.readCallback = UART_miCallback;
2505         uartParams.readMode = UART_MODE_CALLBACK;
2506         uartParams.parityType = uartParity;
2508         MiUartHandle[i] = UART_open(uartTestInstance, &uartParams);
2509         if (MiUartHandle[i] == NULL)
2510         {
2511             goto Err;
2512         }
2513         uartTestInstance++;
2514     }
2516     for (i = 0; i < numUartTestInstances; i++)
2517     {
2518         memset(MiRxBuf[i], 0, UART_TEST_CACHE_LINE_SIZE);
2519         if (dmaMode)
2520         {
2521             bufAddr = l2_global_address((uintptr_t)MiRxBuf[i]);
2522             CacheP_wbInv((void *)(uintptr_t)bufAddr, UART_TEST_CACHE_LINE_SIZE);
2523         }
2524         else
2525         {
2526             bufAddr = (uintptr_t)MiRxBuf[i];
2527         }
2529         UART_read(MiUartHandle[i], (void *)(uintptr_t)bufAddr, UART_TEST_READ_LEN);
2530     }
2532     for (i = 0; i < numUartTestInstances; i++)
2533     {
2534         for (j = 0; j < UART_TEST_READ_LEN; j++)
2535         {
2536             MiTxBuf[j] = fifoTrgLvlData[j] + (char)i;
2537         }
2538         if (dmaMode)
2539         {
2540             bufAddr = l2_global_address((uintptr_t)MiTxBuf);
2541             CacheP_wbInv((void *)(uintptr_t)bufAddr, UART_TEST_CACHE_LINE_SIZE);
2542         }
2543         else
2544         {
2545             bufAddr = (uintptr_t)MiTxBuf;
2546         }
2548         if (UART_write(MiUartHandle[i], (void *)(uintptr_t)bufAddr, UART_TEST_READ_LEN) == UART_ERROR)
2549         {
2550             goto Err;
2551         }
2552     }
2554     /* add delay for the read semaphore calback */
2555     Osal_delay(100);
2557     for (i = 0; i < numUartTestInstances; i++)
2558     {
2559         for (j = 0; j < UART_TEST_READ_LEN; j++)
2560         {
2561             if ((fifoTrgLvlData[j] + (char)i) != MiRxBuf[i][j])
2562             {
2563                 goto Err;
2564             }
2565         }
2566     }
2568     ret = true;
2570 Err:
2571     for (i = 0; i < numUartTestInstances; i++)
2572     {
2573         if (MiUartHandle[i] != NULL)
2574         {
2575             UART_close(MiUartHandle[i]);
2576             MiUartHandle[i] = NULL;
2577         }
2578     }
2580     verifyLoopback = FALSE;
2581     uartTestInstance = uartTestStartInst;
2582     return (ret);
2584 #endif /* if SOC_TPR12 */
2585 #endif /* if DMA */
2587 /**
2588  *  @b Description
2589  *  @n
2590  *      The function is used to test the UART Driver *WRITE* functions with
2591  *      various invalid arguments.
2592  *
2593  *  @param[in]  handle
2594  *      UART Handle
2595  *
2596  *  @retval
2597  *      Success -   0
2598  *  @retval
2599  *      Error   -   <0
2600  */
2601 static bool UART_writeInvalidArgs(UART_Handle handle)
2603     uint8_t     buffer[4];
2604     int32_t     status;
2606     /**************************************************************************
2607      * Test: Write with invalid buffer
2608      **************************************************************************/
2609     status = UART_write(handle, NULL, 128);
2610     if (status >= 0)
2611     {
2612         UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
2613         return false;
2614     }
2616     /**************************************************************************
2617      * Test: Write with invalid size
2618      **************************************************************************/
2619     status = UART_write(handle, &buffer[0], 0);
2620     if (status >= 0)
2621     {
2622         UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
2623         return false;
2624     }
2626     /**************************************************************************
2627      * Test: Write Polling with invalid buffer
2628      **************************************************************************/
2629     status = UART_writePolling(handle, NULL, 128);
2630     if (status >= 0)
2631     {
2632         UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
2633         return false;
2634     }
2636     /**************************************************************************
2637      * Test: Write Polling with invalid size
2638      **************************************************************************/
2639     status = UART_writePolling(handle, &buffer[0], 0);
2640     if (status >= 0)
2641     {
2642         UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
2643         return false;
2644     }
2646     return true;
2649 /**
2650  *  @b Description
2651  *  @n
2652  *      The function is used to test the UART Driver *READ* functions with
2653  *      various invalid arguments.
2654  *
2655  *  @param[in]  handle
2656  *      UART Handle
2657  *
2658  *  @retval
2659  *      Success -   0
2660  *  @retval
2661  *      Error   -   <0
2662  */
2663 static bool UART_readInvalidArgs(UART_Handle handle)
2665     uint8_t     buffer[4];
2666     int32_t     status;
2668     /**************************************************************************
2669      * Test: Read with invalid buffer
2670      **************************************************************************/
2671     status = UART_read(handle, NULL, 128);
2672     if (status != UART_EINVAL)
2673     {
2674         UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
2675         return false;
2676     }
2678     /**************************************************************************
2679      * Test: Read with invalid size
2680      **************************************************************************/
2681     status = UART_read(handle, &buffer[0], 0);
2682     if (status != UART_EINVAL)
2683     {
2684         UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
2685         return false;
2686     }
2688     /**************************************************************************
2689      * Test: Read Polling with invalid buffer
2690      **************************************************************************/
2691     status = UART_readPolling(handle, NULL, 128);
2692     if (status != UART_EINVAL)
2693     {
2694         UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
2695         return false;
2696     }
2698     /**************************************************************************
2699      * Test: Read Polling with invalid size
2700      **************************************************************************/
2701     status = UART_readPolling(handle, &buffer[0], 0);
2702     if (status != UART_EINVAL)
2703     {
2704         UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
2705         return false;
2706     }
2708     return true;
2711 /**
2712  *  @b Description
2713  *  @n
2714  *      The function is used to test the exported UART API.
2715  *
2716  *  @retval
2717  *      Success     -   0
2718  *  @retval
2719  *      Error       -   <0
2720  */
2721 bool UART_test_api (bool dmaMode)
2723     UART_Params     params;
2724     UART_Handle     handle;
2726     /* UART SoC init configuration */
2727     UART_initConfig(dmaMode);
2729     /* Setup the default UART Parameters */
2730     UART_Params_init(&params);
2732     /* Open the UART Instance */
2733     handle = UART_open(uartTestInstance, &params);
2734     if (handle == NULL)
2735     {
2736         UART_test_log("Error: Unable to open the UART Instance\n");
2737         return false;
2738     }
2739     /**************************************************************************
2740      * Test: Graceful shutdown
2741      **************************************************************************/
2742     UART_close(handle);
2744     /**************************************************************************
2745      * Test: Reopen the driver
2746      **************************************************************************/
2747     handle = UART_open(0, &params);
2748     if (handle == NULL)
2749     {
2750         UART_test_log("Error: Unable to open the UART Instance\n");
2751         return false;
2752     }
2754     /* Test: This will test the UART Write with Invalid arguments */
2755     if (!UART_writeInvalidArgs(handle))
2756         return false;
2758     /* Test: This will test the UART Read with Invalid arguments */
2759     if (!UART_readInvalidArgs(handle))
2760         return false;
2762     /* Close the driver: */
2763     UART_close(handle);
2764     return true;
2767 #if (defined(SOC_TPR12) || defined (SOC_AWR294X)) && defined(SIM_BUILD)
2769 /**
2770  *  @b Description
2771  *  @n
2772  *      The function is used to populate the *test* buffer with a predefined
2773  *      signature
2774  *
2775  *  @param[in]  ptrBuffer
2776  *      Buffer to be populated
2777  *  @param[in]  size
2778  *      Size of the buffer
2779  *
2780  *  @retval
2781  *      Not applicable
2782  */
2783 void UART_populateBuffer (char* ptrBuffer, uint32_t size)
2785     uint32_t index;
2786     char     ch = 'A';
2788     /* Populate the data buffer: */
2789     for (index = 0; index < size; index++)
2790     {
2791         *(ptrBuffer + index) = ch++;
2792         if (ch == ('Z'+1))
2793             ch = 'A';
2794     }
2795     return;
2798 /**
2799  *  @b Description
2800  *  @n
2801  *      The function is used to profile the UART Transmit API for
2802  *      comparison in DMA and Non-DMA mode
2803  *
2804  *  @retval
2805  *      Success -   0
2806  *  @retval
2807  *      Error   -   <0
2808  */
2809 #if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
2810 #pragma DATA_ALIGN (uartDataBuf, UART_TEST_CACHE_LINE_SIZE)
2811 char uartDataBuf[0x2000];
2812 #else
2813 char uartDataBuf[0x2000] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
2814 #endif
2816 bool UART_test_profile_tx(bool dmaMode)
2818     int32_t         status;
2819     UART_Params     params;
2820     UART_Handle     handle;
2821     int32_t         testIndex;
2822     int32_t         dataSizeIndex;
2823     uint32_t        dataSize[] = { 64, 256, 1024, 4096, 8192 };
2824     uint32_t        numDataSize = sizeof(dataSize)/sizeof(uint32_t);
2825     uint32_t        baudRate =  921600;
2826     uintptr_t       ptrTxData;
2827     uint32_t        txTimeTaken;
2828     UART_Stats      stats;
2829     char            testDescription[128];
2831 #if defined(SIM_BUILD)
2832     numDataSize = 3;
2833 #endif
2835     CycleprofilerP_init();
2837     /********************************************************************************
2838      * Execute the test for all data sizes
2839      ********************************************************************************/
2840     for (dataSizeIndex = 0; dataSizeIndex < numDataSize; dataSizeIndex++)
2841     {
2842         /********************************************************************************
2843          * For each data size we will run through the following:-
2844          * - Test Index 0: Non-DMA + Blocking Mode
2845          * - Test Index 1: DMA + Blocking Mode
2846          * - Test Index 2: Non-DMA + Polling Mode
2847          * - Test Index 3: DMA + Polling Mode
2848          ********************************************************************************/
2849         for (testIndex = 0; testIndex < 4; testIndex++)
2850         {
2852 #ifdef UART_DMA_ENABLE
2853             if(testIndex & 1)
2854             {
2855                 dmaMode = true;
2856                 ptrTxData = l2_global_address((uintptr_t)uartDataBuf);
2857             }
2858             else
2859 #endif
2860             {
2861                 dmaMode = false;
2862                 ptrTxData = (uintptr_t)uartDataBuf;
2863             }
2865             /* UART SoC init configuration */
2866             UART_initConfig(dmaMode);
2868             /*******************************************************************************
2869              * Initialization:
2870              *******************************************************************************/
2871             UART_Params_init(&params);
2872             params.readDataMode   = UART_DATA_BINARY;
2873             params.writeDataMode  = UART_DATA_BINARY;
2874             params.baudRate       = baudRate;
2875             params.readEcho       = UART_ECHO_OFF;
2877             /* Open the UART Instance: */
2878             handle = UART_open(uartTestInstance, &params);
2879             if (handle == NULL)
2880             {
2881                 UART_test_log ("Error: Unable to open the UART Driver while profiling Transmit Data\n");
2882                 return false;
2883             }
2885             /******************************************************************************
2886              * Debug Message:
2887              ******************************************************************************/
2888             switch (testIndex)
2889             {
2890                 case 0:
2891                 {
2892                     sprintf (testDescription, "UART %d Profile Test in Non-DMA Blocking Mode [Data Size %d bytes]",
2893                              uartTestInstance, dataSize[dataSizeIndex]);
2894                     break;
2895                 }
2896                 case 1:
2897                 {
2898                     sprintf (testDescription, "UART %d Profile Test in DMA Blocking Mode [Data Size %d bytes]",
2899                              uartTestInstance, dataSize[dataSizeIndex]);
2900                     break;
2901                 }
2902                 case 2:
2903                 {
2904                     sprintf (testDescription, "UART %d Profile Test in Non-DMA Polling Mode [Data Size %d bytes]",
2905                              uartTestInstance, dataSize[dataSizeIndex]);
2906                     break;
2907                 }
2908                 case 3:
2909                 {
2910                     sprintf (testDescription, "UART %d Profile Test in DMA Polling Mode [Data Size %d bytes]",
2911                              uartTestInstance, dataSize[dataSizeIndex]);
2912                     break;
2913                 }
2914                 default:
2915                 {
2916                     /* Control should never come here */
2917                     OSAL_Assert (!0);
2918                     return false;
2919                 }
2920             }
2922             /* Initialize the memory to be used: */
2923             memset ((void *)uartDataBuf, 0, dataSize[dataSizeIndex]);
2925             /* Populate the transmit buffer: */
2926             UART_populateBuffer (uartDataBuf, dataSize[dataSizeIndex]);
2928             if (dmaMode)
2929             {
2930                 CacheP_wbInv((void *)(uintptr_t)uartDataBuf, (int32_t)dataSize[dataSizeIndex]);
2931             }
2933             /****************************************************************
2934              * Profile the time taken to send out the data
2935              ****************************************************************/
2936             txTimeTaken = CycleprofilerP_getTimeStamp();
2938             if ((testIndex == 0) || (testIndex == 1))
2939                 status = UART_write(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
2940             else
2941                 status = UART_writePolling(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
2943             txTimeTaken = CycleprofilerP_getTimeStamp() - txTimeTaken;
2945             /* Were we able to send out the data */
2946             if (status != dataSize[dataSizeIndex])
2947             {
2948                 UART_test_log1 ("Error: Unable to send out the data [Status %d]\n", status);
2949                 UART_close(handle);
2950                 return false;
2951             }
2953             /* Get the UART Statistics: */
2954             if (UART_control (handle, UART_CMD_GET_STATS, &stats) < 0)
2955             {
2956                 UART_close(handle);
2957                 return false;
2958             }
2960             /* Debug Message: */
2961             UART_test_log ("Debug: Transmit Measurements\n");
2962             UART_test_log1 ("Debug: Baud Rate        : %d\n", baudRate);
2963             UART_test_log1 ("Debug: Data Size        : %d\n", dataSize[dataSizeIndex]);
2964             UART_test_log1 ("Debug: Transmit         : %d ticks\n", txTimeTaken);
2965             UART_test_log1 ("Debug: Tx Interrupt     : %d\n", stats.numTxInterrupts);
2966             UART_test_log1 ("Debug: Tx DMA Interrupt : %d\n", stats.numTxDMAInterrupts);
2968             /* Close the driver: */
2969             UART_close(handle);
2970         }
2971     }
2973     /********************************************************************************************
2974      * This is just a beautification; we have mucked around with the UART Console by dumping
2975      * all the data. So here we open a console and just put a banner to make it clean
2976      ********************************************************************************************/
2977     {
2978         char* ptrTestDelimitter = "\n\r*********************************************\n\r";
2980         UART_Params_init(&params);
2981         params.readDataMode   = UART_DATA_BINARY;
2982         params.writeDataMode  = UART_DATA_BINARY;
2983         params.baudRate       = baudRate;
2984         params.readEcho       = UART_ECHO_OFF;
2986         /* Open the UART Instance: */
2987         handle = UART_open(uartTestInstance, &params);
2988         if (!handle)
2989         {
2990             UART_test_log ("Error: Unable to open the UART Driver while printing the test banner\n");
2991             return false;
2992         }
2994         /* Write the banner on the console*/
2995         UART_writePolling (handle, (uint8_t*)ptrTestDelimitter, strlen(ptrTestDelimitter));
2996         UART_writePolling (handle, (uint8_t*)ptrTestDelimitter, strlen(ptrTestDelimitter));
2998         /* Close the driver: */
2999         UART_close(handle);
3000     }
3002     return true;
3004 #endif
3006 bool UART_test_loopback_data(bool dmaMode)
3008     bool              ret = false;
3009     UART_Handle       handle = NULL;
3010     UART_Params       params;
3011     SemaphoreP_Params semParams;
3012     int32_t           status;
3013     uintptr_t         pTxBuf;
3014     uintptr_t         pRxBuf;
3015     uint32_t          i;
3017     /* Create call back semaphore for read */
3018     UART_osalSemParamsInit(&semParams);
3019     semParams.mode = SemaphoreP_Mode_BINARY;
3020     callbackSem = UART_osalCreateBlockingLock(0, &semParams);
3022     /* enable the loopback */
3023     verifyLoopback = TRUE;
3025     /* UART SoC init configuration */
3026     UART_initConfig(dmaMode);
3028     /* Setup the read callback UART Parameters */
3029     UART_Params_init(&params);
3030     params.baudRate = 921600;
3031     params.readCallback = UART_callback;
3032     params.readMode = UART_MODE_CALLBACK;
3034     /* Open the UART Instance */
3035     handle = UART_open(uartTestInstance, &params);
3036     if (handle == NULL)
3037     {
3038         UART_test_log ("Error: Unable to open the UART Driver!\n");
3039         goto Err;
3040     }
3042     /* Reset the Rx buffer */
3043     memset(scanPrompt, 0, MAX_TEST_BUFFER_SIZE);
3045     if (dmaMode)
3046     {
3047         pTxBuf = l2_global_address((uintptr_t)fifoTrgLvlData);
3048         pRxBuf = l2_global_address((uintptr_t)scanPrompt);
3049         CacheP_wbInv((void *)(uintptr_t)scanPrompt, MAX_TEST_BUFFER_SIZE);
3050     }
3051     else
3052     {
3053         pTxBuf = (uintptr_t)fifoTrgLvlData;
3054         pRxBuf = (uintptr_t)scanPrompt;
3055     }
3057     /* RX in callback mode */
3058     status = UART_read(handle, (void *)pRxBuf, MAX_TEST_BUFFER_SIZE);
3059     if (status < 0)
3060     {
3061         UART_test_log1 ("Error: UART_read() return %d!\n", status);
3062         goto Err;
3063     }
3065     /* Send out the data */
3066     status = UART_write(handle, (void *)pTxBuf, MAX_TEST_BUFFER_SIZE);
3067     if (status < 0)
3068     {
3069         UART_test_log1 ("Error: UART_write() return %d!\n", status);
3070         goto Err;
3071     }
3073     /* Wait for RX call back */
3074     if ((status = UART_osalPendLock(callbackSem, params.writeTimeout)) != SemaphoreP_OK)
3075     {
3076         UART_test_log1 ("Error: UART_osalPendLock() return %d!\n", status);
3077         goto Err;
3078     }
3080     /* Check if read data matches with write data */
3081     for (i = 0; i < MAX_TEST_BUFFER_SIZE; i++)
3082     {
3083         if (scanPrompt[i] != fifoTrgLvlData[i])
3084         {
3085             UART_test_log3 ("Error: UART_test_loopback_data: data fails at index %d (%c != %c)\n", i, scanPrompt[i], fifoTrgLvlData[i]);
3086             goto Err;
3087         }
3088     }
3089     ret = true;
3091 Err:
3092     if (callbackSem != NULL)
3093     {
3094         UART_osalDeleteBlockingLock(callbackSem);
3095         callbackSem = NULL;
3096     }
3097     if (handle != NULL)
3098     {
3099         UART_close(handle);
3100     }
3102     verifyLoopback = FALSE;
3103     return (ret);
3106 UART_Tests Uart_tests[] =
3108 #ifdef UART_DMA_ENABLE
3109     {UART_test_read_write, true, UART_TEST_ID_DMA, "\r\n UART DMA read write test in block mode"},
3110 #endif
3111     {UART_test_read_write, false, UART_TEST_ID_INT, "\r\n UART non-DMA read write test in block mode"},
3112 #ifdef UART_DMA_ENABLE
3113     {UART_test_callback, true, UART_TEST_ID_DMA_CB, "\r\n UART DMA read write test in callback mode"},
3114 #endif
3115     {UART_test_callback, false, UART_TEST_ID_CB, "\r\n UART non-DMA read write test in callback mode"},
3116 #ifdef UART_DMA_ENABLE
3117     {UART_test_timeout, true, UART_TEST_ID_DMA_TO, "\r\n UART DMA timeout test, wait for 10 seconds to timeout read"},
3118 #endif
3119     {UART_test_timeout, false, UART_TEST_ID_TO, "\r\n UART non-DMA timeout test, wait for 10 seconds to timeout read"},
3120 #if !defined(UART_API2_NOT_SUPPORTED)
3121 #ifdef UART_DMA_ENABLE
3122     {UART_test_rx_err, true, UART_TEST_ID_DMA_RXERR, "\r\n UART DMA RX error test, enter a break"},
3123 #endif
3124     {UART_test_rx_err, false, UART_TEST_ID_RXERR, "\r\n UART non-DMA RX error test, enter a break"},
3125 #endif
3126 #ifdef UART_DMA_ENABLE
3127     {UART_test_read_write_cancel, true, UART_TEST_ID_DMA_CANCEL, "\r\n UART DMA read write cancel test, enter less than 16 chars"},
3128 #endif
3129     {UART_test_read_write_cancel, false, UART_TEST_ID_CANCEL, "\r\n UART non-DMA read write cancel test, enter less than 16 chars"},
3130 #ifdef USE_BIOS
3131 #if !defined(UART_API2_NOT_SUPPORTED)
3132 #ifdef UART_DMA_ENABLE
3133     {UART_test_simultaneous_rw, true, UART_TEST_ID_DMA_RW, "\r\n UART DMA simultaneous read write test "},
3134 #endif
3135     {UART_test_simultaneous_rw, false, UART_TEST_ID_RW, "\r\n UART non-DMA simultaneous read write test "},
3136 #endif
3137 #endif
3138 #if defined(UART_DMA_ENABLE)
3139 #if !defined(UART_NO_FIFO)
3140     {UART_test_fifo_trglvl, true, UART_TEST_ID_DMA_TRGLVL, "\r\n UART DMA TX/RX FIFO trigger level test "},
3141 #endif
3142 #endif
3143     {UART_test_printf_scanf, false, UART_TEST_ID_PRINTF, "\r\n UART stdio printf and scanf test "},
3144 #if !defined(UART_NO_FIFO)
3145     {UART_test_fifo_trglvl, false, UART_TEST_ID_TRGLVL, "\r\n UART non-DMA TX/RX FIFO trigger level test "},
3146 #endif
3147     {UART_test_polling_timeout, false, UART_TEST_ID_POLL_TO, "\r\n UART polling timeout test, wait for 10 seconds to timeout read"},
3148     {UART_test_printf_scanf_stdio_params, false, UART_TEST_ID_STDIOPARAMS, "\r\n UART stdio printf and scanf test with STDIO params(Default) "},
3149     {UART_test_read_write_int_disable, false, UART_TEST_ID_INT_DISABLE, "\r\n UART read write test with interrupt disabled"},
3150     {UART_test_read_verify, false, UART_TEST_ID_RDVERIFY, "\r\n UART non-DMA read API test in loopback mode"},
3151 #ifdef UART_DMA_ENABLE
3152 #if !(defined(SOC_TPR12) || defined (SOC_AWR294X))
3153     {UART_test_multiple_instances, true, UART_TEST_ID_MULTI_INSTS, "\r\n UART DMA multiple instances loopback test "},
3154 #endif
3155 #endif
3156     {UART_test_api, false, UART_TEST_ID_API, "\r\n UART API Test"},
3157 #if (defined(SOC_TPR12) || defined (SOC_AWR294X)) && defined(SIM_BUILD)
3158     {UART_test_profile_tx, false, UART_TEST_ID_PROF_TX, "\r\n UART non-DMA/DMA Blocking/Polling transmit profiling"},
3159 #endif
3160 #ifdef UART_DMA_ENABLE
3161     {UART_test_loopback_data, true, UART_TEST_ID_DMA_LB_DATA, "\r\n UART DMA read write test with loopback"},
3162 #endif
3163     {UART_test_loopback_data, false, UART_TEST_ID_LB_DATA, "\r\n UART non-DMA read write test with loopback"},
3164     {NULL, }
3165 };
3167 void UART_test_print_test_desc(UART_Tests *test)
3170 #if !defined(SIM_BUILD)
3171     UART_Handle uart = NULL;
3172     UART_Params uartParams;
3173     char        testIdPrompt[16] = "\r\n UART UT ";
3174         char        crPrompt[16] = "\r\n";
3175     char        testId[16] = {0, };
3177     /* UART SoC init configuration */
3178     UART_initConfig(false);
3180     /* Initialize the default configuration params. */
3181     UART_Params_init(&uartParams);
3182     uartParams.parityType = uartParity;
3183     uart = UART_open(uartTestInstance, &uartParams);
3185     /* Print unit test ID */
3186     sprintf(testId, "%d", test->testId);
3187     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3188     UART_write(uart, (void *)(uintptr_t)testIdPrompt, sizeof(testIdPrompt));
3189     UART_write(uart, (void *)(uintptr_t)testId, sizeof(testId));
3190     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3192     /* Print test description */
3193     UART_write(uart, (void *)(uintptr_t)test->testDesc, sizeof(test->testDesc));
3194     UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
3196     UART_close(uart);
3197 #else
3198     printf("UART UT %d: %s\n", test->testId, test->testDesc);
3199 #endif
3202 void UART_test_print_test_result(UART_Tests *test, bool pass)
3204 #if !defined(SIM_BUILD)
3205     UART_Handle uart = NULL;
3206     UART_Params uartParams;
3207     char        testIdPrompt[16] = "\r\n UART UT ";
3208     char        crPrompt[16] = "\r\n";
3209     char        testId[16] = {0, };
3210     char        resultPass[16] = " PASSED";
3211     char        resultFail[16] = " FAILED";
3213     /* UART SoC init configuration */
3214     UART_initConfig(false);
3216     /* Initialize the default configuration params. */
3217     UART_Params_init(&uartParams);
3218     uartParams.parityType = uartParity;
3219     uart = UART_open(uartTestInstance, &uartParams);
3221     /* Print unit test ID */
3222     sprintf(testId, "%d", test->testId);
3223     UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
3224     UART_write(uart, (void *)(uintptr_t)testIdPrompt, strlen(testIdPrompt));
3225     UART_write(uart, (void *)(uintptr_t)testId, strlen(testId));
3226     if (pass == true)
3227     {
3228         UART_write(uart, (void *)(uintptr_t)resultPass, strlen(resultPass));
3229     }
3230     else
3231     {
3232         UART_write(uart, (void *)(uintptr_t)resultFail, strlen(resultFail));
3233     }
3235     UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
3237     UART_close(uart);
3238 #else
3239     printf("UART UT %d: %s\n", test->testId, pass?"PASSED":"FAILED");
3240 #endif
3243 void UART_test_print_test_results(bool pass)
3245     const char  resultPass[32] = "\r\n All tests have passed. \r\n";
3246     const char  resultFail[32] = "\r\n Some tests have failed. \r\n";
3248 #if !defined(SIM_BUILD)
3250     /* UART SoC init configuration */
3251     UART_initConfig(false);
3253     UART_stdioInit(uartTestInstance);
3255     if (pass == true)
3256     {
3257         UART_printStatus(resultPass);
3258     }
3259     else
3260     {
3261         UART_printStatus(resultFail);
3262     }
3263     UART_stdioDeInit();
3264 #else
3265     printf("%s", pass?resultPass:resultFail);
3266 #endif
3269 #if defined (USE_BIOS) || defined (FREERTOS)
3270 /*
3271  *  ======== taskFxn ========
3272  */
3273 void taskFxn(void *a0, void *a1)
3274 #else
3275 int main(void)
3276 #endif /* #if defined (USE_BIOS) || defined (FREERTOS) */
3278     bool testResult = false;
3279     uint32_t i;
3281 #if !(defined(USE_BIOS) || defined(FREERTOS))
3282     if (Board_initUART() == false)
3283     {
3284         return(0);
3285     }
3286 #endif
3288     UART_init();
3290     for (i = 0; ; i++)
3291     {
3292         if (Uart_tests[i].testFunc == NULL)
3293         {
3294             break;
3295         }
3296         UART_test_print_test_desc(&Uart_tests[i]);
3297         testResult = Uart_tests[i].testFunc(Uart_tests[i].dmaMode);
3298         UART_test_print_test_result(&Uart_tests[i], testResult);
3300         if (testResult == false)
3301         {
3302             break;
3303         }
3305     }
3307     UART_test_print_test_results(testResult);
3309     while (1)
3310     {
3311     }
3314 #if defined (USE_BIOS) || defined (FREERTOS)
3315 #define APP_TSK_STACK_MAIN              (16U * 1024U)
3316 static uint8_t  gAppTskStackMain[APP_TSK_STACK_MAIN] __attribute__((aligned(32)));
3317 /*
3318  *  ======== main ========
3319  */
3320 Int main()
3322     TaskP_Params taskParams;
3324         Uart_appC7xPreInit();
3326     if (Board_initUART() == false)
3327     {
3328         printf("\nBoard_initUART failed!\n");
3329         return(0);
3330     }
3332     /* Initialize the task params */
3333     TaskP_Params_init(&taskParams);
3334     /* Set the task priority higher than the default priority (1) */
3335     taskParams.priority =2;
3336     taskParams.stack        = gAppTskStackMain;
3337     taskParams.stacksize    = sizeof (gAppTskStackMain);
3339     TaskP_create(taskFxn, &taskParams);
3340     /* Start the scheduler to start the tasks executing. */
3341     OS_start();
3342     return(0);
3344 #endif /* #if defined (USE_BIOS) || defined (FREERTOS) */
3346 #ifdef UART_DMA_ENABLE
3347 #if !(defined (SOC_AM65XX) || defined(SOC_J721E) || defined(SOC_J7200) || defined(SOC_AM64X) || defined(SOC_TPR12) || defined (SOC_AWR294X))
3348 EDMA3_RM_Handle gEdmaHandle = NULL;
3350 /*
3351  * Initialize the edma driver and get the handle to the edma driver;
3352  */
3353 static EDMA3_RM_Handle UartApp_edmaInit(void)
3355     EDMA3_DRV_Result edmaResult = EDMA3_DRV_E_INVALID_PARAM;
3356     uint32_t edma3Id;
3358 #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) ||\
3359     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)
3360     uint32_t edmaEvent[2], i, chnMapping, chnMappingIdx;
3362     /* For Keystone devices, edm3Id is UART instance and SoC specific */
3363     UART_getEdmaInfo(uartTestInstance, &edma3Id, edmaEvent);
3365     /* Set the RX/TX ownDmaChannels and dmaChannelHwEvtMap */
3366     for (i = 0; i < 2; i++)
3367     {
3368         chnMapping = edmaEvent[i];
3369         if (chnMapping < 32)
3370             chnMappingIdx = 0;
3371         else
3372         {
3373             chnMapping -= 32;
3374             chnMappingIdx = 1;
3375         }
3376         sampleInstInitConfig[edma3Id][0].ownDmaChannels[chnMappingIdx] |= (1 << chnMapping);
3377         sampleInstInitConfig[edma3Id][0].ownTccs[chnMappingIdx] |= (1 << chnMapping);
3378         sampleInstInitConfig[edma3Id][0].ownPaRAMSets[chnMappingIdx] |= (1 << chnMapping);
3379         sampleEdma3GblCfgParams[edma3Id].dmaChannelHwEvtMap[chnMappingIdx] |= (1 << chnMapping);
3380     }
3381 #endif
3383     if (gEdmaHandle != NULL)
3384     {
3385         return(gEdmaHandle);
3386     }
3388 #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)
3389     edma3Id = 0;
3390 #endif
3391     gEdmaHandle = (EDMA3_RM_Handle)edma3init(edma3Id, &edmaResult);
3392 #ifdef USE_BIOS
3393     if (edmaResult != EDMA3_DRV_SOK)
3394     {
3395         /* Report EDMA Error */
3396         System_printf("\nEDMA driver initialization FAIL\n");
3397     }
3398     else
3399     {
3400         System_printf("\nEDMA driver initialization PASS.\n");
3401     }
3402 #endif
3403     return(gEdmaHandle);
3405 #endif
3406 #if defined(SOC_TPR12) || defined (SOC_AWR294X)
3407 EDMA_Handle gEdmaHandle = NULL;
3409 #ifdef BUILD_MCU
3410 #define UART_EDMA_INSTANCE_ID   EDMA_DRV_INST_MSS_A
3411 #else
3412 #define UART_EDMA_INSTANCE_ID   EDMA_DRV_INST_DSS_B
3413 #endif
3415 uint32_t UART_edmaErrCount = 0;
3416 uint32_t UART_edmaTCErrCount = 0;
3418 void Test_edmaErrorCallbackFxn(EDMA_Handle handle, EDMA_errorInfo_t *errorInfo)
3420     //OSAL_Assert(true);
3421     UART_edmaErrCount++;
3422     #if 0
3423     printf("edmaError:isOutstandingTransferCompletionTransfersExceededLimit:%d\n",
3424             errorInfo->isOutstandingTransferCompletionTransfersExceededLimit);
3425     #endif
3428 void Test_edmaTransferControllerErrorCallbackFxn
3430     EDMA_Handle                         handle,
3431     EDMA_transferControllerErrorInfo_t* errorInfo
3434     //OSAL_Assert(true);
3435     UART_edmaTCErrCount++;
3436     #if 0
3437     printf("edmaTransferControllerError:ReqErr:%d, RsvdMemErr:%d, BusErr:%d, errCode:%d, tcc:%d\n",
3438             errorInfo->isTransferRequestError,
3439             errorInfo->isWriteToReservedConfigMemoryMap,
3440             errorInfo->isBusError,
3441             errorInfo->busErrorInfo.errorCode,
3442             errorInfo->busErrorInfo.transferCompletionCode);
3443     #endif
3446 /*
3447  * Initialize the edma driver and get the handle to the edma driver;
3448  */
3449 static EDMA_Handle UartApp_edmaInit(void)
3451     EDMA_errorConfig_t  errorConfig;
3452     EDMA_instanceInfo_t instanceInfo;
3453     EDMA3CCInitParams   initParam;
3454     uint32_t            edmaInstId = UART_EDMA_INSTANCE_ID;
3455     int32_t             errCode;
3457     if (gEdmaHandle != NULL)
3458     {
3459         return(gEdmaHandle);
3460     }
3462     if (uartTestInstance == 2)
3463     {
3464         /* UART Instance 2 uses DSS EDMA instance B */
3465         edmaInstId = EDMA_DRV_INST_DSS_B;
3466     }
3468     /* Initialize the UART edma instance */
3469     EDMA3CCInitParams_init(&initParam);
3470     initParam.initParamSet = TRUE;
3471     errCode = EDMA_init(edmaInstId, &initParam);
3472     if (errCode != EDMA_NO_ERROR)
3473     {
3474         printf("Error: Unable to initialize EDMA, errorCode = %d\n", errCode);
3475         return NULL;
3476     }
3478     /* Open the UART edma Instance */
3479     gEdmaHandle = EDMA_open(edmaInstId, &errCode, &instanceInfo);
3480     if (gEdmaHandle == NULL)
3481     {
3482         printf("Error: Unable to open the edma Instance(%d), erorCode = %d\n",
3483                       UART_EDMA_INSTANCE_ID, errCode);
3484         return NULL;
3485     }
3487     /* Setup the EDMA Error Monitoring: */
3488     errorConfig.isConfigAllEventQueues              = true;
3489     errorConfig.isConfigAllTransferControllers      = true;
3490     errorConfig.isEventQueueThresholdingEnabled     = true;
3491     errorConfig.eventQueueThreshold                 = EDMA_EVENT_QUEUE_THRESHOLD_MAX;
3492     errorConfig.isEnableAllTransferControllerErrors = true;
3493     errorConfig.callbackFxn                         = Test_edmaErrorCallbackFxn;
3494     errorConfig.transferControllerCallbackFxn       = Test_edmaTransferControllerErrorCallbackFxn;
3495     errCode = EDMA_configErrorMonitoring(gEdmaHandle, &errorConfig);
3496     if (errCode != EDMA_NO_ERROR)
3497     {
3498         printf("Debug: EDMA_configErrorMonitoring() failed with errorCode = %d\n", errCode);
3499         //return NULL;
3500     }
3502     return(gEdmaHandle);
3504 #endif /* SOC_TPR12 */
3505 #endif
3507 #if defined(BUILD_MPU) || defined (__C7100__)
3508 extern void Osal_initMmuDefault(void);
3509 void InitMmu(void)
3511     Osal_initMmuDefault();
3513 #endif
3515 void Uart_appC7xPreInit(void)
3517 #if defined (__C7100__) && !defined (SOC_J7200)
3518     CSL_ClecEventConfig cfgClec;
3519         CSL_CLEC_EVTRegs   *clecBaseAddr = (CSL_CLEC_EVTRegs*) CSL_COMPUTE_CLUSTER0_CLEC_REGS_BASE;
3521     uint32_t            i, maxInputs = 2048U;
3523     /* make secure claim bit to FALSE so that after we switch to non-secure mode
3524      * we can program the CLEC MMRs
3525      */
3526     cfgClec.secureClaimEnable = FALSE;
3527     cfgClec.evtSendEnable     = FALSE;
3528     cfgClec.rtMap             = CSL_CLEC_RTMAP_DISABLE;
3529     cfgClec.extEvtNum         = 0U;
3530     cfgClec.c7xEvtNum         = 0U;
3531     for(i = 0U; i < maxInputs; i++)
3532     {
3533         CSL_clecConfigEvent(clecBaseAddr, i, &cfgClec);
3534     }
3535 #endif
3537     return;