diff --git a/packages/ti/drv/uart/test/src/main_uart_test.c b/packages/ti/drv/uart/test/src/main_uart_test.c
index 372585c81ef483ac41074cbb018a6f329882c07a..3d1c7d8ef81ad4f8cfdcc64227737b561dc75868 100644 (file)
#include <ti/csl/arch/csl_arch.h>
#endif
+//#define CIO_DRV_CONSOLE
+
+#ifdef CIO_DRV_CONSOLE
+#define UART_test_log printf
+#define UART_test_log1 printf
+#define UART_test_log2 printf
+#define UART_test_log3 printf
+#else
+#define UART_test_log(x)
+#define UART_test_log1(x,y)
+#define UART_test_log2(x,y,z)
+#define UART_test_log3(x,y,z,l)
+#endif
+
+
#if defined(SOC_TPR12)
-#define QT_BUILD
+#if defined(SIM_BUILD)
#define UART_RX_LOOPBACK_ONLY
+#endif
#define UART_API2_NOT_SUPPORTED
#define UART_NO_FIFO
-//#define UART_RW_INT_ONLY
#endif
void Uart_appC7xPreInit(void);
#define UART_RDVERIFY_READ_LEN (4U)
/* Timeout value of read and write */
-#ifdef QT_BUILD
+#ifdef SIM_BUILD
#define UART_TEST_TIMEOUT (50U)
#else
-#define UART_TEST_TIMEOUT (5000U)
+#define UART_TEST_TIMEOUT (10000U)
#endif
/* Max number of instances to test in multiple instance test case */
/* MAX Data Pattern Test Size for the Data Tests: */
#define MAX_TEST_BUFFER_SIZE 256
-#define UART_TEST_CACHE_LINE_SIZE (128U)
-#if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
-#pragma DATA_ALIGN (scanPrompt, UART_TEST_CACHE_LINE_SIZE)
-char scanPrompt[MAX_TEST_BUFFER_SIZE];
+#if defined(CSL_CACHE_L2_LINESIZE)
+#define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L2_LINESIZE
+#elif defined(CSL_CACHE_L1D_LINESIZE)
+#define UART_TEST_CACHE_LINE_SIZE CSL_CACHE_L1D_LINESIZE
#else
-char scanPrompt[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
+#define UART_TEST_CACHE_LINE_SIZE (128U)
#endif
-char echoPrompt[40] = "\n\r Data entered is as follows \r\n";
-char dataPrint[40] = "\r\n enter the data of 16 character \r\n";
-char readTimeoutPrompt[60] = "\r\n Read timed out \r\n";
-char breakErrPrompt[60] = "\r\n Received a break condition error \r\n";
-char rdCancelPrompt[60] = "\r\n Previous read canceled \r\n";
-char wrCancelPrompt[60] = "\r\n Previous write canceled \r\n";
-char fifoTrgLvlData[MAX_TEST_BUFFER_SIZE] = "0123456789112345678921234567893123456789412345678951234567896123456789712345678981234567899123456789";
-char stdioPrint[64] = "\r\n enter the data of 16 character and press ENTER \r\n";
+char scanPrompt[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
+char echoPrompt[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\n\r Data entered is as follows \r\n";
+char dataPrint[40] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character \r\n";
+char readTimeoutPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Read timed out \r\n";
+char breakErrPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Received a break condition error \r\n";
+char rdCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous read canceled \r\n";
+char wrCancelPrompt[60] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n Previous write canceled \r\n";
+char fifoTrgLvlData[MAX_TEST_BUFFER_SIZE] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) =
+ "0123456789112345678921234567893123456789412345678951234567896123456789712345678981234567899123456789"
+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789abcedef12345"
+ "6789ABCDEF012345678901234567899876543210deadbeef89512345";
+char stdioPrint[64] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE))) = "\r\n enter the data of 16 character and press ENTER \r\n";
UART_Transaction callbackTransaction;
SemaphoreP_Handle callbackSem = NULL;
#endif
UdmaInitPrms_init(instId, &initPrms);
-#if defined(SOC_J721E) || defined(SOC_J7200)
- /*
- * Modify the default virtual interrupt configuration
- * in UDMA RM table to support DMA mode, since UART
- * DMA example uses more than two DMA events which
- * requires numVintr > 2
- */
-#if defined (BUILD_MCU2_1)
- initPrms.rmInitPrms.startVintr = 226U;
- initPrms.rmInitPrms.numVintr = 18U;
-#endif
-#if (defined (BUILD_MCU1_1) || defined(BUILD_MCU1_0))
- initPrms.rmInitPrms.startVintr = 124U;
- initPrms.rmInitPrms.numVintr = 4U;
-#endif
-#endif
retVal = Udma_init(&gUdmaDrvObj, &initPrms);
if(UDMA_SOK == retVal)
{
}
-/**
- * @b Description
- * @n
- * The function is used to populate the *test* buffer with a predefined
- * signature
- *
- * @param[in] ptrBuffer
- * Buffer to be populated
- * @param[in] size
- * Size of the buffer
- *
- * @retval
- * Not applicable
- */
-void UART_populateBuffer (uint8_t* ptrBuffer, uint32_t size)
-{
- uint32_t index;
- char ch = 'A';
-
- /* Populate the data buffer: */
- for (index = 0; index < size; index++)
- {
- *(ptrBuffer + index) = ch++;
- if (ch == ('Z'+1))
- ch = 'A';
- }
- return;
-}
-
void UART_callback(UART_Handle handle, void *buf, size_t count)
{
UART_osalPostLock(callbackSem);
while (taskSyncFlag == true)
{
transaction.buf = (void *)(uintptr_t)addrDataPrint;
- transaction.count = sizeof(dataPrint);
+ transaction.count = strlen(dataPrint);
UART_write2(uart, &transaction);
Osal_delay(100);
}
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
- transaction.count = sizeof(echoPrompt);
+ transaction.count = strlen(echoPrompt);
if (UART_write2(uart, &transaction) == UART_ERROR)
{
goto Err;
* the read is complete.
*
*/
-//static bool UART_test_read_write_cancel(bool dmaMode)
-bool UART_test_read_write_cancel(bool dmaMode)
+static bool UART_test_read_write_cancel(bool dmaMode)
{
UART_Handle uart = NULL;
UART_Params uartParams;
goto Err;
}
/* Delay for 10 seconds to allow user to enter chars */
-#if !defined(QT_BUILD)
+#if !defined(SIM_BUILD)
Osal_delay(10000);
#else
Osal_delay(100);
/* Print read cancelled prompt */
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrRdCancelPrompt;
- transaction.count = sizeof(rdCancelPrompt);
+ transaction.count = strlen(rdCancelPrompt);
#if !defined(UART_API2_NOT_SUPPORTED)
if (UART_write2(uart, &transaction) == UART_ERROR)
#else
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrDataPrint;
- transaction.count = sizeof(dataPrint);
+ transaction.count = strlen(dataPrint);
#if !defined(UART_API2_NOT_SUPPORTED)
if (UART_write2(uart, &transaction) == UART_ERROR)
#else
#endif
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
- transaction.count = sizeof(echoPrompt);
+ transaction.count = strlen(echoPrompt);
#if !defined(UART_API2_NOT_SUPPORTED)
if (UART_write2(uart, &transaction) == UART_ERROR)
#else
/* Perform the 1st write */
UART_transactionInit(&callbackTransaction);
callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
- callbackTransaction.count = sizeof(wrCancelPrompt);
+ callbackTransaction.count = strlen(wrCancelPrompt);
#if !defined(UART_API2_NOT_SUPPORTED)
if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
#else
/* Perform the 2nd write */
UART_transactionInit(&callbackTransaction);
callbackTransaction.buf = (void *)(uintptr_t)addrWrCancelPrompt;
- callbackTransaction.count = sizeof(wrCancelPrompt);
+ callbackTransaction.count = strlen(wrCancelPrompt);
#if !defined(UART_API2_NOT_SUPPORTED)
if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
#else
{
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrBreakErrPrompt;
- transaction.count = sizeof(breakErrPrompt);
+ transaction.count = strlen(breakErrPrompt);
if (UART_write2(uart, &transaction) == UART_ERROR)
{
goto Err;
/* Initialize the default configuration params. */
UART_Params_init(&uartParams);
uartParams.parityType = uartParity;
-#if defined(UART_API2_NOT_SUPPORTED)
uartParams.readTimeout = UART_TEST_TIMEOUT;
-#endif
if (dmaMode)
{
transaction.buf = (void *)(uintptr_t)scanPrompt;
transaction.count = UART_TEST_READ_LEN;
transaction.timeout = UART_TEST_TIMEOUT;
-#if defined(UART_API2_NOT_SUPPORTED)
+#if !defined(UART_API2_NOT_SUPPORTED)
if (UART_read2(uart, &transaction) == UART_ERROR)
#else
if (UART_read(uart, transaction.buf, transaction.count) == UART_ERROR)
{
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrReadTimeoutPrompt;
- transaction.count = sizeof(readTimeoutPrompt);
+ transaction.count = strlen(readTimeoutPrompt);
transaction.timeout = UART_TEST_TIMEOUT;
if (UART_write2(uart, &transaction) == UART_ERROR)
{
UART_Params uartParams;
bool ret = false;
uint32_t rdSize = UART_TEST_READ_LEN;
- uint32_t wrSize = sizeof(readTimeoutPrompt);
+ uint32_t wrSize = strlen(readTimeoutPrompt);
/* UART SoC init configuration */
UART_initConfig(dmaMode);
goto Err;
}
- wrSize = sizeof(dataPrint);
+ wrSize = strlen(dataPrint);
UART_writePolling(uart, (const void *)dataPrint, wrSize);
memset(scanPrompt, 0, sizeof(scanPrompt));
goto Err;
}
#endif
- wrSize = sizeof(echoPrompt);
+ wrSize = strlen(echoPrompt);
UART_writePolling(uart, (const void *)echoPrompt, wrSize);
UART_writePolling(uart, (const void *)scanPrompt, rdSize);
}
/* Write DMA or non-DMA test prompt */
- if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, sizeof(dataPrint)) == UART_ERROR)
+ if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
{
goto Err;
}
#endif
- if (UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, sizeof(echoPrompt)) == UART_ERROR)
+ if (UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt)) == UART_ERROR)
{
goto Err;
}
UART_transactionInit(&callbackTransaction);
callbackTransaction.buf = (void *)(uintptr_t)addrDataPrint;
- callbackTransaction.count = sizeof(dataPrint);
+ callbackTransaction.count = strlen(dataPrint);
if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
{
goto Err;
UART_transactionInit(&callbackTransaction);
callbackTransaction.buf = (void *)(uintptr_t)addrEchoPrompt;
- callbackTransaction.count = sizeof(echoPrompt);
+ callbackTransaction.count = strlen(echoPrompt);
if (UART_write2(uart, &callbackTransaction) == UART_ERROR)
{
goto Err;
length = UART_read(uart, (void *)&rBuff[12], UART_RDVERIFY_READ_LEN);
#else
memset(rBuff, 0, UART_TEST_READ_LEN);
- Osal_delay(1);
for (i =0; i < UART_TEST_READ_LEN;i++)
{
if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
#else
memset(rBuff, 0, UART_TEST_READ_LEN);
- Osal_delay(1);
for (i =0; i < UART_TEST_READ_LEN;i++)
{
if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
#else
memset(rBuff, 0, UART_TEST_READ_LEN);
- Osal_delay(1);
for (i =0; i < UART_TEST_READ_LEN;i++)
{
if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
UART_read(uart, (void *)&rBuff[0], UART_TEST_READ_LEN);
#else
memset(rBuff, 0, UART_TEST_READ_LEN);
- Osal_delay(2);
for (i =0; i < UART_TEST_READ_LEN;i++)
{
if (UART_write(uart, (void *)&tBuff[i], 1) == UART_ERROR)
}
/* Test read/write API's in blocking mode */
- if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, sizeof(dataPrint)) == UART_ERROR)
+ if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
{
goto Err;
}
}
#endif
- UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, sizeof(echoPrompt));
+ UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
UART_close(uart);
/* Test read2/write2 API's in blocking mode */
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrDataPrint;
- transaction.count = sizeof(dataPrint);
+ transaction.count = strlen(dataPrint);
if (UART_write2(uart, &transaction) == UART_ERROR)
{
goto Err;
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
- transaction.count = sizeof(echoPrompt);
+ transaction.count = strlen(echoPrompt);
if (UART_write2(uart, &transaction) == UART_ERROR)
{
goto Err;
}
/* Test read/write API's in blocking mode */
- if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, sizeof(dataPrint)) == UART_ERROR)
+ if (UART_write(uart, (void *)(uintptr_t)addrDataPrint, strlen(dataPrint)) == UART_ERROR)
{
goto Err;
}
goto Err;
}
#endif
- UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, sizeof(echoPrompt));
+ UART_write(uart, (void *)(uintptr_t)addrEchoPrompt, strlen(echoPrompt));
UART_write(uart, (void *)(uintptr_t)addrScanPrompt, length);
UART_close(uart);
/* Test read2/write2 API's in blocking mode */
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrDataPrint;
- transaction.count = sizeof(dataPrint);
+ transaction.count = strlen(dataPrint);
if (UART_write2(uart, &transaction) == UART_ERROR)
{
goto Err;
UART_transactionInit(&transaction);
transaction.buf = (void *)(uintptr_t)addrEchoPrompt;
- transaction.count = sizeof(echoPrompt);
+ transaction.count = strlen(echoPrompt);
if (UART_write2(uart, &transaction) == UART_ERROR)
{
goto Err;
}
#ifdef UART_DMA_ENABLE
-#if !defined(UART_RX_LOOPBACK_ONLY)
+#if !defined(SOC_TPR12)
static uint32_t UART_getMaxNumInst(uint32_t numInst)
{
uint32_t i = 0;
uartTestInstance = uartTestStartInst;
return (ret);
}
-#endif /* if UART_RX_LOOPBACK_ONLY */
+#endif /* if SOC_TPR12 */
#endif /* if DMA */
/**
status = UART_write(handle, NULL, 128);
if (status >= 0)
{
- printf("Error: UART Write with invalid buffer returned %d\n", status);
+ UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
return false;
}
status = UART_write(handle, &buffer[0], 0);
if (status >= 0)
{
- printf("Error: UART Write with invalid size returned %d\n", status);
+ UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
return false;
}
status = UART_writePolling(handle, NULL, 128);
if (status >= 0)
{
- printf("Error: UART Write with invalid buffer returned %d\n", status);
+ UART_test_log1("Error: UART Write with invalid buffer returned %d\n", status);
return false;
}
status = UART_writePolling(handle, &buffer[0], 0);
if (status >= 0)
{
- printf("Error: UART Write with invalid size returned %d\n", status);
+ UART_test_log1("Error: UART Write with invalid size returned %d\n", status);
return false;
}
status = UART_read(handle, NULL, 128);
if (status != UART_EINVAL)
{
- printf("Error: UART Read with invalid buffer returned %d\n", status);
+ UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
return false;
}
status = UART_read(handle, &buffer[0], 0);
if (status != UART_EINVAL)
{
- printf("Error: UART Read with invalid size returned %d\n", status);
+ UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
return false;
}
status = UART_readPolling(handle, NULL, 128);
if (status != UART_EINVAL)
{
- printf("Error: UART Read with invalid buffer returned %d\n", status);
+ UART_test_log1("Error: UART Read with invalid buffer returned %d\n", status);
return false;
}
status = UART_readPolling(handle, &buffer[0], 0);
if (status != UART_EINVAL)
{
- printf("Error: UART Read with invalid size returned %d\n", status);
+ UART_test_log1("Error: UART Read with invalid size returned %d\n", status);
return false;
}
handle = UART_open(uartTestInstance, ¶ms);
if (handle == NULL)
{
- printf("Error: Unable to open the UART Instance\n");
+ UART_test_log("Error: Unable to open the UART Instance\n");
return false;
}
/**************************************************************************
handle = UART_open(0, ¶ms);
if (handle == NULL)
{
- printf("Error: Unable to open the UART Instance\n");
+ UART_test_log("Error: Unable to open the UART Instance\n");
return false;
}
return true;
}
+#if defined(SOC_TPR12) && defined(SIM_BUILD)
+
+/**
+ * @b Description
+ * @n
+ * The function is used to populate the *test* buffer with a predefined
+ * signature
+ *
+ * @param[in] ptrBuffer
+ * Buffer to be populated
+ * @param[in] size
+ * Size of the buffer
+ *
+ * @retval
+ * Not applicable
+ */
+void UART_populateBuffer (char* ptrBuffer, uint32_t size)
+{
+ uint32_t index;
+ char ch = 'A';
+
+ /* Populate the data buffer: */
+ for (index = 0; index < size; index++)
+ {
+ *(ptrBuffer + index) = ch++;
+ if (ch == ('Z'+1))
+ ch = 'A';
+ }
+ return;
+}
+
/**
* @b Description
* @n
* @retval
* Error - <0
*/
-uint8_t uartDataBuf[0x2000];
+#if (defined(_TMS320C6X) || defined (__TI_ARM_V7M4__))
+#pragma DATA_ALIGN (uartDataBuf, UART_TEST_CACHE_LINE_SIZE)
+char uartDataBuf[0x2000];
+#else
+char uartDataBuf[0x2000] __attribute__ ((aligned (UART_TEST_CACHE_LINE_SIZE)));
+#endif
bool UART_test_profile_tx(bool dmaMode)
{
uint32_t numDataSize = sizeof(dataSize)/sizeof(uint32_t);
uint32_t baudRate = 921600;
uintptr_t ptrTxData;
-#if defined(SOC_TPR12)
uint32_t txTimeTaken;
UART_Stats stats;
-#endif
char testDescription[128];
-#if defined(QT_BUILD)
+#if defined(SIM_BUILD)
numDataSize = 3;
#endif
-#if defined(SOC_TPR12)
CycleprofilerP_init();
-#endif
/********************************************************************************
* Execute the test for all data sizes
handle = UART_open(uartTestInstance, ¶ms);
if (handle == NULL)
{
- printf ("Error: Unable to open the UART Driver while profiling Transmit Data\n");
+ UART_test_log ("Error: Unable to open the UART Driver while profiling Transmit Data\n");
return false;
}
/* Populate the transmit buffer: */
UART_populateBuffer (uartDataBuf, dataSize[dataSizeIndex]);
-#if defined(SOC_TPR12)
+ if (dmaMode)
+ {
+ CacheP_wbInv((void *)(uintptr_t)uartDataBuf, (int32_t)dataSize[dataSizeIndex]);
+ }
+
/****************************************************************
* Profile the time taken to send out the data
****************************************************************/
txTimeTaken = CycleprofilerP_getTimeStamp();
-#endif
if ((testIndex == 0) || (testIndex == 1))
status = UART_write(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
else
status = UART_writePolling(handle, (void *)ptrTxData, dataSize[dataSizeIndex]);
-#if defined(SOC_TPR12)
txTimeTaken = CycleprofilerP_getTimeStamp() - txTimeTaken;
-#endif
/* Were we able to send out the data */
if (status != dataSize[dataSizeIndex])
{
- printf ("Error: Unable to send out the data [Status %d]\n", status);
+ UART_test_log1 ("Error: Unable to send out the data [Status %d]\n", status);
UART_close(handle);
return false;
}
-#if defined(SOC_TPR12)
/* Get the UART Statistics: */
if (UART_control (handle, UART_CMD_GET_STATS, &stats) < 0)
{
}
/* Debug Message: */
- printf ("Debug: Transmit Measurements\n");
- printf ("Debug: Baud Rate : %d\n", baudRate);
- printf ("Debug: Data Size : %d\n", dataSize[dataSizeIndex]);
- printf ("Debug: Transmit : %d ticks\n", txTimeTaken);
- printf ("Debug: Tx Interrupt : %d\n", stats.numTxInterrupts);
- printf ("Debug: Tx DMA Interrupt : %d\n", stats.numTxDMAInterrupts);
-#endif
+ UART_test_log ("Debug: Transmit Measurements\n");
+ UART_test_log1 ("Debug: Baud Rate : %d\n", baudRate);
+ UART_test_log1 ("Debug: Data Size : %d\n", dataSize[dataSizeIndex]);
+ UART_test_log1 ("Debug: Transmit : %d ticks\n", txTimeTaken);
+ UART_test_log1 ("Debug: Tx Interrupt : %d\n", stats.numTxInterrupts);
+ UART_test_log1 ("Debug: Tx DMA Interrupt : %d\n", stats.numTxDMAInterrupts);
/* Close the driver: */
UART_close(handle);
handle = UART_open(uartTestInstance, ¶ms);
if (!handle)
{
- printf ("Error: Unable to open the UART Driver while printing the test banner\n");
+ UART_test_log ("Error: Unable to open the UART Driver while printing the test banner\n");
return false;
}
return true;
}
+#endif
bool UART_test_loopback_data(bool dmaMode)
{
callbackSem = UART_osalCreateBlockingLock(0, &semParams);
/* enable the loopback */
- verifyLoopback = 1;
+ verifyLoopback = TRUE;
/* UART SoC init configuration */
UART_initConfig(dmaMode);
handle = UART_open(uartTestInstance, ¶ms);
if (handle == NULL)
{
+ UART_test_log ("Error: Unable to open the UART Driver!\n");
goto Err;
}
status = UART_read(handle, (void *)pRxBuf, MAX_TEST_BUFFER_SIZE);
if (status < 0)
{
+ UART_test_log1 ("Error: UART_read() return %d!\n", status);
goto Err;
}
status = UART_write(handle, (void *)pTxBuf, MAX_TEST_BUFFER_SIZE);
if (status < 0)
{
+ UART_test_log1 ("Error: UART_write() return %d!\n", status);
goto Err;
}
/* Wait for RX call back */
- if (UART_osalPendLock(callbackSem, params.writeTimeout) != SemaphoreP_OK)
+ if ((status = UART_osalPendLock(callbackSem, params.writeTimeout)) != SemaphoreP_OK)
{
+ UART_test_log1 ("Error: UART_osalPendLock() return %d!\n", status);
goto Err;
}
{
if (scanPrompt[i] != fifoTrgLvlData[i])
{
+ UART_test_log3 ("Error: UART_test_loopback_data: data fails at index %d (%c != %c)\n", i, scanPrompt[i], fifoTrgLvlData[i]);
goto Err;
}
}
{UART_test_read_write_int_disable, false, UART_TEST_ID_INT_DISABLE, "\r\n UART read write test with interrupt disabled"},
{UART_test_read_verify, false, UART_TEST_ID_RDVERIFY, "\r\n UART non-DMA read API test in loopback mode"},
#ifdef UART_DMA_ENABLE
-#if !defined(UART_RX_LOOPBACK_ONLY)
+#if !defined(SOC_TPR12)
{UART_test_multiple_instances, true, UART_TEST_ID_MULTI_INSTS, "\r\n UART DMA multiple instances loopback test "},
#endif
#endif
{UART_test_api, false, UART_TEST_ID_API, "\r\n UART API Test"},
+#if defined(SOC_TPR12) && defined(SIM_BUILD)
{UART_test_profile_tx, false, UART_TEST_ID_PROF_TX, "\r\n UART non-DMA/DMA Blocking/Polling transmit profiling"},
+#endif
#ifdef UART_DMA_ENABLE
{UART_test_loopback_data, true, UART_TEST_ID_DMA_LB_DATA, "\r\n UART DMA read write test with loopback"},
#endif
void UART_test_print_test_desc(UART_Tests *test)
{
-#if !defined(QT_BUILD)
+#if !defined(SIM_BUILD)
UART_Handle uart = NULL;
UART_Params uartParams;
char testIdPrompt[16] = "\r\n UART UT ";
void UART_test_print_test_result(UART_Tests *test, bool pass)
{
-#if !defined(QT_BUILD)
+#if !defined(SIM_BUILD)
UART_Handle uart = NULL;
UART_Params uartParams;
char testIdPrompt[16] = "\r\n UART UT ";
/* Print unit test ID */
sprintf(testId, "%d", test->testId);
- UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
- UART_write(uart, (void *)(uintptr_t)testIdPrompt, sizeof(testIdPrompt));
- UART_write(uart, (void *)(uintptr_t)testId, sizeof(testId));
+ UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
+ UART_write(uart, (void *)(uintptr_t)testIdPrompt, strlen(testIdPrompt));
+ UART_write(uart, (void *)(uintptr_t)testId, strlen(testId));
if (pass == true)
{
- UART_write(uart, (void *)(uintptr_t)resultPass, sizeof(resultPass));
+ UART_write(uart, (void *)(uintptr_t)resultPass, strlen(resultPass));
}
else
{
- UART_write(uart, (void *)(uintptr_t)resultFail, sizeof(resultFail));
+ UART_write(uart, (void *)(uintptr_t)resultFail, strlen(resultFail));
}
- UART_write(uart, (void *)(uintptr_t)crPrompt, sizeof(crPrompt));
+ UART_write(uart, (void *)(uintptr_t)crPrompt, strlen(crPrompt));
UART_close(uart);
#else
const char resultPass[32] = "\r\n All tests have passed. \r\n";
const char resultFail[32] = "\r\n Some tests have failed. \r\n";
-#if !defined(QT_BUILD)
+#if !defined(SIM_BUILD)
+
/* UART SoC init configuration */
UART_initConfig(false);
{
UART_printStatus(resultFail);
}
-
UART_stdioDeInit();
#else
printf("%s", pass?resultPass:resultFail);
{
EDMA_errorConfig_t errorConfig;
EDMA_instanceInfo_t instanceInfo;
+ EDMA3CCInitParams initParam;
+ uint32_t edmaInstId = UART_EDMA_INSTANCE_ID;
int32_t errCode;
if (gEdmaHandle != NULL)
return(gEdmaHandle);
}
+ if (uartTestInstance == 2)
+ {
+ /* UART Instance 2 uses DSS EDMA instance B */
+ edmaInstId = EDMA_DRV_INST_DSS_B;
+ }
+
/* Initialize the UART edma instance */
- errCode = EDMA_init(UART_EDMA_INSTANCE_ID);
+ EDMA3CCInitParams_init(&initParam);
+ initParam.initParamSet = TRUE;
+ errCode = EDMA_init(edmaInstId, &initParam);
if (errCode != EDMA_NO_ERROR)
{
printf("Error: Unable to initialize EDMA, errorCode = %d\n", errCode);
}
/* Open the UART edma Instance */
- gEdmaHandle = EDMA_open(UART_EDMA_INSTANCE_ID, &errCode, &instanceInfo);
+ gEdmaHandle = EDMA_open(edmaInstId, &errCode, &instanceInfo);
if (gEdmaHandle == NULL)
{
printf("Error: Unable to open the edma Instance(%d), erorCode = %d\n",
return(gEdmaHandle);
}
-#endif
+#endif /* SOC_TPR12 */
#endif
#if defined(BUILD_MPU) || defined (__C7100__)