97 const uint8_t * txBuff,
99 #if FEATURE_LPUART_HAS_DMA_ENABLE
100 static status_t LPUART_DRV_StartSendDataUsingDma(uint32_t instance,
101 const uint8_t * txBuff,
105 #if FEATURE_LPUART_HAS_DMA_ENABLE
106 static void LPUART_DRV_CompleteSendDataUsingDma(
void * parameter,
edma_chn_status_t status);
111 #if FEATURE_LPUART_HAS_DMA_ENABLE
112 static status_t LPUART_DRV_StartReceiveDataUsingDma(uint32_t instance,
117 #if FEATURE_LPUART_HAS_DMA_ENABLE
118 static void LPUART_DRV_CompleteReceiveDataUsingDma(
void * parameter,
edma_chn_status_t status);
159 uint32_t lpuartSourceClock;
171 DEV_ASSERT(g_lpuartStatePtr[instance] == NULL);
173 #if FEATURE_LPUART_HAS_DMA_ENABLE
180 uint8_t *clearStructPtr = (uint8_t *)lpuartStatePtr;
183 clearStructPtr[idx] = 0;
187 g_lpuartStatePtr[instance] = lpuartStatePtr;
192 #if FEATURE_LPUART_HAS_DMA_ENABLE
248 uint32_t lpuartSourceClock;
255 DEV_ASSERT(g_lpuartStatePtr[instance] != NULL);
276 g_lpuartStatePtr[instance] = NULL;
290 void * callbackParam)
300 return currentCallback;
313 void * callbackParam)
323 return currentCallback;
335 const uint8_t * txBuff,
357 #if FEATURE_LPUART_HAS_DMA_ENABLE
361 retVal = LPUART_DRV_StartSendDataUsingDma(instance, txBuff, txSize);
378 #if FEATURE_LPUART_HAS_DMA_ENABLE
381 LPUART_DRV_CompleteSendDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
403 const uint8_t * txBuff,
423 #if FEATURE_LPUART_HAS_DMA_ENABLE
427 retVal = LPUART_DRV_StartSendDataUsingDma(instance, txBuff, txSize);
462 *bytesRemaining = lpuartState->
txSize;;
464 #if FEATURE_LPUART_HAS_DMA_ENABLE
509 #if FEATURE_LPUART_HAS_DMA_ENABLE
513 LPUART_DRV_CompleteSendDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
551 #if FEATURE_LPUART_HAS_DMA_ENABLE
555 retVal = LPUART_DRV_StartReceiveDataUsingDma(instance, rxBuff, rxSize);
572 #if FEATURE_LPUART_HAS_DMA_ENABLE
575 LPUART_DRV_CompleteReceiveDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
620 #if FEATURE_LPUART_HAS_DMA_ENABLE
624 retVal = LPUART_DRV_StartReceiveDataUsingDma(instance, rxBuff, rxSize);
643 uint32_t * bytesRemaining)
659 *bytesRemaining = lpuartState->
rxSize;
661 #if FEATURE_LPUART_HAS_DMA_ENABLE
704 #if FEATURE_LPUART_HAS_DMA_ENABLE
708 LPUART_DRV_CompleteReceiveDataUsingDma(((
void *)instance),
EDMA_CHN_NORMAL);
765 lpuartState->
rxSize -= 2U;
769 if (lpuartState->
rxSize == 0U)
784 if (lpuartState->
txSize > 0U)
806 lpuartState->
txSize -= 2U;
810 if (lpuartState->
txSize == 0U)
838 const uint8_t * txBuff,
856 ((txSize & 1U) == 0U));
859 lpuartState->
txBuff = txBuff;
860 lpuartState->
txSize = txSize;
870 #if FEATURE_LPUART_HAS_DMA_ENABLE
879 static status_t LPUART_DRV_StartSendDataUsingDma(uint32_t instance,
880 const uint8_t * txBuff,
899 lpuartState->
txBuff = txBuff;
953 #if FEATURE_LPUART_HAS_DMA_ENABLE
963 static void LPUART_DRV_CompleteSendDataUsingDma(
void * parameter,
edma_chn_status_t status)
970 uint32_t instance = ((uint32_t)parameter);
1026 ((rxSize & 1U) == 0U));
1031 lpuartState->
rxBuff = rxBuff;
1032 lpuartState->
rxSize = rxSize;
1044 #if FEATURE_LPUART_HAS_DMA_ENABLE
1053 static status_t LPUART_DRV_StartReceiveDataUsingDma(uint32_t instance,
1090 lpuartState->
rxBuff = rxBuff;
1133 #if FEATURE_LPUART_HAS_DMA_ENABLE
1143 static void LPUART_DRV_CompleteReceiveDataUsingDma(
void * parameter,
edma_chn_status_t status)
1150 uint32_t instance = ((uint32_t)parameter);
1192 const uint8_t *txBuff = lpuartState->
txBuff;
1202 data = (uint16_t)(*txBuff);
1204 data |= (uint16_t)(((uint16_t)(*txBuff)) << 8U);
1212 data = (uint16_t)(*txBuff);
1214 data |= (uint16_t)(((uint16_t)(*txBuff)) << 8U);
1234 uint8_t *rxBuff = lpuartState->
rxBuff;
1247 *rxBuff = (uint8_t)(data & 0xFFU);
1250 *rxBuff = (uint8_t)(data >> 8U);
1258 *rxBuff = (uint8_t)(data & 0xFFU);
1261 *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)
const isr_t g_lpuartIsr[LPUART_INSTANCE_COUNT]
Table to save LPUART ISRs.
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.
void LPUART_HAL_Putchar9(LPUART_Type *base, uint16_t data)
Sends the LPUART 9-bit character.
const clock_names_t g_lpuartClkNames[LPUART_INSTANCE_COUNT]
Table to save LPUART indexes in PCC register map for clock configuration.
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 LPUART_DRV_AbortReceivingData(uint32_t instance)
Terminates a non-blocking receive early.
void(* lpuart_rx_callback_t)(uint32_t instance, void *lpuartState)
LPUART receive callback function type.
lpuart_tx_callback_t LPUART_DRV_InstallTxCallback(uint32_t instance, lpuart_tx_callback_t function, void *callbackParam)
Installs callback function for the LPUART transmit.
void(* lpuart_tx_callback_t)(uint32_t instance, void *lpuartState)
LPUART transmit callback function type.
status_t EDMA_DRV_StopChannel(uint8_t channel)
Stops the eDMA channel.
lpuart_tx_callback_t txCallback
void EDMA_HAL_TCDSetMajorCount(DMA_Type *base, uint32_t channel, uint32_t count)
Sets the major iteration count according to minor loop channel link setting.
uint32_t EDMA_HAL_TCDGetCurrentMajorCount(const DMA_Type *base, uint32_t channel)
Returns the current major iteration count.
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)
void LPUART_HAL_SetParityMode(LPUART_Type *base, lpuart_parity_mode_t parityModeType)
Configures parity mode in the LPUART controller.
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
lpuart_rx_callback_t LPUART_DRV_InstallRxCallback(uint32_t instance, lpuart_rx_callback_t function, void *callbackParam)
Installs callback function for the LPUART receive.
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...
bool LPUART_HAL_GetIntMode(const LPUART_Type *base, lpuart_interrupt_t intSrc)
Returns LPUART module interrupts state.
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)
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
static void LPUART_HAL_SetTxDmaCmd(LPUART_Type *base, bool enable)
Configures DMA requests.
status_t LPUART_DRV_Init(uint32_t instance, lpuart_state_t *lpuartStatePtr, const lpuart_user_config_t *lpuartUserConfig)
Initializes an LPUART operation instance.
lpuart_state_t * g_lpuartStatePtr[LPUART_INSTANCE_COUNT]
lpuart_rx_callback_t rxCallback
static status_t LPUART_DRV_StartReceiveDataUsingInt(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
static void EDMA_HAL_TCDSetDisableDmaRequestAfterTCDDoneCmd(DMA_Type *base, uint32_t channel, bool disable)
Disables/Enables the DMA request after the major loop completes for the TCD.
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.
LPUART_Type *const g_lpuartBase[LPUART_INSTANCE_COUNT]
Table of base addresses for LPUART instances.
const IRQn_Type g_lpuartRxTxIrqId[LPUART_INSTANCE_COUNT]
Table to save LPUART IRQ enumeration numbers defined in the CMSIS header file.
volatile status_t transmitStatus
clock_names_t
Clock names.
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_HAL_SetTransmitterCmd(LPUART_Type *base, bool enable)
Enable/Disable the LPUART transmitter.
static void LPUART_HAL_Putchar(LPUART_Type *base, uint8_t data)
Sends the LPUART 8-bit character.
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
status_t LPUART_HAL_ClearStatusFlag(LPUART_Type *base, lpuart_status_flag_t statusFlag)
LPUART clears an individual status flag.
LPUART configuration structure.
void LPUART_HAL_Getchar9(const LPUART_Type *base, uint16_t *readData)
Gets the LPUART 9-bit character.
DMA_Type *const g_edmaBase[DMA_INSTANCE_COUNT]
Array for the eDMA module register base address.
#define LPUART_INSTANCE_COUNT
void INT_SYS_EnableIRQ(IRQn_Type irqNumber)
Enables an interrupt for a given IRQ number.
void LPUART_HAL_Getchar10(const LPUART_Type *base, uint16_t *readData)
Gets the LPUART 10-bit character.
status_t LPUART_HAL_SetBaudRate(LPUART_Type *base, uint32_t sourceClockInHz, uint32_t desiredBaudRate)
Configures the LPUART baud rate.
static void LPUART_HAL_SetReceiverCmd(LPUART_Type *base, bool enable)
Enable/Disable the LPUART receiver.
void(* edma_callback_t)(void *parameter, edma_chn_status_t status)
Definition for the eDMA channel callback function.
void LPUART_HAL_Putchar10(LPUART_Type *base, uint16_t data)
Sends the LPUART 10-bit character (Note: Feature available on select LPUART instances).
status_t EDMA_DRV_ConfigSingleBlockTransfer(uint8_t channel, edma_transfer_type_t type, uint32_t srcAddr, uint32_t destAddr, edma_transfer_size_t transferSize, uint32_t dataBufferSize)
Configures a simple single block data transfer with DMA.
void LPUART_HAL_SetBitCountPerChar(LPUART_Type *base, lpuart_bit_count_per_char_t bitCountPerChar)
Configures the number of bits per character in the LPUART controller.
status_t LPUART_DRV_GetTransmitStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous transmit is complete.
lpuart_transfer_type_t transferType
void LPUART_HAL_SetIntMode(LPUART_Type *base, lpuart_interrupt_t intSrc, bool enable)
Configures the LPUART module interrupts.
void(* isr_t)(void)
Interrupt handler type.
bool LPUART_HAL_GetStatusFlag(const LPUART_Type *base, lpuart_status_flag_t statusFlag)
LPUART get status flag.
lpuart_bit_count_per_char_t bitCountPerChar
volatile status_t receiveStatus
static void LPUART_HAL_SetRxDmaCmd(LPUART_Type *base, bool enable)
Configures DMA requests.
Runtime state of the LPUART driver.
static void LPUART_HAL_SetStopBitCount(LPUART_Type *base, lpuart_stop_bit_count_t stopBitCount)
Configures the number of stop bits in the LPUART controller.
status_t LPUART_DRV_GetReceiveStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous receive is complete.
status_t EDMA_DRV_InstallCallback(uint8_t channel, edma_callback_t callback, void *parameter)
Registers the callback function and the parameter for eDMA channel.
void LPUART_HAL_Init(LPUART_Type *base)
Initializes the LPUART controller.
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
static void LPUART_HAL_Getchar(const LPUART_Type *base, uint8_t *readData)
Gets the LPUART 8-bit character.