70 #if (defined(UART_OVER_LPUART))
74 #if (defined(UART_OVER_FLEXIO))
79 #if (defined(UART_OVER_LINFLEXD))
80 #include "linflexd_uart_driver.h"
84 #if (defined(UART_OVER_LPUART))
88 static uint8_t s_lpuartStateInstanceMapping[NO_OF_LPUART_INSTS_FOR_UART];
90 static bool s_lpuartStateIsAllocated[NO_OF_LPUART_INSTS_FOR_UART];
94 #if (defined(UART_OVER_FLEXIO))
99 flexio_device_state_t flexioDeviceState;
101 static uint8_t s_flexioUartStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_UART];
103 static bool s_flexioUartStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_UART];
107 #if (defined(UART_OVER_LINFLEXD))
109 static linflexd_uart_state_t s_linFlexDState[NO_OF_LINFLEXD_INSTS_FOR_UART];
111 static uint8_t s_linFlexDStateInstanceMapping[NO_OF_LINFLEXD_INSTS_FOR_UART];
113 static bool s_linFlexDStateIsAllocated[NO_OF_LINFLEXD_INSTS_FOR_UART];
123 uint8_t * instanceMapping,
125 uint8_t numberOfinstances)
132 uint32_t uartIdx = instance->
instIdx;
135 for (i = 0; i < numberOfinstances; i++)
137 if (isAllocated[i] ==
false)
139 instanceMapping[i] = (uint8_t)uartIdx;
140 isAllocated[i] =
true;
154 const uint8_t * instanceMapping,
156 uint8_t numberOfinstances)
163 uint32_t uartIdx = instance->
instIdx;
166 for (i = 0;i < numberOfinstances;i++)
168 if (instanceMapping[i] == (uint8_t)uartIdx)
170 isAllocated[i] =
false;
176 #if (defined(UART_OVER_FLEXIO))
183 static uint8_t UART_FindFlexioState(
const uart_instance_t *
const instance)
188 uint32_t uartIdx = instance->
instIdx;
190 for (i = 0; i < NO_OF_FLEXIO_INSTS_FOR_UART; i++)
192 if (s_flexioUartStateInstanceMapping[i] == (uint8_t)uartIdx)
219 #if (defined(UART_OVER_LPUART))
252 s_lpuartStateInstanceMapping,
254 NO_OF_LPUART_INSTS_FOR_UART);
276 #if (defined(UART_OVER_FLEXIO))
341 flexioUartTxConfig.
dataPin = ((extension_flexio_for_uart_t *)(config->
extension))->dataPinTx;
346 flexioUartRxConfig.
dataPin = ((extension_flexio_for_uart_t *)(config->
extension))->dataPinRx;
359 s_flexioUartStateInstanceMapping,
361 NO_OF_FLEXIO_INSTS_FOR_UART);
374 #if (defined(UART_OVER_LINFLEXD))
377 linflexd_uart_user_config_t linFlexDConfig;
378 linFlexDConfig.baudRate = config->
baudRate;
385 linFlexDConfig.wordLength = LINFLEXD_UART_7_BITS;
388 linFlexDConfig.wordLength = LINFLEXD_UART_8_BITS;
391 linFlexDConfig.wordLength = LINFLEXD_UART_15_BITS;
394 linFlexDConfig.wordLength = LINFLEXD_UART_16_BITS;
404 linFlexDConfig.parityCheck =
false;
407 linFlexDConfig.parityCheck =
true;
408 linFlexDConfig.parityType = LINFLEXD_UART_PARITY_EVEN;
411 linFlexDConfig.parityCheck =
true;
412 linFlexDConfig.parityType = LINFLEXD_UART_PARITY_ODD;
419 linFlexDConfig.stopBitsCount = (linflexd_uart_stop_bits_count_t)config->
stopBitCount;
420 linFlexDConfig.transferType = (linflexd_uart_transfer_type_t)config->
transferType;
426 s_linFlexDStateInstanceMapping,
428 NO_OF_LINFLEXD_INSTS_FOR_UART);
430 status = LINFLEXD_UART_DRV_Init(instance->
instIdx, &s_linFlexDState[index], &linFlexDConfig);
435 (void)LINFLEXD_UART_DRV_InstallRxCallback(instance->
instIdx,
443 (void)LINFLEXD_UART_DRV_InstallTxCallback(instance->
instIdx,
467 #if (defined(UART_OVER_FLEXIO))
474 #if (defined(UART_OVER_LPUART))
481 s_lpuartStateInstanceMapping,
483 NO_OF_LPUART_INSTS_FOR_UART);
488 #if (defined(UART_OVER_FLEXIO))
492 index = UART_FindFlexioState(instance);
497 s_flexioUartStateInstanceMapping,
499 NO_OF_FLEXIO_INSTS_FOR_UART);
505 s_flexioUartStateInstanceMapping,
507 NO_OF_FLEXIO_INSTS_FOR_UART);
512 #if (defined(UART_OVER_LINFLEXD))
516 status = LINFLEXD_UART_DRV_Deinit(instance->
instIdx);
520 s_linFlexDStateInstanceMapping,
522 NO_OF_LINFLEXD_INSTS_FOR_UART);
544 #if (defined(UART_OVER_FLEXIO))
546 uint8_t bitCount = 0;
552 #if (defined(UART_OVER_LPUART))
559 #if (defined(UART_OVER_FLEXIO))
562 index = UART_FindFlexioState(instance);
563 bitCount = (s_flexioUartTxState[index]).bitCount;
573 #if (defined(UART_OVER_LINFLEXD))
576 status = LINFLEXD_UART_DRV_SetBaudRate(instance->
instIdx, desiredBaudRate);
601 #if (defined(UART_OVER_LPUART))
609 #if (defined(UART_OVER_FLEXIO))
617 #if (defined(UART_OVER_LINFLEXD))
620 status = LINFLEXD_UART_DRV_GetBaudRate(instance->
instIdx, configuredBaudRate);
640 const uint8_t * txBuff,
652 #if (defined(UART_OVER_LPUART))
659 #if (defined(UART_OVER_FLEXIO))
663 &(s_flexioUartTxState[UART_FindFlexioState(instance)]),
670 #if (defined(UART_OVER_LINFLEXD))
673 status = LINFLEXD_UART_DRV_SendDataBlocking(instance->
instIdx, txBuff, txSize, timeout);
700 #if (defined(UART_OVER_LPUART))
707 #if (defined(UART_OVER_FLEXIO))
711 &(s_flexioUartTxState[UART_FindFlexioState(instance)]),
717 #if (defined(UART_OVER_LINFLEXD))
720 status = LINFLEXD_UART_DRV_SendData(instance->
instIdx, txBuff, txSize);
746 #if (defined(UART_OVER_LPUART))
753 #if (defined(UART_OVER_FLEXIO))
760 #if (defined(UART_OVER_LINFLEXD))
763 status = LINFLEXD_UART_DRV_AbortSendingData(instance->
instIdx);
790 #if (defined(UART_OVER_LPUART))
797 #if (defined(UART_OVER_FLEXIO))
801 &(s_flexioUartTxState[UART_FindFlexioState(instance)]),
806 #if (defined(UART_OVER_LINFLEXD))
809 status = LINFLEXD_UART_DRV_GetTransmitStatus(instance->
instIdx, bytesRemaining);
839 #if (defined(UART_OVER_LPUART))
846 #if (defined(UART_OVER_FLEXIO))
850 &(s_flexioUartRxState[UART_FindFlexioState(instance)]),
857 #if (defined(UART_OVER_LINFLEXD))
860 status = LINFLEXD_UART_DRV_ReceiveDataBlocking(instance->
instIdx, rxBuff, rxSize, timeout);
886 #if (defined(UART_OVER_LPUART))
893 #if (defined(UART_OVER_FLEXIO))
897 &(s_flexioUartRxState[UART_FindFlexioState(instance)]),
903 #if (defined(UART_OVER_LINFLEXD))
906 status = LINFLEXD_UART_DRV_ReceiveData(instance->
instIdx, rxBuff, rxSize);
932 #if (defined(UART_OVER_LPUART))
939 #if (defined(UART_OVER_FLEXIO))
946 #if (defined(UART_OVER_LINFLEXD))
949 status = LINFLEXD_UART_DRV_AbortReceivingData(instance->
instIdx);
976 #if (defined(UART_OVER_LPUART))
983 #if (defined(UART_OVER_FLEXIO))
991 #if (defined(UART_OVER_LINFLEXD))
994 status = LINFLEXD_UART_DRV_GetReceiveStatus(instance->
instIdx, bytesRemaining);
1021 #if (defined(UART_OVER_LPUART))
1028 #if (defined(UART_OVER_FLEXIO))
1035 #if (defined(UART_OVER_LINFLEXD))
1038 status = LINFLEXD_UART_DRV_SetRxBuffer(instance->
instIdx, rxBuff, rxSize);
1065 #if (defined(UART_OVER_LPUART))
1072 #if (defined(UART_OVER_FLEXIO))
1079 #if (defined(UART_OVER_LINFLEXD))
1082 status = LINFLEXD_UART_DRV_SetTxBuffer(instance->
instIdx, txBuff, txSize);
status_t UART_Init(const uart_instance_t *const instance, const uart_user_config_t *config)
Initializes the UART module.
status_t LPUART_DRV_AbortSendingData(uint32_t instance)
Terminates a non-blocking transmission early.
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.
uart_callback_t LPUART_DRV_InstallTxCallback(uint32_t instance, uart_callback_t function, void *callbackParam)
Installs callback function for the LPUART transmit.
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...
status_t FLEXIO_UART_DRV_ReceiveData(flexio_uart_state_t *state, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking UART reception.
status_t LPUART_DRV_AbortReceivingData(uint32_t instance)
Terminates a non-blocking receive early.
status_t UART_SendData(const uart_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking UART transmission.
status_t FLEXIO_UART_DRV_SetTxBuffer(flexio_uart_state_t *state, const uint8_t *txBuff, uint32_t txSize)
Provide a buffer for transmitting data.
uart_bit_count_per_char_t bitCount
static void UART_FreeState(bool *isAllocated, const uint8_t *instanceMapping, const uart_instance_t *const instance, uint8_t numberOfinstances)
status_t UART_GetReceiveStatus(const uart_instance_t *const instance, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART reception.
status_t UART_GetBaudRate(const uart_instance_t *const instance, uint32_t *configuredBaudRate)
Returns the UART baud rate.
status_t FLEXIO_UART_DRV_SetConfig(flexio_uart_state_t *state, uint32_t baudRate, uint8_t bitCount)
Set the baud rate and bit width for any subsequent UART communication.
Structure storing PAL instance information.
status_t UART_SetTxBuffer(const uart_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize)
Provide a buffer for transmitting data.
status_t UART_AbortSendingData(const uart_instance_t *const instance)
Terminates a non-blocking transmission early.
lpuart_bit_count_per_char_t bitCountPerChar
status_t FLEXIO_UART_DRV_SendData(flexio_uart_state_t *state, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking UART transmission.
lpuart_parity_mode_t parityMode
status_t FLEXIO_UART_DRV_SendDataBlocking(flexio_uart_state_t *state, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking UART transmission.
status_t UART_ReceiveDataBlocking(const uart_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking UART reception.
uart_parity_mode_t parityMode
flexio_uart_driver_direction_t direction
status_t FLEXIO_UART_DRV_ReceiveDataBlocking(flexio_uart_state_t *state, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking UART reception.
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...
lpuart_transfer_type_t
Type of LPUART transfer (based on interrupts or DMA).
status_t FLEXIO_UART_DRV_GetBaudRate(flexio_uart_state_t *state, uint32_t *baudRate)
Get the currently configured baud rate.
lpuart_parity_mode_t
LPUART parity mode.
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 ...
status_t UART_AbortReceivingData(const uart_instance_t *const instance)
Terminates a non-blocking receive early.
status_t FLEXIO_UART_DRV_GetStatus(flexio_uart_state_t *state, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART transfer.
uart_callback_t txCallback
status_t FLEXIO_UART_DRV_SetRxBuffer(flexio_uart_state_t *state, uint8_t *rxBuff, uint32_t rxSize)
Provide a buffer for receiving data.
status_t LPUART_DRV_SetBaudRate(uint32_t instance, uint32_t desiredBaudRate)
Configures the LPUART baud rate.
uart_inst_type_t instType
Driver internal context structure.
status_t UART_ReceiveData(const uart_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking UART reception.
status_t FLEXIO_UART_DRV_Deinit(flexio_uart_state_t *state)
De-initialize the FLEXIO_UART driver.
status_t FLEXIO_UART_DRV_TransferAbort(flexio_uart_state_t *state)
Aborts a non-blocking UART transfer.
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.
#define FLEXIO_UART_INSTANCE_COUNT
status_t UART_SetRxBuffer(const uart_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize)
Provide a buffer for receiving data.
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 uint8_t UART_AllocateState(bool *isAllocated, uint8_t *instanceMapping, const uart_instance_t *const instance, uint8_t numberOfinstances)
Defines the UART configuration structure.
status_t UART_GetTransmitStatus(const uart_instance_t *const instance, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART transmission.
LPUART configuration structure.
#define LPUART_INSTANCE_COUNT
lpuart_stop_bit_count_t
LPUART number of stop bits.
flexio_driver_type_t driverType
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.
Driver configuration structure.
lpuart_transfer_type_t transferType
status_t FLEXIO_UART_DRV_Init(uint32_t instance, const flexio_uart_user_config_t *userConfigPtr, flexio_uart_state_t *state)
Initialize the FLEXIO_UART driver.
Runtime state of the LPUART driver.
status_t UART_SetBaudRate(const uart_instance_t *const instance, uint32_t desiredBaudRate)
Configures the UART baud rate.
status_t UART_Deinit(const uart_instance_t *const instance)
De-initializes the UART module.
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
uart_callback_t rxCallback
status_t LPUART_DRV_GetReceiveStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous receive is complete.
status_t UART_SendDataBlocking(const uart_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking UART transmission.
uart_transfer_type_t transferType
status_t LPUART_DRV_SetRxBuffer(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Sets the internal driver reference to the rx buffer.
lpuart_stop_bit_count_t stopBitCount
uart_stop_bit_count_t stopBitCount