22 #if (defined(UART_OVER_LPUART))
26 #if (defined(UART_OVER_FLEXIO))
31 #if (defined(UART_OVER_LINFLEXD))
32 #include "linflexd_uart_driver.h"
36 #if (defined(UART_OVER_LPUART))
40 static uart_instance_t lpuartStateInstanceMapping[NO_OF_LPUART_INSTS_FOR_UART];
42 static bool lpuartStateIsAllocated[NO_OF_LPUART_INSTS_FOR_UART];
46 #if (defined(UART_OVER_FLEXIO))
51 flexio_device_state_t flexioDeviceState;
53 static uart_instance_t flexioUartStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_UART];
55 static bool flexioUartStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_UART];
59 #if (defined(UART_OVER_LINFLEXD))
61 linflexd_uart_state_t linFlexDState[NO_OF_LINFLEXD_INSTS_FOR_UART];
63 static uart_instance_t linFlexDStateInstanceMapping[NO_OF_LINFLEXD_INSTS_FOR_UART];
65 static bool linFlexDStateIsAllocated[NO_OF_LINFLEXD_INSTS_FOR_UART];
77 uint8_t numberOfinstances)
81 for (i = 0; i < numberOfinstances; i++)
83 if (isAllocated[i] ==
false)
85 instanceMapping[i] = instance;
86 isAllocated[i] =
true;
102 uint8_t numberOfinstances)
106 for (i = 0;i < numberOfinstances;i++)
108 if (instanceMapping[i] == instance)
110 isAllocated[i] =
false;
116 #if (defined(UART_OVER_FLEXIO))
126 for (i = 0; i < NO_OF_FLEXIO_INSTS_FOR_UART; i++)
128 if (flexioUartStateInstanceMapping[i] == instance)
150 #if (defined (UART_OVER_LPUART))
184 lpuartStateInstanceMapping,
186 NO_OF_LPUART_INSTS_FOR_UART);
205 #if (defined (UART_OVER_FLEXIO))
270 flexioUartTxConfig.
dataPin = ((extension_flexio_for_uart_t*)(config->
extension))->dataPinTx;
275 flexioUartRxConfig.
dataPin = ((extension_flexio_for_uart_t*)(config->
extension))->dataPinRx;
288 flexioUartStateInstanceMapping,
290 NO_OF_FLEXIO_INSTS_FOR_UART);
305 #if (defined (UART_OVER_LINFLEXD))
306 linflexd_uart_user_config_t linFlexDConfig;
308 linFlexDConfig.baudRate = config->
baudRate;
316 linFlexDConfig.wordLength = LINFLEXD_UART_7_BITS;
319 linFlexDConfig.wordLength = LINFLEXD_UART_8_BITS;
322 linFlexDConfig.wordLength = LINFLEXD_UART_15_BITS;
325 linFlexDConfig.wordLength = LINFLEXD_UART_16_BITS;
335 linFlexDConfig.parityCheck =
false;
338 linFlexDConfig.parityCheck =
true;
339 linFlexDConfig.parityType = LINFLEXD_UART_PARITY_EVEN;
342 linFlexDConfig.parityCheck =
true;
343 linFlexDConfig.parityType = LINFLEXD_UART_PARITY_ODD;
350 linFlexDConfig.stopBitsCount = (linflexd_uart_stop_bits_count_t)config->
stopBitCount;
351 linFlexDConfig.transferType = (linflexd_uart_transfer_type_t)config->
transferType;
357 linFlexDStateInstanceMapping,
359 NO_OF_LINFLEXD_INSTS_FOR_UART);
361 status = LINFLEXD_UART_DRV_Init(instance, &linFlexDState[index], &linFlexDConfig);
391 #if defined(UART_OVER_LPUART)
398 lpuartStateInstanceMapping,
400 NO_OF_LPUART_INSTS_FOR_UART);
406 #if defined(UART_OVER_FLEXIO)
409 uint8_t index = UART_FindFlexioState(instance);
414 flexioUartStateInstanceMapping,
416 NO_OF_FLEXIO_INSTS_FOR_UART);
422 flexioUartStateInstanceMapping,
424 NO_OF_FLEXIO_INSTS_FOR_UART);
430 #if (defined(UART_OVER_LINFLEXD))
431 status = LINFLEXD_UART_DRV_Deinit(instance);
435 linFlexDStateInstanceMapping,
437 NO_OF_LINFLEXD_INSTS_FOR_UART);
455 #if defined(UART_OVER_LPUART)
463 #if defined(UART_OVER_FLEXIO)
466 uint8_t index = UART_FindFlexioState(instance);
467 uint8_t bitCount = (flexioUartTxState[index]).bitCount;
478 #if (defined(UART_OVER_LINFLEXD))
479 status = LINFLEXD_UART_DRV_SetBaudRate(instance, desiredBaudRate);
497 #if defined(UART_OVER_LPUART)
505 #if defined(UART_OVER_FLEXIO)
514 #if (defined(UART_OVER_LINFLEXD))
515 status = LINFLEXD_UART_DRV_GetBaudRate(instance, configuredBaudRate);
530 const uint8_t * txBuff,
537 #if defined(UART_OVER_LPUART)
545 #if defined(UART_OVER_FLEXIO)
549 &(flexioUartTxState[UART_FindFlexioState(instance)]),
557 #if (defined(UART_OVER_LINFLEXD))
558 status = LINFLEXD_UART_DRV_SendDataBlocking(instance, txBuff, txSize, timeout);
575 #if defined(UART_OVER_LPUART)
584 #if defined(UART_OVER_FLEXIO)
588 &(flexioUartTxState[UART_FindFlexioState(instance)]),
595 #if (defined(UART_OVER_LINFLEXD))
596 status = LINFLEXD_UART_DRV_SendData(instance, txBuff, txSize);
613 #if defined(UART_OVER_LPUART)
621 #if defined(UART_OVER_FLEXIO)
629 #if (defined(UART_OVER_LINFLEXD))
630 status = LINFLEXD_UART_DRV_AbortSendingData(instance);
648 #if defined(UART_OVER_LPUART)
656 #if defined(UART_OVER_FLEXIO)
660 &(flexioUartTxState[UART_FindFlexioState(instance)]),
666 #if (defined(UART_OVER_LINFLEXD))
667 status = LINFLEXD_UART_DRV_GetTransmitStatus(instance, bytesRemaining);
688 #if defined(UART_OVER_LPUART)
696 #if defined(UART_OVER_FLEXIO)
700 &(flexioUartRxState[UART_FindFlexioState(instance)]),
708 #if (defined(UART_OVER_LINFLEXD))
709 status = LINFLEXD_UART_DRV_ReceiveDataBlocking(instance, rxBuff, rxSize, timeout);
726 #if defined(UART_OVER_LPUART)
734 #if defined(UART_OVER_FLEXIO)
738 &(flexioUartRxState[UART_FindFlexioState(instance)]),
745 #if (defined(UART_OVER_LINFLEXD))
746 status = LINFLEXD_UART_DRV_ReceiveData(instance, rxBuff, rxSize);
763 #if defined(UART_OVER_LPUART)
771 #if defined(UART_OVER_FLEXIO)
779 #if (defined(UART_OVER_LINFLEXD))
780 status = LINFLEXD_UART_DRV_AbortReceivingData(instance);
798 #if defined(UART_OVER_LPUART)
806 #if defined(UART_OVER_FLEXIO)
815 #if (defined(UART_OVER_LINFLEXD))
816 status = LINFLEXD_UART_DRV_GetReceiveStatus(instance, bytesRemaining);
status_t UART_GetReceiveStatus(uart_instance_t instance, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART reception.
status_t UART_SetBaudRate(uart_instance_t instance, uint32_t desiredBaudRate)
Configures the UART baud rate.
status_t LPUART_DRV_AbortSendingData(uint32_t instance)
Terminates a non-blocking transmission early.
status_t UART_ReceiveDataBlocking(uart_instance_t instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking UART reception.
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 UART_Init(uart_instance_t instance, uart_user_config_t *config)
Initializes the UART module.
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(uart_instance_t instance, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking UART transmission.
status_t UART_Deinit(uart_instance_t instance)
De-initializes the UART module.
uart_bit_count_per_char_t bitCount
status_t UART_GetBaudRate(uart_instance_t 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.
status_t UART_AbortSendingData(uart_instance_t instance)
Terminates a non-blocking transmission early.
lpuart_bit_count_per_char_t bitCountPerChar
status_t UART_AbortReceivingData(uart_instance_t instance)
Terminates a non-blocking receive early.
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 UART_ReceiveData(uart_instance_t instance, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking UART reception.
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.
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.
status_t UART_GetTransmitStatus(uart_instance_t instance, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART transmission.
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 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 LPUART_DRV_SetBaudRate(uint32_t instance, uint32_t desiredBaudRate)
Configures the LPUART baud rate.
Driver internal context structure.
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.
static void UART_FreeState(bool *isAllocated, uart_instance_t *instanceMapping, uart_instance_t instance, uint8_t numberOfinstances)
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 FLEXIO_UART_LOW_INDEX
static uint8_t UART_AllocateState(bool *isAllocated, uart_instance_t *instanceMapping, uart_instance_t instance, uint8_t numberOfinstances)
LPUART configuration structure.
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 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.
uart_transfer_type_t transferType
status_t UART_SendDataBlocking(uart_instance_t instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking UART transmission.
#define LPUART_HIGH_INDEX
#define FLEXIO_UART_HIGH_INDEX
lpuart_stop_bit_count_t stopBitCount
uart_stop_bit_count_t stopBitCount