86 #include "lpuart_hw_access.h"
110 const uint8_t * txBuff,
117 #if FEATURE_LPUART_HAS_DMA_ENABLE
121 const uint8_t * txBuff,
170 uint32_t lpuartSourceClock;
180 DEV_ASSERT(s_lpuartStatePtr[instance] == NULL);
182 #if FEATURE_LPUART_HAS_DMA_ENABLE
189 uint8_t *clearStructPtr = (uint8_t *)lpuartStatePtr;
192 clearStructPtr[idx] = 0;
196 s_lpuartStatePtr[instance] = lpuartStatePtr;
201 #if FEATURE_LPUART_HAS_DMA_ENABLE
216 LPUART_SetParityMode(base, lpuartUserConfig->
parityMode);
217 LPUART_SetStopBitCount(base, lpuartUserConfig->
stopBitCount);
253 uint32_t lpuartSourceClock;
260 DEV_ASSERT(s_lpuartStatePtr[instance] != NULL);
264 while (!LPUART_GetStatusFlag(base, LPUART_TX_COMPLETE)) {}
277 s_lpuartStatePtr[instance] = NULL;
291 void * callbackParam)
301 return currentCallback;
314 void * callbackParam)
324 return currentCallback;
336 const uint8_t * txBuff,
358 #if FEATURE_LPUART_HAS_DMA_ENABLE
381 #if FEATURE_LPUART_HAS_DMA_ENABLE
403 const uint8_t *txBuff,
415 ((txSize & 1U) == 0U));
418 LPUART_SetTransmitterCmd(base,
true);
422 while (!LPUART_GetStatusFlag(base, LPUART_TX_DATA_REG_EMPTY))
425 lpuartState->
txBuff = txBuff;
442 LPUART_SetTransmitterCmd(base,
false);
455 const uint8_t * txBuff,
475 #if FEATURE_LPUART_HAS_DMA_ENABLE
504 if (bytesRemaining != NULL)
514 *bytesRemaining = lpuartState->
txSize;;
516 #if FEATURE_LPUART_HAS_DMA_ENABLE
564 #if FEATURE_LPUART_HAS_DMA_ENABLE
605 #if FEATURE_LPUART_HAS_DMA_ENABLE
628 #if FEATURE_LPUART_HAS_DMA_ENABLE
662 ((rxSize & 1U) == 0U));
669 while (!LPUART_GetStatusFlag(base, LPUART_RX_DATA_REG_FULL))
672 lpuartState->
rxBuff = rxBuff;
688 if (LPUART_GetStatusFlag(base, LPUART_RX_OVERRUN))
692 (void)LPUART_ClearStatusFlag(base, LPUART_RX_OVERRUN);
695 else if (LPUART_GetStatusFlag(base, LPUART_FRAME_ERR))
699 (void)LPUART_ClearStatusFlag(base, LPUART_FRAME_ERR);
702 else if (LPUART_GetStatusFlag(base, LPUART_NOISE_DETECT))
706 (void)LPUART_ClearStatusFlag(base, LPUART_NOISE_DETECT);
709 else if (LPUART_GetStatusFlag(base, LPUART_PARITY_ERR))
713 (void)LPUART_ClearStatusFlag(base, LPUART_PARITY_ERR);
761 #if FEATURE_LPUART_HAS_DMA_ENABLE
784 uint32_t * bytesRemaining)
790 if (bytesRemaining != NULL)
800 *bytesRemaining = lpuartState->
rxSize;
802 #if FEATURE_LPUART_HAS_DMA_ENABLE
848 #if FEATURE_LPUART_HAS_DMA_ENABLE
872 uint16_t sbr, sbrTemp, i;
873 uint32_t osr, tempDiff, calculatedBaud, baudDiff;
874 uint32_t lpuartSourceClock;
880 if (lpuartState != NULL)
899 DEV_ASSERT(lpuartSourceClock >= (desiredBaudRate * 4U));
906 sbr = (uint16_t)(lpuartSourceClock / (desiredBaudRate * osr));
907 calculatedBaud = (lpuartSourceClock / (osr * sbr));
909 if (calculatedBaud > desiredBaudRate)
911 baudDiff = calculatedBaud - desiredBaudRate;
915 baudDiff = desiredBaudRate - calculatedBaud;
920 for (i = 5U; i <= 32U; i++)
923 sbrTemp = (uint16_t)(lpuartSourceClock / (desiredBaudRate * i));
925 calculatedBaud = (lpuartSourceClock / (i * sbrTemp));
927 if (calculatedBaud > desiredBaudRate)
929 tempDiff = calculatedBaud - desiredBaudRate;
933 tempDiff = desiredBaudRate - calculatedBaud;
936 if (tempDiff <= baudDiff)
946 if ((osr > 3U) && (osr < 8U))
948 LPUART_SetBothEdgeSamplingCmd(base,
true);
952 LPUART_SetOversamplingRatio(base, (osr - 1U));
955 LPUART_SetBaudRateDivisor(base, sbr);
974 uint32_t lpuartSourceClock;
981 osr = LPUART_GetOversamplingRatio(base);
982 sbr = LPUART_GetBaudRateDivisor(base);
984 *configuredBaudRate = (lpuartSourceClock / ((osr + 1UL) * sbr));
997 const uint8_t * txBuff,
1005 lpuartState->
txBuff = txBuff;
1006 lpuartState->
txSize = txSize;
1029 lpuartState->
rxBuff = rxBuff;
1030 lpuartState->
rxSize = rxSize;
1061 if (LPUART_GetIntMode(base, LPUART_INT_RX_DATA_REG_FULL))
1063 if (LPUART_GetStatusFlag(base, LPUART_RX_DATA_REG_FULL))
1077 lpuartState->
rxSize -= 2U;
1081 if (lpuartState->
rxSize == 0U)
1091 if (lpuartState->
rxSize == 0U)
1106 if (LPUART_GetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY))
1108 if (LPUART_GetStatusFlag(base, LPUART_TX_DATA_REG_EMPTY))
1111 if (lpuartState->
txSize > 0U)
1125 lpuartState->
txSize -= 2U;
1129 if (lpuartState->
txSize == 0U)
1138 if (lpuartState->
txSize == 0U)
1140 LPUART_SetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY,
false);
1148 if (LPUART_GetIntMode(base, LPUART_INT_TX_COMPLETE))
1150 if (LPUART_GetStatusFlag(base, LPUART_TX_COMPLETE))
1152 if (lpuartState->
txSize == 0U)
1159 #if FEATURE_LPUART_HAS_DMA_ENABLE
1176 if (LPUART_GetStatusFlag(base, LPUART_RX_OVERRUN))
1185 #if FEATURE_LPUART_HAS_DMA_ENABLE
1199 (void)LPUART_ClearStatusFlag(base, LPUART_RX_OVERRUN);
1202 else if (LPUART_GetStatusFlag(base, LPUART_FRAME_ERR))
1211 #if FEATURE_LPUART_HAS_DMA_ENABLE
1225 (void)LPUART_ClearStatusFlag(base, LPUART_FRAME_ERR);
1228 else if (LPUART_GetStatusFlag(base, LPUART_PARITY_ERR))
1237 #if FEATURE_LPUART_HAS_DMA_ENABLE
1251 (void)LPUART_ClearStatusFlag(base, LPUART_PARITY_ERR);
1254 else if (LPUART_GetStatusFlag(base, LPUART_NOISE_DETECT))
1263 #if FEATURE_LPUART_HAS_DMA_ENABLE
1277 (void)LPUART_ClearStatusFlag(base, LPUART_NOISE_DETECT);
1294 const uint8_t * txBuff,
1312 ((txSize & 1U) == 0U));
1315 lpuartState->
txBuff = txBuff;
1316 lpuartState->
txSize = txSize;
1321 LPUART_SetTransmitterCmd(base,
true);
1324 LPUART_SetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY,
true);
1325 LPUART_SetIntMode(base, LPUART_INT_TX_COMPLETE,
true);
1330 #if FEATURE_LPUART_HAS_DMA_ENABLE
1340 const uint8_t * txBuff,
1358 lpuartState->
txBuff = txBuff;
1359 lpuartState->
txSize = 0U;
1376 LPUART_SetTransmitterCmd(base,
true);
1379 LPUART_SetTxDmaCmd(base,
true);
1382 LPUART_SetIntMode(base, LPUART_INT_TX_COMPLETE,
true);
1411 LPUART_SetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY,
false);
1415 LPUART_SetIntMode(base, LPUART_INT_TX_COMPLETE,
false);
1418 LPUART_SetTransmitterCmd(base,
false);
1430 #if FEATURE_LPUART_HAS_DMA_ENABLE
1447 uint32_t instance = ((uint32_t)parameter);
1460 if (lpuartState->
txSize > 0U)
1467 lpuartState->
txSize = 0U;
1502 ((rxSize & 1U) == 0U));
1507 lpuartState->
rxBuff = rxBuff;
1508 lpuartState->
rxSize = rxSize;
1512 LPUART_SetReceiverCmd(base,
true);
1515 LPUART_SetErrorInterrupts(base,
true);
1518 LPUART_SetIntMode(base, LPUART_INT_RX_DATA_REG_FULL,
true);
1523 #if FEATURE_LPUART_HAS_DMA_ENABLE
1564 lpuartState->
rxBuff = rxBuff;
1565 lpuartState->
rxSize = 0U;
1570 LPUART_SetReceiverCmd(base,
true);
1573 LPUART_SetErrorInterrupts(base,
true);
1576 LPUART_SetRxDmaCmd(base,
true);
1599 LPUART_SetReceiverCmd(base,
false);
1602 LPUART_SetErrorInterrupts(base,
false);
1605 LPUART_Getchar(base, &tmpByte);
1608 LPUART_SetIntMode(base, LPUART_INT_RX_DATA_REG_FULL,
false);
1624 #if FEATURE_LPUART_HAS_DMA_ENABLE
1641 uint32_t instance = ((uint32_t)parameter);
1660 if (lpuartState->
rxSize > 0U)
1667 lpuartState->
rxSize = 0U;
1699 const uint8_t *txBuff = lpuartState->
txBuff;
1704 LPUART_Putchar(base, *txBuff);
1709 data = (uint16_t)(*txBuff);
1711 data |= (uint16_t)(((uint16_t)(*txBuff)) << 8U);
1714 LPUART_Putchar9(base, data);
1719 data = (uint16_t)(*txBuff);
1721 data |= (uint16_t)(((uint16_t)(*txBuff)) << 8U);
1724 LPUART_Putchar10(base, data);
1739 const LPUART_Type * base = s_lpuartBase[instance];
1741 uint8_t *rxBuff = lpuartState->
rxBuff;
1746 LPUART_Getchar(base, rxBuff);
1751 LPUART_Getchar9(base, &data);
1754 *rxBuff = (uint8_t)(data & 0xFFU);
1757 *rxBuff = (uint8_t)(data >> 8U);
1762 LPUART_Getchar10(base, &data);
1765 *rxBuff = (uint8_t)(data & 0xFFU);
1768 *rxBuff = (uint8_t)(data >> 8U);
1772 #if FEATURE_LPUART_HAS_DMA_ENABLE
1788 LPUART_SetTxDmaCmd(base,
false);
1794 LPUART_SetIntMode(base, LPUART_INT_TX_COMPLETE,
false);
1797 LPUART_SetTransmitterCmd(base,
false);
1830 LPUART_SetReceiverCmd(base,
false);
1833 LPUART_SetErrorInterrupts(base,
false);
1836 LPUART_SetRxDmaCmd(base,
false);
status_t LPUART_DRV_AbortSendingData(uint32_t instance)
Terminates a non-blocking transmission early.
void EDMA_DRV_SetMajorLoopIterationCount(uint8_t virtualChannel, uint32_t majorLoopCount)
Configures the number of major loop iterations.
static void LPUART_DRV_CompleteReceiveDataUsingInt(uint32_t instance)
static status_t LPUART_DRV_StartReceiveDataUsingDma(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
uint32_t EDMA_DRV_GetRemainingMajorIterationsCount(uint8_t virtualChannel)
Returns the remaining major loop iteration count.
status_t EDMA_DRV_InstallCallback(uint8_t virtualChannel, edma_callback_t callback, void *parameter)
Registers the callback function and the parameter for eDMA channel.
status_t LPUART_DRV_SendDataBlocking(uint32_t instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Sends data out through the LPUART module using a blocking method.
static void LPUART_DRV_GetData(uint32_t instance)
uart_callback_t LPUART_DRV_InstallTxCallback(uint32_t instance, uart_callback_t function, void *callbackParam)
Installs callback function for the LPUART transmit.
void LPUART_DRV_SendDataPolling(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
Send out multiple bytes of data using polling method.
status_t OSIF_SemaDestroy(const semaphore_t *const pSem)
Destroys a previously created semaphore.
status_t LPUART_DRV_Deinit(uint32_t instance)
Shuts down the LPUART by disabling interrupts and transmitter/receiver.
status_t LPUART_DRV_SendData(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
Sends data out through the LPUART module using a non-blocking method. This enables an a-sync method f...
volatile bool isRxBlocking
void DefaultISR(void)
Default ISR.
status_t EDMA_DRV_ConfigMultiBlockTransfer(uint8_t virtualChannel, edma_transfer_type_t type, uint32_t srcAddr, uint32_t destAddr, edma_transfer_size_t transferSize, uint32_t blockSize, uint32_t blockCount, bool disableReqOnCompletion)
Configures a multiple block data transfer with DMA.
static lpuart_state_t * s_lpuartStatePtr[(2u)]
status_t LPUART_DRV_AbortReceivingData(uint32_t instance)
Terminates a non-blocking receive early.
static const IRQn_Type s_lpuartRxTxIrqId[(2u)]
uart_callback_t rxCallback
status_t LPUART_DRV_ReceiveDataPolling(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Receive multiple bytes of data using polling method.
status_t OSIF_SemaCreate(semaphore_t *const pSem, const uint8_t initValue)
Creates a semaphore with a given value.
#define LPUART_CLOCK_NAMES
static void LPUART_DRV_CompleteSendDataUsingInt(uint32_t instance)
static status_t LPUART_DRV_StartSendDataUsingDma(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
lpuart_bit_count_per_char_t bitCountPerChar
status_t EDMA_DRV_StopChannel(uint8_t virtualChannel)
Stops the eDMA channel.
void INT_SYS_DisableIRQ(IRQn_Type irqNumber)
Disables an interrupt for a given IRQ number.
lpuart_transfer_type_t transferType
lpuart_parity_mode_t parityMode
edma_chn_status_t
Channel status for eDMA channel.
status_t LPUART_DRV_ReceiveData(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Gets data from the LPUART module by using a non-blocking method. This enables an a-sync method for re...
void EDMA_DRV_SetDestAddr(uint8_t virtualChannel, uint32_t address)
Configures the destination address for the eDMA channel.
status_t CLOCK_SYS_GetFreq(clock_names_t clockName, uint32_t *frequency)
Gets the clock frequency for a specific clock name.
static void LPUART_DRV_PutData(uint32_t instance)
void LPUART_DRV_IRQHandler(uint32_t instance)
uart_callback_t LPUART_DRV_InstallRxCallback(uint32_t instance, uart_callback_t function, void *callbackParam)
Installs callback function for the LPUART receive.
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
IRQn_Type
Defines the Interrupt Numbers definitions.
status_t LPUART_DRV_SetBaudRate(uint32_t instance, uint32_t desiredBaudRate)
Configures the LPUART baud rate.
static void LPUART_DRV_StopTxDma(uint32_t instance)
status_t LPUART_DRV_Init(uint32_t instance, lpuart_state_t *lpuartStatePtr, const lpuart_user_config_t *lpuartUserConfig)
Initializes an LPUART operation instance.
status_t LPUART_DRV_SetTxBuffer(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
Sets the internal driver reference to the tx buffer.
uart_callback_t txCallback
static status_t LPUART_DRV_StartReceiveDataUsingInt(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
void EDMA_DRV_SetSrcAddr(uint8_t virtualChannel, uint32_t address)
Configures the source address for the eDMA channel.
static void LPUART_DRV_TxDmaCallback(void *parameter, edma_chn_status_t status)
status_t OSIF_SemaWait(semaphore_t *const pSem, const uint32_t timeout)
Decrement a semaphore with timeout.
volatile status_t transmitStatus
status_t LPUART_DRV_ReceiveDataBlocking(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Gets data from the LPUART module by using a blocking method. Blocking means that the function does no...
static void LPUART_DRV_RxDmaCallback(void *parameter, edma_chn_status_t status)
static status_t LPUART_DRV_StartSendDataUsingInt(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
status_t OSIF_SemaPost(semaphore_t *const pSem)
Increment a semaphore.
static LPUART_Type *const s_lpuartBase[(2u)]
volatile bool isTxBlocking
status_t EDMA_DRV_StartChannel(uint8_t virtualChannel)
Starts an eDMA channel.
LPUART configuration structure.
#define LPUART_INSTANCE_COUNT
void INT_SYS_EnableIRQ(IRQn_Type irqNumber)
Enables an interrupt for a given IRQ number.
void(* uart_callback_t)(void *driverState, uart_event_t event, void *userData)
Callback for all peripherals which support UART features.
void(* edma_callback_t)(void *parameter, edma_chn_status_t status)
Definition for the eDMA channel callback function.
void LPUART_DRV_GetBaudRate(uint32_t instance, uint32_t *configuredBaudRate)
Returns the LPUART baud rate.
clock_names_t
Clock names.
status_t LPUART_DRV_GetTransmitStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous transmit is complete.
lpuart_transfer_type_t transferType
void(* isr_t)(void)
Interrupt handler type.
lpuart_bit_count_per_char_t bitCountPerChar
volatile status_t receiveStatus
Runtime state of the LPUART driver.
status_t LPUART_DRV_GetReceiveStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous receive is complete.
#define LPUART_RX_TX_IRQS
status_t LPUART_DRV_SetRxBuffer(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Sets the internal driver reference to the rx buffer.
static void LPUART_DRV_StopRxDma(uint32_t instance)
static const clock_names_t s_lpuartClkNames[(2u)]
void INT_SYS_InstallHandler(IRQn_Type irqNumber, const isr_t newHandler, isr_t *const oldHandler)
Installs an interrupt handler routine for a given IRQ number.
lpuart_stop_bit_count_t stopBitCount