82 #include "lpuart_hw_access.h"
106 const uint8_t * txBuff,
108 #if FEATURE_LPUART_HAS_DMA_ENABLE
109 static status_t LPUART_DRV_StartSendDataUsingDma(uint32_t instance,
110 const uint8_t * txBuff,
114 #if FEATURE_LPUART_HAS_DMA_ENABLE
115 static void LPUART_DRV_CompleteSendDataUsingDma(
void * parameter,
edma_chn_status_t status);
120 #if FEATURE_LPUART_HAS_DMA_ENABLE
121 static status_t LPUART_DRV_StartReceiveDataUsingDma(uint32_t instance,
126 #if FEATURE_LPUART_HAS_DMA_ENABLE
127 static void LPUART_DRV_CompleteReceiveDataUsingDma(
void * parameter,
edma_chn_status_t status);
172 DEV_ASSERT(s_lpuartStatePtr[instance] == NULL);
174 #if FEATURE_LPUART_HAS_DMA_ENABLE
181 uint8_t *clearStructPtr = (uint8_t *)lpuartStatePtr;
184 clearStructPtr[idx] = 0;
188 s_lpuartStatePtr[instance] = lpuartStatePtr;
193 #if FEATURE_LPUART_HAS_DMA_ENABLE
194 lpuartStatePtr->rxDMAChannel = lpuartUserConfig->
rxDMAChannel;
195 lpuartStatePtr->txDMAChannel = lpuartUserConfig->
txDMAChannel;
208 LPUART_SetParityMode(base, lpuartUserConfig->
parityMode);
209 LPUART_SetStopBitCount(base, lpuartUserConfig->
stopBitCount);
216 LPUART_SetTransmitterCmd(base,
true);
217 LPUART_SetReceiverCmd(base,
true);
249 uint32_t lpuartSourceClock;
256 DEV_ASSERT(s_lpuartStatePtr[instance] != NULL);
260 while (!LPUART_GetStatusFlag(base, LPUART_TX_COMPLETE)) {}
273 LPUART_SetTransmitterCmd(base,
false);
274 LPUART_SetReceiverCmd(base,
false);
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
362 retVal = LPUART_DRV_StartSendDataUsingDma(instance, txBuff, txSize);
379 #if FEATURE_LPUART_HAS_DMA_ENABLE
382 LPUART_DRV_CompleteSendDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
402 const uint8_t *txBuff,
413 while (!LPUART_GetStatusFlag(base, LPUART_TX_DATA_REG_EMPTY))
416 lpuartState->
txBuff = txBuff;
443 const uint8_t * txBuff,
463 #if FEATURE_LPUART_HAS_DMA_ENABLE
467 retVal = LPUART_DRV_StartSendDataUsingDma(instance, txBuff, txSize);
501 *bytesRemaining = lpuartState->
txSize;;
503 #if FEATURE_LPUART_HAS_DMA_ENABLE
548 #if FEATURE_LPUART_HAS_DMA_ENABLE
552 LPUART_DRV_CompleteSendDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
590 #if FEATURE_LPUART_HAS_DMA_ENABLE
594 retVal = LPUART_DRV_StartReceiveDataUsingDma(instance, rxBuff, rxSize);
611 #if FEATURE_LPUART_HAS_DMA_ENABLE
614 LPUART_DRV_CompleteReceiveDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
646 while (!LPUART_GetStatusFlag(base, LPUART_RX_DATA_REG_FULL))
649 lpuartState->
rxBuff = rxBuff;
665 if (LPUART_GetStatusFlag(base, LPUART_RX_OVERRUN))
667 status = LPUART_ClearStatusFlag(base, LPUART_RX_OVERRUN);
715 #if FEATURE_LPUART_HAS_DMA_ENABLE
719 retVal = LPUART_DRV_StartReceiveDataUsingDma(instance, rxBuff, rxSize);
738 uint32_t * bytesRemaining)
753 *bytesRemaining = lpuartState->
rxSize;
755 #if FEATURE_LPUART_HAS_DMA_ENABLE
798 #if FEATURE_LPUART_HAS_DMA_ENABLE
802 LPUART_DRV_CompleteReceiveDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
823 uint16_t sbr, sbrTemp, i;
824 uint32_t osr, tempDiff, calculatedBaud, baudDiff;
825 uint32_t lpuartSourceClock;
840 sbr = (uint16_t)(lpuartSourceClock / (desiredBaudRate * osr));
841 calculatedBaud = (lpuartSourceClock / (osr * sbr));
843 if (calculatedBaud > desiredBaudRate)
845 baudDiff = calculatedBaud - desiredBaudRate;
849 baudDiff = desiredBaudRate - calculatedBaud;
854 for (i = 5U; i <= 32U; i++)
857 sbrTemp = (uint16_t)(lpuartSourceClock / (desiredBaudRate * i));
859 calculatedBaud = (lpuartSourceClock / (i * sbrTemp));
861 if (calculatedBaud > desiredBaudRate)
863 tempDiff = calculatedBaud - desiredBaudRate;
867 tempDiff = desiredBaudRate - calculatedBaud;
870 if (tempDiff <= baudDiff)
880 if ((osr > 3U) && (osr < 8U))
882 LPUART_SetBothEdgeSamplingCmd(base,
true);
886 LPUART_SetOversamplingRatio(base, (osr - 1U));
889 LPUART_SetBaudRateDivisor(base, sbr);
907 uint32_t lpuartSourceClock;
914 osr = LPUART_GetOversamplingRatio(base);
915 sbr = LPUART_GetBaudRateDivisor(base);
917 *configuredBaudRate = (lpuartSourceClock / ((osr + 1UL) * sbr));
946 if (LPUART_GetIntMode(base, LPUART_INT_RX_DATA_REG_FULL))
948 if (LPUART_GetStatusFlag(base, LPUART_RX_DATA_REG_FULL))
970 lpuartState->
rxSize -= 2U;
974 if (lpuartState->
rxSize == 0U)
984 if (LPUART_GetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY))
986 if (LPUART_GetStatusFlag(base, LPUART_TX_DATA_REG_EMPTY))
989 if (lpuartState->
txSize > 0U)
1011 lpuartState->
txSize -= 2U;
1015 if (lpuartState->
txSize == 0U)
1026 if (LPUART_GetStatusFlag(base, LPUART_RX_OVERRUN))
1030 (void)LPUART_ClearStatusFlag(base, LPUART_RX_OVERRUN);
1043 const uint8_t * txBuff,
1061 ((txSize & 1U) == 0U));
1064 lpuartState->
txBuff = txBuff;
1065 lpuartState->
txSize = txSize;
1070 LPUART_SetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY,
true);
1075 #if FEATURE_LPUART_HAS_DMA_ENABLE
1084 static status_t LPUART_DRV_StartSendDataUsingDma(uint32_t instance,
1085 const uint8_t * txBuff,
1103 lpuartState->
txBuff = txBuff;
1120 LPUART_SetTxDmaCmd(base,
true);
1142 LPUART_SetIntMode(base, LPUART_INT_TX_DATA_REG_EMPTY,
false);
1155 #if FEATURE_LPUART_HAS_DMA_ENABLE
1165 static void LPUART_DRV_CompleteSendDataUsingDma(
void * parameter,
edma_chn_status_t status)
1172 uint32_t instance = ((uint32_t)parameter);
1177 LPUART_SetTxDmaCmd(base,
false);
1228 ((rxSize & 1U) == 0U));
1233 lpuartState->
rxBuff = rxBuff;
1234 lpuartState->
rxSize = rxSize;
1238 LPUART_SetIntMode(base, LPUART_INT_RX_OVERRUN,
true);
1241 LPUART_SetIntMode(base, LPUART_INT_RX_DATA_REG_FULL,
true);
1246 #if FEATURE_LPUART_HAS_DMA_ENABLE
1255 static status_t LPUART_DRV_StartReceiveDataUsingDma(uint32_t instance,
1287 LPUART_SetRxDmaCmd(base,
true);
1290 lpuartState->
rxBuff = rxBuff;
1297 LPUART_SetIntMode(base, LPUART_INT_RX_OVERRUN,
true);
1319 LPUART_SetIntMode(base, LPUART_INT_RX_DATA_REG_FULL,
false);
1320 LPUART_SetIntMode(base, LPUART_INT_RX_OVERRUN,
false);
1333 #if FEATURE_LPUART_HAS_DMA_ENABLE
1343 static void LPUART_DRV_CompleteReceiveDataUsingDma(
void * parameter,
edma_chn_status_t status)
1350 uint32_t instance = ((uint32_t)parameter);
1355 LPUART_SetRxDmaCmd(base,
false);
1359 LPUART_SetIntMode(base, LPUART_INT_RX_OVERRUN,
false);
1392 const uint8_t *txBuff = lpuartState->
txBuff;
1397 LPUART_Putchar(base, *txBuff);
1402 data = (uint16_t)(*txBuff);
1404 data |= (uint16_t)(((uint16_t)(*txBuff)) << 8U);
1407 LPUART_Putchar9(base, data);
1412 data = (uint16_t)(*txBuff);
1414 data |= (uint16_t)(((uint16_t)(*txBuff)) << 8U);
1417 LPUART_Putchar10(base, data);
1432 const LPUART_Type * base = s_lpuartBase[instance];
1434 uint8_t *rxBuff = lpuartState->
rxBuff;
1439 LPUART_Getchar(base, rxBuff);
1444 LPUART_Getchar9(base, &data);
1447 *rxBuff = (uint8_t)(data & 0xFFU);
1450 *rxBuff = (uint8_t)(data >> 8U);
1455 LPUART_Getchar10(base, &data);
1458 *rxBuff = (uint8_t)(data & 0xFFU);
1461 *rxBuff = (uint8_t)(data >> 8U);
status_t LPUART_DRV_AbortSendingData(uint32_t instance)
Terminates a non-blocking transmission early.
static void LPUART_DRV_CompleteReceiveDataUsingInt(uint32_t instance)
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.
static LPUART_Type *const s_lpuartBase[LPUART_INSTANCE_COUNT]
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.
uint32_t EDMA_DRV_GetRemainingMajorIterationsCount(uint8_t channel)
Returns the remaining major loop iteration count.
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...
static const IRQn_Type s_lpuartRxTxIrqId[LPUART_INSTANCE_COUNT]
volatile bool isRxBlocking
void DefaultISR(void)
Default ISR.
status_t LPUART_DRV_AbortReceivingData(uint32_t instance)
Terminates a non-blocking receive early.
uart_callback_t rxCallback
status_t EDMA_DRV_StopChannel(uint8_t channel)
Stops the eDMA channel.
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.
static void LPUART_DRV_CompleteSendDataUsingInt(uint32_t instance)
lpuart_bit_count_per_char_t bitCountPerChar
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.
clock_names_t
Clock names.
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...
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.
static const clock_names_t s_lpuartClkNames[LPUART_INSTANCE_COUNT]
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
status_t LPUART_DRV_SetBaudRate(uint32_t instance, uint32_t desiredBaudRate)
Configures the LPUART baud rate.
status_t LPUART_DRV_Init(uint32_t instance, lpuart_state_t *lpuartStatePtr, const lpuart_user_config_t *lpuartUserConfig)
Initializes an LPUART operation instance.
uart_callback_t txCallback
static status_t LPUART_DRV_StartReceiveDataUsingInt(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
status_t OSIF_SemaWait(semaphore_t *const pSem, const uint32_t timeout)
Decrement a semaphore with timeout.
status_t EDMA_DRV_StartChannel(uint8_t channel)
Starts an eDMA channel.
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...
#define LPUART_CLOCK_NAMES
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.
volatile bool isTxBlocking
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)
static lpuart_state_t * s_lpuartStatePtr[LPUART_INSTANCE_COUNT]
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.
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.
status_t EDMA_DRV_ConfigMultiBlockTransfer(uint8_t channel, 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.
status_t EDMA_DRV_InstallCallback(uint8_t channel, edma_callback_t callback, void *parameter)
Registers the callback function and the parameter for eDMA channel.
#define LPUART_RX_TX_IRQS
isr_t g_lpuartIsr[LPUART_INSTANCE_COUNT]
IRQn_Type
Defines the Interrupt Numbers definitions.
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