AM62x MCU+ SDK  09.02.01
uart/v0/uart.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2021-2023 Texas Instruments Incorporated
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *
11  * Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the
14  * distribution.
15  *
16  * Neither the name of Texas Instruments Incorporated nor the names of
17  * its contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 
48 #ifndef UART_V0_H_
49 #define UART_V0_H_
50 
51 /* ========================================================================== */
52 /* Include Files */
53 /* ========================================================================== */
54 
55 #include <stdint.h>
56 #include <kernel/dpl/SystemP.h>
57 #include <kernel/dpl/SemaphoreP.h>
58 #include <kernel/dpl/HwiP.h>
59 #include <drivers/hw_include/cslr.h>
60 #include <drivers/hw_include/cslr_uart.h>
61 #include <drivers/hw_include/hw_types.h>
62 
63 #ifdef __cplusplus
64 extern "C" {
65 #endif
66 
67 /* ========================================================================== */
68 /* Macros & Typedefs */
69 /* ========================================================================== */
70 
72 #define UART_FIFO_SIZE (64U)
73 
79 #define UART_TRANSMITEMPTY_TRIALCOUNT (3000U)
80 
82 #define UART_ERROR_COUNT (0x00FFFFFFU)
83 
85 typedef void *UART_Handle;
86 
96 #define UART_TRANSFER_STATUS_SUCCESS (0U)
97 
98 #define UART_TRANSFER_STATUS_TIMEOUT (1U)
99 
100 #define UART_TRANSFER_STATUS_ERROR_BI (2U)
101 
102 #define UART_TRANSFER_STATUS_ERROR_FE (3U)
103 
104 #define UART_TRANSFER_STATUS_ERROR_PE (4U)
105 
106 #define UART_TRANSFER_STATUS_ERROR_OE (5U)
107 
108 #define UART_TRANSFER_STATUS_CANCELLED (6U)
109 
110 #define UART_TRANSFER_STATUS_STARTED (7U)
111 
112 #define UART_TRANSFER_STATUS_READ_TIMEOUT (8U)
113 
114 #define UART_TRANSFER_STATUS_ERROR_INUSE (9U)
115 
116 #define UART_TRANSFER_STATUS_ERROR_OTH (10U)
117 
138 #define UART_TRANSFER_MODE_BLOCKING (0U)
139 
143 #define UART_TRANSFER_MODE_CALLBACK (1U)
144 
166 #define UART_READ_RETURN_MODE_FULL (0U)
167 
170 #define UART_READ_RETURN_MODE_PARTIAL (1U)
171 
181 #define UART_LEN_5 (0U)
182 #define UART_LEN_6 (1U)
183 #define UART_LEN_7 (2U)
184 #define UART_LEN_8 (3U)
185 
195 #define UART_STOPBITS_1 (0U)
196 #define UART_STOPBITS_2 (1U)
197 
207 #define UART_PARITY_NONE (0x00U)
208 #define UART_PARITY_ODD (0x01U)
209 #define UART_PARITY_EVEN (0x03U)
210 #define UART_PARITY_FORCED0 (0x07U)
211 #define UART_PARITY_FORCED1 (0x05U)
212 
222 #define UART_FCTYPE_NONE (0x00U)
223 #define UART_FCTYPE_HW (0x02U)
224 
234 #define UART_FCPARAM_RXNONE (0x00U)
235 #define UART_FCPARAM_RXXONXOFF_2 (0x01U)
236 #define UART_FCPARAM_RXXONXOFF_1 (0x02U)
237 #define UART_FCPARAM_RXXONXOFF_12 (0x03U)
238 #define UART_FCPARAM_AUTO_RTS (0x40U)
239 
249 #define UART_FCPARAM_TXNONE (0x00U)
250 #define UART_FCPARAM_TXXONXOFF_2 (0x04U)
251 #define UART_FCPARAM_TXXONXOFF_1 (0x08U)
252 #define UART_FCPARAM_TXXONXOFF_12 (0x0CU)
253 #define UART_FCPARAM_AUTO_CTS (0x80U)
254 
264 #define UART_RXTRIGLVL_1 (1U)
265 #define UART_RXTRIGLVL_8 (8U)
266 #define UART_RXTRIGLVL_16 (16U)
267 #define UART_RXTRIGLVL_56 (56U)
268 #define UART_RXTRIGLVL_60 (60U)
269 
279 #define UART_TXTRIGLVL_1 (1U)
280 #define UART_TXTRIGLVL_8 (8U)
281 #define UART_TXTRIGLVL_16 (16U)
282 #define UART_TXTRIGLVL_32 (32U)
283 #define UART_TXTRIGLVL_56 (56U)
284 
294 #define UART_OPER_MODE_16X (0U)
295 #define UART_OPER_MODE_SIR (1U)
296 #define UART_OPER_MODE_16X_AUTO_BAUD (2U)
297 #define UART_OPER_MODE_13X (3U)
298 #define UART_OPER_MODE_MIR (4U)
299 #define UART_OPER_MODE_FIR (5U)
300 #define UART_OPER_MODE_CIR (6U)
301 #define UART_OPER_MODE_DISABLED (7U)
302 
313 #define UART_TX_FIFO_NOT_FULL ( \
314  UART_SSR_TX_FIFO_FULL_TX_FIFO_FULL_VALUE_0)
315 #define UART_TX_FIFO_FULL ( \
316  UART_SSR_TX_FIFO_FULL_TX_FIFO_FULL_VALUE_1)
317 
327 #define UART_INTID_MODEM_STAT (UART_IIR_IT_TYPE_IT_TYPE_VALUE_0 \
328  << \
329  UART_IIR_IT_TYPE_SHIFT)
330 #define UART_INTID_TX_THRES_REACH (UART_IIR_IT_TYPE_IT_TYPE_VALUE_1 \
331  << \
332  UART_IIR_IT_TYPE_SHIFT)
333 #define UART_INTID_RX_THRES_REACH (UART_IIR_IT_TYPE_IT_TYPE_VALUE_2 \
334  << \
335  UART_IIR_IT_TYPE_SHIFT)
336 #define UART_INTID_RX_LINE_STAT_ERROR (UART_IIR_IT_TYPE_IT_TYPE_VALUE_3 \
337  << \
338  UART_IIR_IT_TYPE_SHIFT)
339 #define UART_INTID_CHAR_TIMEOUT (UART_IIR_IT_TYPE_IT_TYPE_VALUE_6 \
340  << \
341  UART_IIR_IT_TYPE_SHIFT)
342 #define UART_INTID_XOFF_SPEC_CHAR_DETECT (UART_IIR_IT_TYPE_IT_TYPE_VALUE_8 \
343  << \
344  UART_IIR_IT_TYPE_SHIFT)
345 #define UART_INTID_MODEM_SIG_STATE_CHANGE (UART_IIR_IT_TYPE_IT_TYPE_VALUE_10 \
346  << \
347  UART_IIR_IT_TYPE_SHIFT)
348 
350 #define UART_INTR_PENDING (0U)
351 #define UART_N0_INTR_PENDING (1U)
352 
361 #define UART_INTR_CTS (UART_IER_CTS_IT_MASK)
362 #define UART_INTR_RTS (UART_IER_RTS_IT_MASK)
363 #define UART_INTR_XOFF (UART_IER_XOFF_IT_MASK)
364 #define UART_INTR_SLEEPMODE (UART_IER_SLEEP_MODE_MASK)
365 #define UART_INTR_MODEM_STAT (UART_IER_MODEM_STS_IT_MASK)
366 #define UART_INTR_LINE_STAT (UART_IER_LINE_STS_IT_MASK)
367 #define UART_INTR_THR (UART_IER_THR_IT_MASK)
368 #define UART_INTR_RHR_CTI (UART_IER_RHR_IT_MASK)
369 
370 #define UART_INTR2_RX_EMPTY (UART_IER2_EN_RXFIFO_EMPTY_MASK)
371 #define UART_INTR2_TX_EMPTY (UART_IER2_EN_TXFIFO_EMPTY_MASK)
372 
381 #define UART_FIFO_PE_FE_BI_DETECTED (UART_LSR_RX_FIFO_STS_MASK)
382 #define UART_BREAK_DETECTED_ERROR (UART_LSR_RX_BI_MASK)
383 #define UART_FRAMING_ERROR (UART_LSR_RX_FE_MASK)
384 #define UART_PARITY_ERROR (UART_LSR_RX_PE_MASK)
385 #define UART_OVERRUN_ERROR (UART_LSR_RX_OE_MASK)
386 
395 #define UART_REG_CONFIG_MODE_A ((uint32_t) 0x0080)
396 #define UART_REG_CONFIG_MODE_B ((uint32_t) 0x00BF)
397 #define UART_REG_OPERATIONAL_MODE ((uint32_t) 0x007F)
398 
409 #define UART_CONFIG_MODE_POLLED (0x00U)
410 #define UART_CONFIG_MODE_INTERRUPT (0x01U)
411 #define UART_CONFIG_MODE_USER_INTR (0x02U)
412 #define UART_CONFIG_MODE_DMA (0x03U)
413 
414 /* ========================================================================== */
415 /* Structures and Enums */
416 /* ========================================================================== */
417 
422 typedef struct
423 {
424  void *buf;
427  uint32_t count;
431  uint32_t timeout;
433  uint32_t status;
435  void *args;
437 } UART_Transaction;
438 
446 typedef void (*UART_CallbackFxn) (UART_Handle handle,
447  UART_Transaction *transaction);
448 
459 typedef struct
460 {
461  uint32_t baudRate;
463  uint32_t dataLength;
465  uint32_t stopBits;
467  uint32_t parityType;
469  uint32_t readMode;
471  uint32_t readReturnMode;
473  uint32_t writeMode;
475  UART_CallbackFxn readCallbackFxn;
477  UART_CallbackFxn writeCallbackFxn;
479  uint32_t hwFlowControl;
481  uint32_t hwFlowControlThr;
484  /*
485  * Driver configuration
486  */
487  uint32_t transferMode;
489  uint32_t intrNum;
491  uint16_t eventId;
493  uint8_t intrPriority;
495  uint32_t skipIntrReg;
497  int32_t uartDmaIndex;
502  /*
503  * UART configuration
504  */
505  uint32_t operMode;
507  uint32_t rxTrigLvl;
509  uint32_t txTrigLvl;
511  uint32_t rxEvtNum;
513  uint32_t txEvtNum;
515 } UART_Params;
516 
518 typedef struct
519 {
520  /*
521  * SOC configuration
522  */
523  uint32_t baseAddr;
525  uint32_t inputClkFreq;
527 } UART_Attrs;
528 
529 /* ========================================================================== */
530 /* Internal/Private Structure Declarations */
531 /* ========================================================================== */
532 
536 typedef struct
537 {
538  /*
539  * User parameters
540  */
541  UART_Handle handle;
543  UART_Params prms;
545  /*
546  * UART write variables
547  */
548  const void *writeBuf;
550  uint32_t writeCount;
552  uint32_t writeSizeRemaining;
554  /*
555  * UART receive variables
556  */
557  void *readBuf;
559  uint32_t readCount;
561  uint32_t readSizeRemaining;
563  uint32_t rxTimeoutCnt;
565  uint32_t readErrorCnt;
567  /*
568  * UART ransaction status variables
569  */
570  UART_Transaction *readTrans;
572  UART_Transaction *writeTrans;
574  /*
575  * State variables
576  */
577  uint32_t isOpen;
579  void *lock;
581  SemaphoreP_Object lockObj;
583  void *readTransferSem;
586  SemaphoreP_Object readTransferSemObj;
588  void *writeTransferSem;
591  SemaphoreP_Object writeTransferSemObj;
593  void *hwiHandle;
595  HwiP_Object hwiObj;
597  void* uartDmaHandle;
599 } UART_Object;
600 
607 typedef struct
608 {
609  UART_Attrs *attrs;
611  UART_Object *object;
613  uint32_t traceInstance;
615 } UART_Config;
616 
618 extern UART_Config gUartConfig[];
620 extern uint32_t gUartConfigNum;
621 
622 /* ========================================================================== */
623 /* Global Variables Declarations */
624 /* ========================================================================== */
625 
626 /* None */
627 
628 /* ========================================================================== */
629 /* Function Declarations */
630 /* ========================================================================== */
631 
635 void UART_init(void);
636 
640 void UART_deinit(void);
641 
658 UART_Handle UART_open(uint32_t index, const UART_Params *prms);
659 
669 void UART_close(UART_Handle handle);
670 
709 int32_t UART_write(UART_Handle handle, UART_Transaction *trans);
710 
745 int32_t UART_read(UART_Handle handle, UART_Transaction *trans);
746 
778 int32_t UART_writeCancel(UART_Handle handle, UART_Transaction *trans);
779 
811 int32_t UART_readCancel(UART_Handle handle, UART_Transaction *trans);
812 
821 UART_Handle UART_getHandle(uint32_t index);
822 
832 void UART_flushTxFifo(UART_Handle handle);
833 
839 static inline void UART_Params_init(UART_Params *prms);
840 
847 static inline void UART_Transaction_init(UART_Transaction *trans);
848 
849 /* ========================================================================== */
850 /* Static Function Definitions */
851 /* ========================================================================== */
852 
853 static inline void UART_Params_init(UART_Params *prms)
854 {
855  if(prms != NULL)
856  {
857  prms->baudRate = 115200U;
858  prms->dataLength = UART_LEN_8;
859  prms->stopBits = UART_STOPBITS_1;
860  prms->parityType = UART_PARITY_NONE;
861  prms->readMode = UART_TRANSFER_MODE_BLOCKING;
862  prms->readReturnMode = UART_READ_RETURN_MODE_FULL;
863  prms->writeMode = UART_TRANSFER_MODE_BLOCKING;
864  prms->readCallbackFxn = NULL;
865  prms->writeCallbackFxn = NULL;
866  prms->hwFlowControl = 0U;
867  prms->hwFlowControlThr = UART_RXTRIGLVL_16;
868  prms->intrNum = 0xFFFF;
869  prms->transferMode = UART_CONFIG_MODE_INTERRUPT;
870  prms->intrPriority = 4U;
871  prms->skipIntrReg = 0U;
872  prms->uartDmaIndex = -1;
873  prms->operMode = UART_OPER_MODE_16X;
874  prms->rxTrigLvl = UART_RXTRIGLVL_8;
875  prms->txTrigLvl = UART_TXTRIGLVL_32;
876  }
877 }
878 
879 static inline void UART_Transaction_init(UART_Transaction *trans)
880 {
881  if(trans != NULL)
882  {
883  trans->buf = NULL;
884  trans->count = 0U;
885  trans->timeout = SystemP_WAIT_FOREVER;
886  trans->status = UART_TRANSFER_STATUS_SUCCESS;
887  trans->args = NULL;
888  }
889 }
890 
891 /* ========================================================================== */
892 /* Advanced Function Declarations */
893 /* ========================================================================== */
902 uint32_t UART_getBaseAddr(UART_Handle handle);
903 
912 void UART_enableLoopbackMode(uint32_t baseAddr);
913 
922 void UART_disableLoopbackMode(uint32_t baseAddr);
923 
941 static inline void UART_putChar(uint32_t baseAddr, uint8_t byteTx);
942 
957 static inline uint32_t UART_getChar(uint32_t baseAddr, uint8_t *pChar);
958 
987 static inline void UART_intrEnable(uint32_t baseAddr, uint32_t intrFlag);
988 
1013 static inline void UART_intrDisable(uint32_t baseAddr, uint32_t intrFlag);
1014 
1033 static inline void UART_intr2Enable(uint32_t baseAddr, uint32_t intrFlag);
1034 
1052 static inline void UART_intr2Disable(uint32_t baseAddr, uint32_t intrFlag);
1053 
1079 static inline uint32_t UART_getIntrIdentityStatus(uint32_t baseAddr);
1080 
1093 static inline uint32_t UART_getIntr2Status(uint32_t baseAddr);
1094 
1109 static inline uint32_t UART_checkCharsAvailInFifo(uint32_t baseAddr);
1110 
1121 static inline uint32_t UART_readLineStatus(uint32_t baseAddr);
1122 
1136 static inline uint8_t UART_getCharFifo(uint32_t baseAddr, uint8_t *readBuf);
1137 /* ========================================================================== */
1138 /* Advanced Function Definitions */
1139 /* ========================================================================== */
1140 static inline void UART_putChar(uint32_t baseAddr, uint8_t byteTx)
1141 {
1142  /* Write the byte to the Transmit Holding Register(or TX FIFO). */
1143  HW_WR_REG32(baseAddr + UART_THR, (uint32_t) byteTx);
1144 }
1145 
1146 static inline uint32_t UART_getChar(uint32_t baseAddr, uint8_t *pChar)
1147 {
1148  uint32_t lcrRegValue = 0U;
1149  uint32_t retVal = 0U;
1150 
1151  /* Preserving the current value of LCR. */
1152  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1153 
1154  /* Switching to Register Operational Mode of operation. */
1155  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1156  & 0x7FU);
1157 
1158  /* Checking if the RX FIFO(or RHR) has atleast one byte of data. */
1159  if ((uint32_t) UART_LSR_RX_FIFO_E_RX_FIFO_E_VALUE_0 !=
1160  (HW_RD_REG32(baseAddr + UART_LSR) &
1161  UART_LSR_RX_FIFO_E_MASK))
1162  {
1163  uint32_t tempRetVal = HW_RD_REG32(baseAddr + UART_RHR);
1164  *pChar = (uint8_t)tempRetVal;
1165  retVal = 1U;
1166  }
1167 
1168  /* Restoring the value of LCR. */
1169  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1170 
1171  return retVal;
1172 }
1173 
1174 static inline void UART_intrEnable(uint32_t baseAddr, uint32_t intrFlag)
1175 {
1176  uint32_t enhanFnBitVal = 0U;
1177  uint32_t lcrRegValue = 0U;
1178 
1179  /* Switch to mode B only when the upper 4 bits of IER needs to be changed */
1180  if ((intrFlag & 0xF0U) > 0U)
1181  {
1182  /* Preserving the current value of LCR. */
1183  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1184  /* Switching to Register Configuration Mode B. */
1185  HW_WR_REG32(baseAddr + UART_LCR, UART_REG_CONFIG_MODE_B & 0xFFU);
1186 
1187  /* Collecting the current value of EFR[4] and later setting it. */
1188  enhanFnBitVal = HW_RD_FIELD32(baseAddr + UART_EFR, UART_EFR_ENHANCED_EN);
1189 
1190  HW_WR_FIELD32(baseAddr + UART_EFR, UART_EFR_ENHANCED_EN,
1191  UART_EFR_ENHANCED_EN_ENHANCED_EN_U_VALUE_1);
1192 
1193  /* Restoring the value of LCR. */
1194  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1195 
1196  /* Preserving the current value of LCR. */
1197  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1198 
1199  /* Switching to Register Operational Mode of operation. */
1200  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1201  & 0x7FU);
1202 
1203  /*
1204  ** It is suggested that the System Interrupts for UART in the
1205  ** Interrupt Controller are enabled after enabling the peripheral
1206  ** interrupts of the UART using this API. If done otherwise, there
1207  ** is a risk of LCR value not getting restored and illicit characters
1208  ** transmitted or received from/to the UART. The situation is explained
1209  ** below.
1210  ** The scene is that the system interrupt for UART is already enabled
1211  ** and the current API is invoked. On enabling the interrupts
1212  ** corresponding to IER[7:4] bits below, if any of those interrupt
1213  ** conditions already existed, there is a possibility that the control
1214  ** goes to Interrupt Service Routine (ISR) without executing the
1215  ** remaining statements in this API. Executing the remaining statements
1216  ** is critical in that the LCR value is restored in them.
1217  ** However, there seems to be no risk in this API for enabling
1218  ** interrupts corresponding to IER[3:0] because it is done at the end
1219  ** and no statements follow that.
1220  */
1221 
1222  /************* ATOMIC STATEMENTS START *************************/
1223 
1224  /* Programming the bits IER[7:4]. */
1225  HW_WR_REG32(baseAddr + UART_IER, intrFlag & 0xF0U);
1226 
1227  /* Restoring the value of LCR. */
1228  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1229 
1230  /* Preserving the current value of LCR. */
1231  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1232  /* Switching to Register Configuration Mode B. */
1233  HW_WR_REG32(baseAddr + UART_LCR, UART_REG_CONFIG_MODE_B & 0xFFU);
1234 
1235  /* Restoring the value of EFR[4] to its original value. */
1236  HW_WR_FIELD32(baseAddr + UART_EFR, UART_EFR_ENHANCED_EN, enhanFnBitVal);
1237 
1238  /* Restoring the value of LCR. */
1239  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1240 
1241  /************** ATOMIC STATEMENTS END *************************/
1242  }
1243 
1244  /* Programming the bits IER[3:0]. */
1245  HW_WR_REG32(baseAddr + UART_IER, HW_RD_REG32(baseAddr + UART_IER) |
1246  (intrFlag & 0x0FU));
1247 }
1248 
1249 static inline void UART_intrDisable(uint32_t baseAddr, uint32_t intrFlag)
1250 {
1251  uint32_t enhanFnBitVal;
1252  uint32_t lcrRegValue;
1253 
1254  /* Switch to mode B only when the upper 4 bits of IER needs to be changed */
1255  if((intrFlag & 0xF0U) > 0U)
1256  {
1257  /* Preserving the current value of LCR. */
1258  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1259  /* Switching to Register Configuration Mode B. */
1260  HW_WR_REG32(baseAddr + UART_LCR, UART_REG_CONFIG_MODE_B & 0xFFU);
1261 
1262  /* Collecting the current value of EFR[4] and later setting it. */
1263  enhanFnBitVal = HW_RD_FIELD32(baseAddr + UART_EFR, UART_EFR_ENHANCED_EN);
1264 
1265  HW_WR_FIELD32(baseAddr + UART_EFR, UART_EFR_ENHANCED_EN,
1266  UART_EFR_ENHANCED_EN_ENHANCED_EN_U_VALUE_1);
1267 
1268  /* Restoring the value of LCR. */
1269  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1270  }
1271 
1272  /* Preserving the current value of LCR. */
1273  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1274 
1275  /* Switching to Register Operational Mode of operation. */
1276  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1277  & 0x7FU);
1278 
1279  HW_WR_REG32(baseAddr + UART_IER, HW_RD_REG32(baseAddr + UART_IER) &
1280  ~(intrFlag & 0xFFU));
1281 
1282  /* Restoring the value of LCR. */
1283  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1284 
1285  /* Switch to mode B only when the upper 4 bits of IER needs to be changed */
1286  if((intrFlag & 0xF0U) > 0U)
1287  {
1288  /* Preserving the current value of LCR. */
1289  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1290  /* Switching to Register Configuration Mode B. */
1291  HW_WR_REG32(baseAddr + UART_LCR, UART_REG_CONFIG_MODE_B & 0xFFU);
1292 
1293  /* Restoring the value of EFR[4] to its original value. */
1294  HW_WR_FIELD32(baseAddr + UART_EFR, UART_EFR_ENHANCED_EN, enhanFnBitVal);
1295 
1296  /* Restoring the value of LCR. */
1297  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1298  }
1299 }
1300 
1301 static inline void UART_intr2Enable(uint32_t baseAddr, uint32_t intrFlag)
1302 {
1303  /* Programming the bits IER2[1:0]. */
1304  HW_WR_REG32(baseAddr + UART_IER2, HW_RD_REG32(baseAddr + UART_IER2) |
1305  (intrFlag & 0x03U));
1306 }
1307 
1308 static inline void UART_intr2Disable(uint32_t baseAddr, uint32_t intrFlag)
1309 {
1310  HW_WR_REG32(baseAddr + UART_IER2, HW_RD_REG32(baseAddr + UART_IER2) &
1311  ~(intrFlag & 0x3U));
1312 }
1313 
1314 static inline uint32_t UART_getIntrIdentityStatus(uint32_t baseAddr)
1315 {
1316  uint32_t lcrRegValue = 0U;
1317  uint32_t retVal = 0U;
1318 
1319  /* Preserving the current value of LCR. */
1320  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1321 
1322  /* Switching to Register Operational Mode of operation. */
1323  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1324  & 0x7FU);
1325 
1326  retVal = HW_RD_REG32(baseAddr + UART_IIR) & UART_IIR_IT_TYPE_MASK;
1327 
1328  /* Restoring the value of LCR. */
1329  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1330 
1331  return retVal;
1332 }
1333 
1334 static inline uint32_t UART_getIntr2Status(uint32_t baseAddr)
1335 {
1336  uint32_t retVal = 0U;
1337 
1338  retVal = HW_RD_REG32(baseAddr + UART_ISR2) &
1339  (UART_IER2_EN_RXFIFO_EMPTY_MASK | UART_IER2_EN_TXFIFO_EMPTY_MASK);
1340 
1341  return retVal;
1342 }
1343 
1344 static inline uint32_t UART_checkCharsAvailInFifo(uint32_t baseAddr)
1345 {
1346  uint32_t lcrRegValue = 0;
1347  uint32_t retVal = 0U;
1348 
1349  /* Preserving the current value of LCR. */
1350  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1351 
1352  /* Switching to Register Operational Mode of operation. */
1353  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1354  & 0x7FU);
1355 
1356  /* Checking if the RHR(or RX FIFO) has atleast one byte to be read. */
1357  if ((uint32_t) UART_LSR_RX_FIFO_E_RX_FIFO_E_VALUE_0 !=
1358  (HW_RD_REG32(baseAddr + UART_LSR) &
1359  UART_LSR_RX_FIFO_E_MASK))
1360  {
1361  retVal = (uint32_t) TRUE;
1362  }
1363 
1364  /* Restoring the value of LCR. */
1365  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1366 
1367  return retVal;
1368 }
1369 
1370 static inline uint32_t UART_readLineStatus(uint32_t baseAddr)
1371 {
1372  uint32_t lcrRegValue = 0U;
1373  uint32_t retVal = 0U;
1374 
1375  /* Preserving the current value of LCR. */
1376  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1377 
1378  /* Switching to Register Operational Mode of operation. */
1379  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1380  & 0x7FU);
1381 
1382  retVal = HW_RD_REG32(baseAddr + UART_LSR);
1383 
1384  /* Restoring the value of LCR. */
1385  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1386 
1387  return retVal;
1388 }
1389 
1390 static inline uint8_t UART_getCharFifo(uint32_t baseAddr, uint8_t *readBuf)
1391 {
1392  uint8_t readByte = 0;
1393  uint32_t waitCount = UART_ERROR_COUNT;
1394  uint32_t errorVal;
1395  uint32_t lcrRegValue = 0;
1396 
1397  /* Preserving the current value of LCR. */
1398  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1399 
1400  /* Switching to Register Operational Mode of operation. */
1401  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1402  & 0x7FU);
1403 
1404  /* Read Rx Error Status */
1405  errorVal = HW_RD_REG32(baseAddr + UART_LSR) &
1406  (UART_LSR_RX_FIFO_STS_MASK |
1407  UART_LSR_RX_BI_MASK |
1408  UART_LSR_RX_FE_MASK |
1409  UART_LSR_RX_PE_MASK |
1410  UART_LSR_RX_OE_MASK);
1411 
1412  /* Restoring the value of LCR. */
1413  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1414 
1415  /* Read and throw Erroneous bytes from RxFIFO */
1416  while ((UART_LSR_RX_FIFO_STS_MASK |
1417  UART_LSR_RX_BI_MASK |
1418  UART_LSR_RX_FE_MASK |
1419  UART_LSR_RX_PE_MASK |
1420  UART_LSR_RX_OE_MASK) == errorVal)
1421  {
1422  readByte = (uint8_t) (HW_RD_REG32(baseAddr + UART_RHR) & 0xFFU);
1423  waitCount--;
1424  if (0U == waitCount)
1425  {
1426  break;
1427  }
1428 
1429  /* Preserving the current value of LCR. */
1430  lcrRegValue = HW_RD_REG32(baseAddr + UART_LCR);
1431 
1432  /* Switching to Register Operational Mode of operation. */
1433  HW_WR_REG32(baseAddr + UART_LCR, HW_RD_REG32(baseAddr + UART_LCR)
1434  & 0x7FU);
1435 
1436  /* Read Rx Error Status */
1437  errorVal = HW_RD_REG32(baseAddr + UART_LSR) &
1438  (UART_LSR_RX_FIFO_STS_MASK |
1439  UART_LSR_RX_BI_MASK |
1440  UART_LSR_RX_FE_MASK |
1441  UART_LSR_RX_PE_MASK |
1442  UART_LSR_RX_OE_MASK);
1443 
1444  /* Restoring the value of LCR. */
1445  HW_WR_REG32(baseAddr + UART_LCR, lcrRegValue);
1446  }
1447 
1448  /* Read non-erroneous byte from RxFIFO */
1449  readByte = (uint8_t) (HW_RD_REG32(baseAddr + UART_RHR) & 0xFFU);
1450 
1451  return readByte;
1452 }
1453 
1454 #ifdef __cplusplus
1455 }
1456 #endif
1457 
1458 #endif /* #ifndef UART_V0_H_ */
1459 
UART_enableLoopbackMode
void UART_enableLoopbackMode(uint32_t baseAddr)
Function to enable loopback mode. This function is for internal use. Not recommended for customers to...
UART_deinit
void UART_deinit(void)
This function de-initializes the UART module.
UART_Object::readTransferSem
void * readTransferSem
Definition: uart/v0/uart.h:583
UART_ERROR_COUNT
#define UART_ERROR_COUNT
Count Value to check error in the recieved byte
Definition: uart/v0/uart.h:82
UART_TRANSFER_MODE_BLOCKING
#define UART_TRANSFER_MODE_BLOCKING
UART read/write APIs blocks execution. This mode can only be used when called within a Task context.
Definition: uart/v0/uart.h:138
UART_Object::lockObj
SemaphoreP_Object lockObj
Definition: uart/v0/uart.h:581
UART_Transaction_init
static void UART_Transaction_init(UART_Transaction *trans)
Function to initialize the UART_Transaction struct to its defaults.
Definition: uart/v0/uart.h:879
UART_Object::readTransferSemObj
SemaphoreP_Object readTransferSemObj
Definition: uart/v0/uart.h:586
UART_REG_CONFIG_MODE_B
#define UART_REG_CONFIG_MODE_B
Definition: uart/v0/uart.h:396
UART_STOPBITS_1
#define UART_STOPBITS_1
Definition: uart/v0/uart.h:195
UART_TRANSFER_STATUS_SUCCESS
#define UART_TRANSFER_STATUS_SUCCESS
Transaction success.
Definition: uart/v0/uart.h:96
UART_Object::handle
UART_Handle handle
Definition: uart/v0/uart.h:541
UART_intr2Enable
static void UART_intr2Enable(uint32_t baseAddr, uint32_t intrFlag)
This API enables the specified interrupts in the UART mode of operation for IER2.
Definition: uart/v0/uart.h:1301
UART_Object::hwiHandle
void * hwiHandle
Definition: uart/v0/uart.h:593
index
uint16_t index
Definition: tisci_rm_proxy.h:3
UART_Object::writeBuf
const void * writeBuf
Definition: uart/v0/uart.h:548
SystemP.h
UART_Transaction::timeout
uint32_t timeout
Definition: uart/v0/uart.h:431
UART_Handle
void * UART_Handle
A handle that is returned from a UART_open() call.
Definition: uart/v0/uart.h:85
UART_Object::writeTrans
UART_Transaction * writeTrans
Definition: uart/v0/uart.h:572
UART_getHandle
UART_Handle UART_getHandle(uint32_t index)
Function to return a open'ed UART handle given a UART instance index.
UART_writeCancel
int32_t UART_writeCancel(UART_Handle handle, UART_Transaction *trans)
Function to perform UART canceling of current write transaction.
UART_Config
UART global configuration array.
Definition: uart/v0/uart.h:608
UART_Params::writeMode
uint32_t writeMode
Definition: uart/v0/uart.h:473
UART_getIntr2Status
static uint32_t UART_getIntr2Status(uint32_t baseAddr)
This API determines the UART Interrupt Status 2.
Definition: uart/v0/uart.h:1334
UART_Object::writeSizeRemaining
uint32_t writeSizeRemaining
Definition: uart/v0/uart.h:552
UART_CallbackFxn
void(* UART_CallbackFxn)(UART_Handle handle, UART_Transaction *transaction)
The definition of a callback function used by the UART driver when used in UART_TRANSFER_MODE_CALLBAC...
Definition: uart/v0/uart.h:446
UART_Params::eventId
uint16_t eventId
Definition: uart/v0/uart.h:491
UART_Params::dataLength
uint32_t dataLength
Definition: uart/v0/uart.h:463
SystemP_WAIT_FOREVER
#define SystemP_WAIT_FOREVER
Value to use when needing a timeout of infinity or wait forver until resource is available.
Definition: SystemP.h:83
UART_Params::intrPriority
uint8_t intrPriority
Definition: uart/v0/uart.h:493
UART_write
int32_t UART_write(UART_Handle handle, UART_Transaction *trans)
Function to perform UART write operation.
UART_Params::readMode
uint32_t readMode
Definition: uart/v0/uart.h:469
UART_RXTRIGLVL_8
#define UART_RXTRIGLVL_8
Definition: uart/v0/uart.h:265
SemaphoreP.h
UART_intrDisable
static void UART_intrDisable(uint32_t baseAddr, uint32_t intrFlag)
This API disables the specified interrupts in the UART mode of operation.
Definition: uart/v0/uart.h:1249
UART_disableLoopbackMode
void UART_disableLoopbackMode(uint32_t baseAddr)
Function to disable loopback mode. This function is for internal use. Not recommended for customers t...
UART_PARITY_NONE
#define UART_PARITY_NONE
Definition: uart/v0/uart.h:207
UART_Params::rxTrigLvl
uint32_t rxTrigLvl
Definition: uart/v0/uart.h:507
UART_getChar
static uint32_t UART_getChar(uint32_t baseAddr, uint8_t *pChar)
This API reads a byte from the Receiver Buffer Register (RBR). It checks once if any character is rea...
Definition: uart/v0/uart.h:1146
UART_close
void UART_close(UART_Handle handle)
Function to close a UART peripheral specified by the UART handle.
gUartConfig
UART_Config gUartConfig[]
Externally defined driver configuration array.
UART_getIntrIdentityStatus
static uint32_t UART_getIntrIdentityStatus(uint32_t baseAddr)
This API determines the UART Interrupt Status.
Definition: uart/v0/uart.h:1314
UART_Transaction::args
void * args
Definition: uart/v0/uart.h:435
UART_Params::uartDmaIndex
int32_t uartDmaIndex
Definition: uart/v0/uart.h:497
UART_Object::uartDmaHandle
void * uartDmaHandle
Definition: uart/v0/uart.h:597
UART_READ_RETURN_MODE_FULL
#define UART_READ_RETURN_MODE_FULL
Unblock/callback when buffer is full.
Definition: uart/v0/uart.h:166
UART_Object::isOpen
uint32_t isOpen
Definition: uart/v0/uart.h:577
UART_flushTxFifo
void UART_flushTxFifo(UART_Handle handle)
Function to flush a TX FIFO of peripheral specified by the UART handle.
UART_Params::transferMode
uint32_t transferMode
Definition: uart/v0/uart.h:487
UART_Params::skipIntrReg
uint32_t skipIntrReg
Definition: uart/v0/uart.h:495
UART_Config::attrs
UART_Attrs * attrs
Definition: uart/v0/uart.h:609
UART_Object::writeTransferSemObj
SemaphoreP_Object writeTransferSemObj
Definition: uart/v0/uart.h:591
UART_Object::lock
void * lock
Definition: uart/v0/uart.h:579
UART_Object::readCount
uint32_t readCount
Definition: uart/v0/uart.h:559
UART_Params::parityType
uint32_t parityType
Definition: uart/v0/uart.h:467
UART_Object::rxTimeoutCnt
uint32_t rxTimeoutCnt
Definition: uart/v0/uart.h:563
UART_putChar
static void UART_putChar(uint32_t baseAddr, uint8_t byteTx)
This API writes a byte to the Transmitter FIFO without checking for the emptiness of the Transmitter ...
Definition: uart/v0/uart.h:1140
UART_Object::writeCount
uint32_t writeCount
Definition: uart/v0/uart.h:550
UART_Params::hwFlowControl
uint32_t hwFlowControl
Definition: uart/v0/uart.h:479
UART_Object::readSizeRemaining
uint32_t readSizeRemaining
Definition: uart/v0/uart.h:561
UART_Params::readReturnMode
uint32_t readReturnMode
Definition: uart/v0/uart.h:471
HwiP.h
UART_init
void UART_init(void)
This function initializes the UART module.
UART_Params
UART Parameters.
Definition: uart/v0/uart.h:460
UART_readCancel
int32_t UART_readCancel(UART_Handle handle, UART_Transaction *trans)
Function to perform UART canceling of current read transaction.
UART_Params::baudRate
uint32_t baudRate
Definition: uart/v0/uart.h:461
UART_Params::readCallbackFxn
UART_CallbackFxn readCallbackFxn
Definition: uart/v0/uart.h:475
UART_Object::readErrorCnt
uint32_t readErrorCnt
Definition: uart/v0/uart.h:565
UART_Object::writeTransferSem
void * writeTransferSem
Definition: uart/v0/uart.h:588
UART_Transaction::status
uint32_t status
Definition: uart/v0/uart.h:433
UART_Config::object
UART_Object * object
Definition: uart/v0/uart.h:611
UART_Transaction
Data structure used with UART_read() and UART_write()
Definition: uart/v0/uart.h:423
UART_getBaseAddr
uint32_t UART_getBaseAddr(UART_Handle handle)
Function to get base address of UART instance of a particular handle.
UART_Config::traceInstance
uint32_t traceInstance
Definition: uart/v0/uart.h:613
UART_LEN_8
#define UART_LEN_8
Definition: uart/v0/uart.h:184
UART_checkCharsAvailInFifo
static uint32_t UART_checkCharsAvailInFifo(uint32_t baseAddr)
This API checks if the RX FIFO (or RHR in non-FIFO mode) has atleast one byte of data to be read.
Definition: uart/v0/uart.h:1344
UART_Params::intrNum
uint32_t intrNum
Definition: uart/v0/uart.h:489
UART_Attrs::inputClkFreq
uint32_t inputClkFreq
Definition: uart/v0/uart.h:525
UART_open
UART_Handle UART_open(uint32_t index, const UART_Params *prms)
This function opens a given UART peripheral.
UART_CONFIG_MODE_INTERRUPT
#define UART_CONFIG_MODE_INTERRUPT
Definition: uart/v0/uart.h:410
UART_Params::writeCallbackFxn
UART_CallbackFxn writeCallbackFxn
Definition: uart/v0/uart.h:477
HwiP_Object
Opaque Hwi object used with the Hwi APIs.
Definition: HwiP.h:93
UART_Object
UART driver object.
Definition: uart/v0/uart.h:537
UART_Params::hwFlowControlThr
uint32_t hwFlowControlThr
Definition: uart/v0/uart.h:481
UART_Object::readTrans
UART_Transaction * readTrans
Definition: uart/v0/uart.h:570
UART_Params::stopBits
uint32_t stopBits
Definition: uart/v0/uart.h:465
UART_intr2Disable
static void UART_intr2Disable(uint32_t baseAddr, uint32_t intrFlag)
This API disables the specified interrupts in the UART mode of operation for IER2.
Definition: uart/v0/uart.h:1308
UART_Object::readBuf
void * readBuf
Definition: uart/v0/uart.h:557
UART_Params::rxEvtNum
uint32_t rxEvtNum
Definition: uart/v0/uart.h:511
UART_Params_init
static void UART_Params_init(UART_Params *prms)
Function to initialize the UART_Params struct to its defaults.
Definition: uart/v0/uart.h:853
gUartConfigNum
uint32_t gUartConfigNum
Externally defined driver configuration array size.
SemaphoreP_Object
Opaque semaphore object used with the semaphore APIs.
Definition: SemaphoreP.h:59
UART_read
int32_t UART_read(UART_Handle handle, UART_Transaction *trans)
Function to perform UART read operation.
UART_TXTRIGLVL_32
#define UART_TXTRIGLVL_32
Definition: uart/v0/uart.h:282
UART_OPER_MODE_16X
#define UART_OPER_MODE_16X
Definition: uart/v0/uart.h:294
UART_Attrs
UART instance attributes - used during init time.
Definition: uart/v0/uart.h:519
UART_RXTRIGLVL_16
#define UART_RXTRIGLVL_16
Definition: uart/v0/uart.h:266
UART_readLineStatus
static uint32_t UART_readLineStatus(uint32_t baseAddr)
This API reads the line status register value.
Definition: uart/v0/uart.h:1370
UART_Params::txEvtNum
uint32_t txEvtNum
Definition: uart/v0/uart.h:513
UART_getCharFifo
static uint8_t UART_getCharFifo(uint32_t baseAddr, uint8_t *readBuf)
This API reads the data present at the top of the RX FIFO, that is, the data in the Receive Holding R...
Definition: uart/v0/uart.h:1390
UART_Attrs::baseAddr
uint32_t baseAddr
Definition: uart/v0/uart.h:523
UART_Transaction::buf
void * buf
Definition: uart/v0/uart.h:424
UART_intrEnable
static void UART_intrEnable(uint32_t baseAddr, uint32_t intrFlag)
This API enables the specified interrupts in the UART mode of operation.
Definition: uart/v0/uart.h:1174
UART_Object::hwiObj
HwiP_Object hwiObj
Definition: uart/v0/uart.h:595
UART_Object::prms
UART_Params prms
Definition: uart/v0/uart.h:543
UART_Transaction::count
uint32_t count
Definition: uart/v0/uart.h:427
UART_Params::txTrigLvl
uint32_t txTrigLvl
Definition: uart/v0/uart.h:509
UART_Params::operMode
uint32_t operMode
Definition: uart/v0/uart.h:505