3 * All rights reserved.
\r
6 * SPDX-License-Identifier: BSD-3-Clause
\r
9 #include "fsl_common.h"
\r
10 #include "fsl_usart.h"
\r
11 #include "fsl_flexcomm.h"
\r
15 /*******************************************************************************
\r
17 ******************************************************************************/
\r
19 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
\r
25 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
26 /*! @brief uart RX state structure. */
\r
27 typedef struct _hal_uart_receive_state
\r
29 volatile uint8_t *buffer;
\r
30 volatile uint32_t bufferLength;
\r
31 volatile uint32_t bufferSofar;
\r
32 } hal_uart_receive_state_t;
\r
34 /*! @brief uart TX state structure. */
\r
35 typedef struct _hal_uart_send_state
\r
37 volatile uint8_t *buffer;
\r
38 volatile uint32_t bufferLength;
\r
39 volatile uint32_t bufferSofar;
\r
40 } hal_uart_send_state_t;
\r
42 /*! @brief uart state structure. */
\r
43 typedef struct _hal_uart_state
\r
45 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
46 hal_uart_transfer_callback_t callback;
\r
47 void *callbackParam;
\r
48 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
49 usart_handle_t hardwareHandle;
\r
51 hal_uart_receive_state_t rx;
\r
52 hal_uart_send_state_t tx;
\r
57 /*******************************************************************************
\r
59 ******************************************************************************/
\r
61 /*******************************************************************************
\r
63 ******************************************************************************/
\r
64 static USART_Type *const s_UsartAdapterBase[] = USART_BASE_PTRS;
\r
66 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
68 #if !(defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
69 /* Array of USART IRQ number. */
\r
70 static const IRQn_Type s_UsartIRQ[] = USART_IRQS;
\r
75 /*******************************************************************************
\r
77 ******************************************************************************/
\r
79 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
80 static hal_uart_status_t HAL_UartGetStatus(status_t status)
\r
82 hal_uart_status_t uartStatus = kStatus_HAL_UartError;
\r
85 case kStatus_Success:
\r
86 uartStatus = kStatus_HAL_UartSuccess;
\r
88 case kStatus_USART_TxBusy:
\r
89 uartStatus = kStatus_HAL_UartTxBusy;
\r
91 case kStatus_USART_RxBusy:
\r
92 uartStatus = kStatus_HAL_UartRxBusy;
\r
94 case kStatus_USART_TxIdle:
\r
95 uartStatus = kStatus_HAL_UartTxIdle;
\r
97 case kStatus_USART_RxIdle:
\r
98 uartStatus = kStatus_HAL_UartRxIdle;
\r
100 case kStatus_USART_BaudrateNotSupport:
\r
101 uartStatus = kStatus_HAL_UartBaudrateNotSupport;
\r
103 case kStatus_USART_NoiseError:
\r
104 case kStatus_USART_FramingError:
\r
105 case kStatus_USART_ParityError:
\r
106 uartStatus = kStatus_HAL_UartProtocolError;
\r
114 static hal_uart_status_t HAL_UartGetStatus(status_t status)
\r
116 if (kStatus_Success == status)
\r
118 return kStatus_HAL_UartSuccess;
\r
122 return kStatus_HAL_UartError;
\r
127 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
129 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
130 static void HAL_UartCallback(USART_Type *base, usart_handle_t *handle, status_t status, void *callbackParam)
\r
132 hal_uart_state_t *uartHandle;
\r
133 hal_uart_status_t uartStatus = HAL_UartGetStatus(status);
\r
134 assert(callbackParam);
\r
136 uartHandle = (hal_uart_state_t *)callbackParam;
\r
138 if (kStatus_HAL_UartProtocolError == uartStatus)
\r
140 if (uartHandle->hardwareHandle.rxDataSize)
\r
142 uartStatus = kStatus_HAL_UartError;
\r
146 if (uartHandle->callback)
\r
148 uartHandle->callback(uartHandle, uartStatus, uartHandle->callbackParam);
\r
154 static void HAL_UartInterruptHandle(USART_Type *base, void *handle)
\r
156 hal_uart_state_t *uartHandle = (hal_uart_state_t *)handle;
\r
160 if (NULL == uartHandle)
\r
164 instance = uartHandle->instance;
\r
166 status = USART_GetStatusFlags(s_UsartAdapterBase[instance]);
\r
168 /* Receive data register full */
\r
169 if ((USART_FIFOSTAT_RXNOTEMPTY_MASK & status) &&
\r
170 (USART_GetEnabledInterrupts(s_UsartAdapterBase[instance]) & USART_FIFOINTENSET_RXLVL_MASK))
\r
172 if (uartHandle->rx.buffer)
\r
174 uartHandle->rx.buffer[uartHandle->rx.bufferSofar++] = USART_ReadByte(s_UsartAdapterBase[instance]);
\r
175 if (uartHandle->rx.bufferSofar >= uartHandle->rx.bufferLength)
\r
177 USART_DisableInterrupts(s_UsartAdapterBase[instance],
\r
178 USART_FIFOINTENCLR_RXLVL_MASK | USART_FIFOINTENCLR_RXERR_MASK);
\r
179 uartHandle->rx.buffer = NULL;
\r
180 if (uartHandle->callback)
\r
182 uartHandle->callback(uartHandle, kStatus_HAL_UartRxIdle, uartHandle->callbackParam);
\r
188 /* Send data register empty and the interrupt is enabled. */
\r
189 if ((USART_FIFOSTAT_TXNOTFULL_MASK & status) &&
\r
190 (USART_GetEnabledInterrupts(s_UsartAdapterBase[instance]) & USART_FIFOINTENSET_TXLVL_MASK))
\r
192 if (uartHandle->tx.buffer)
\r
194 USART_WriteByte(s_UsartAdapterBase[instance], uartHandle->tx.buffer[uartHandle->tx.bufferSofar++]);
\r
195 if (uartHandle->tx.bufferSofar >= uartHandle->tx.bufferLength)
\r
197 USART_DisableInterrupts(s_UsartAdapterBase[instance], USART_FIFOINTENCLR_TXLVL_MASK);
\r
198 uartHandle->tx.buffer = NULL;
\r
199 if (uartHandle->callback)
\r
201 uartHandle->callback(uartHandle, kStatus_HAL_UartTxIdle, uartHandle->callbackParam);
\r
208 USART_ClearStatusFlags(s_UsartAdapterBase[instance], status);
\r
215 hal_uart_status_t HAL_UartInit(hal_uart_handle_t handle, hal_uart_config_t *config)
\r
217 hal_uart_state_t *uartHandle;
\r
218 usart_config_t usartConfig;
\r
222 assert(config->instance < (sizeof(s_UsartAdapterBase) / sizeof(USART_Type *)));
\r
223 assert(s_UsartAdapterBase[config->instance]);
\r
225 if (HAL_UART_HANDLE_SIZE < sizeof(hal_uart_state_t))
\r
227 return kStatus_HAL_UartError;
\r
230 USART_GetDefaultConfig(&usartConfig);
\r
231 usartConfig.baudRate_Bps = config->baudRate_Bps;
\r
233 if (kHAL_UartParityEven == config->parityMode)
\r
235 usartConfig.parityMode = kUSART_ParityEven;
\r
237 else if (kHAL_UartParityOdd == config->parityMode)
\r
239 usartConfig.parityMode = kUSART_ParityOdd;
\r
243 usartConfig.parityMode = kUSART_ParityDisabled;
\r
246 if (kHAL_UartTwoStopBit == config->stopBitCount)
\r
248 usartConfig.stopBitCount = kUSART_TwoStopBit;
\r
252 usartConfig.stopBitCount = kUSART_OneStopBit;
\r
254 usartConfig.enableRx = config->enableRx;
\r
255 usartConfig.enableTx = config->enableTx;
\r
256 usartConfig.txWatermark = kUSART_TxFifo0;
\r
257 usartConfig.rxWatermark = kUSART_RxFifo1;
\r
259 status = USART_Init(s_UsartAdapterBase[config->instance], &usartConfig, config->srcClock_Hz);
\r
261 if (kStatus_Success != status)
\r
263 return HAL_UartGetStatus(status);
\r
266 uartHandle = (hal_uart_state_t *)handle;
\r
267 uartHandle->instance = config->instance;
\r
269 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
271 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
272 USART_TransferCreateHandle(s_UsartAdapterBase[config->instance], &uartHandle->hardwareHandle,
\r
273 (usart_transfer_callback_t)HAL_UartCallback, handle);
\r
275 /* Enable interrupt in NVIC. */
\r
276 FLEXCOMM_SetIRQHandler(s_UsartAdapterBase[config->instance], (flexcomm_irq_handler_t)HAL_UartInterruptHandle,
\r
278 NVIC_SetPriority((IRQn_Type)s_UsartIRQ[config->instance], HAL_UART_ISR_PRIORITY);
\r
279 EnableIRQ(s_UsartIRQ[config->instance]);
\r
284 return kStatus_HAL_UartSuccess;
\r
287 hal_uart_status_t HAL_UartDeinit(hal_uart_handle_t handle)
\r
289 hal_uart_state_t *uartHandle;
\r
293 uartHandle = (hal_uart_state_t *)handle;
\r
295 USART_Deinit(s_UsartAdapterBase[uartHandle->instance]);
\r
297 return kStatus_HAL_UartSuccess;
\r
300 hal_uart_status_t HAL_UartReceiveBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
\r
302 hal_uart_state_t *uartHandle;
\r
308 uartHandle = (hal_uart_state_t *)handle;
\r
310 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
311 if (uartHandle->rx.buffer)
\r
313 return kStatus_HAL_UartRxBusy;
\r
317 status = USART_ReadBlocking(s_UsartAdapterBase[uartHandle->instance], data, length);
\r
319 return HAL_UartGetStatus(status);
\r
322 hal_uart_status_t HAL_UartSendBlocking(hal_uart_handle_t handle, const uint8_t *data, size_t length)
\r
324 hal_uart_state_t *uartHandle;
\r
329 uartHandle = (hal_uart_state_t *)handle;
\r
331 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
332 if (uartHandle->tx.buffer)
\r
334 return kStatus_HAL_UartTxBusy;
\r
338 USART_WriteBlocking(s_UsartAdapterBase[uartHandle->instance], data, length);
\r
340 return kStatus_HAL_UartSuccess;
\r
343 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
\r
345 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
347 hal_uart_status_t HAL_UartTransferInstallCallback(hal_uart_handle_t handle,
\r
348 hal_uart_transfer_callback_t callback,
\r
349 void *callbackParam)
\r
351 hal_uart_state_t *uartHandle;
\r
354 assert(HAL_UART_TRANSFER_MODE);
\r
356 uartHandle = (hal_uart_state_t *)handle;
\r
358 uartHandle->callbackParam = callbackParam;
\r
359 uartHandle->callback = callback;
\r
361 return kStatus_HAL_UartSuccess;
\r
364 hal_uart_status_t HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)
\r
366 hal_uart_state_t *uartHandle;
\r
370 assert(HAL_UART_TRANSFER_MODE);
\r
372 uartHandle = (hal_uart_state_t *)handle;
\r
374 status = USART_TransferReceiveNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,
\r
375 (usart_transfer_t *)transfer, NULL);
\r
377 return HAL_UartGetStatus(status);
\r
380 hal_uart_status_t HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)
\r
382 hal_uart_state_t *uartHandle;
\r
386 assert(HAL_UART_TRANSFER_MODE);
\r
388 uartHandle = (hal_uart_state_t *)handle;
\r
390 status = USART_TransferSendNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,
\r
391 (usart_transfer_t *)transfer);
\r
393 return HAL_UartGetStatus(status);
\r
396 hal_uart_status_t HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle, uint32_t *count)
\r
398 hal_uart_state_t *uartHandle;
\r
402 assert(HAL_UART_TRANSFER_MODE);
\r
404 uartHandle = (hal_uart_state_t *)handle;
\r
407 USART_TransferGetReceiveCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);
\r
409 return HAL_UartGetStatus(status);
\r
412 hal_uart_status_t HAL_UartTransferGetSendCount(hal_uart_handle_t handle, uint32_t *count)
\r
414 hal_uart_state_t *uartHandle;
\r
418 assert(HAL_UART_TRANSFER_MODE);
\r
420 uartHandle = (hal_uart_state_t *)handle;
\r
422 status = USART_TransferGetSendCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);
\r
424 return HAL_UartGetStatus(status);
\r
427 hal_uart_status_t HAL_UartTransferAbortReceive(hal_uart_handle_t handle)
\r
429 hal_uart_state_t *uartHandle;
\r
431 assert(HAL_UART_TRANSFER_MODE);
\r
433 uartHandle = (hal_uart_state_t *)handle;
\r
435 USART_TransferAbortReceive(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
\r
437 return kStatus_HAL_UartSuccess;
\r
440 hal_uart_status_t HAL_UartTransferAbortSend(hal_uart_handle_t handle)
\r
442 hal_uart_state_t *uartHandle;
\r
444 assert(HAL_UART_TRANSFER_MODE);
\r
446 uartHandle = (hal_uart_state_t *)handle;
\r
448 USART_TransferAbortSend(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
\r
450 return kStatus_HAL_UartSuccess;
\r
455 /* None transactional API with non-blocking mode. */
\r
456 hal_uart_status_t HAL_UartInstallCallback(hal_uart_handle_t handle,
\r
457 hal_uart_transfer_callback_t callback,
\r
458 void *callbackParam)
\r
460 hal_uart_state_t *uartHandle;
\r
463 assert(!HAL_UART_TRANSFER_MODE);
\r
465 uartHandle = (hal_uart_state_t *)handle;
\r
467 uartHandle->callbackParam = callbackParam;
\r
468 uartHandle->callback = callback;
\r
470 return kStatus_HAL_UartSuccess;
\r
473 hal_uart_status_t HAL_UartReceiveNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
\r
475 hal_uart_state_t *uartHandle;
\r
479 assert(!HAL_UART_TRANSFER_MODE);
\r
481 uartHandle = (hal_uart_state_t *)handle;
\r
483 if (uartHandle->rx.buffer)
\r
485 return kStatus_HAL_UartRxBusy;
\r
488 uartHandle->rx.bufferLength = length;
\r
489 uartHandle->rx.bufferSofar = 0;
\r
490 uartHandle->rx.buffer = data;
\r
491 USART_EnableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENSET_RXLVL_MASK);
\r
492 return kStatus_HAL_UartSuccess;
\r
495 hal_uart_status_t HAL_UartSendNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
\r
497 hal_uart_state_t *uartHandle;
\r
501 assert(!HAL_UART_TRANSFER_MODE);
\r
503 uartHandle = (hal_uart_state_t *)handle;
\r
505 if (uartHandle->tx.buffer)
\r
507 return kStatus_HAL_UartTxBusy;
\r
509 uartHandle->tx.bufferLength = length;
\r
510 uartHandle->tx.bufferSofar = 0;
\r
511 uartHandle->tx.buffer = (volatile uint8_t *)data;
\r
512 USART_EnableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENSET_TXLVL_MASK);
\r
513 return kStatus_HAL_UartSuccess;
\r
516 hal_uart_status_t HAL_UartGetReceiveCount(hal_uart_handle_t handle, uint32_t *reCount)
\r
518 hal_uart_state_t *uartHandle;
\r
521 assert(!HAL_UART_TRANSFER_MODE);
\r
523 uartHandle = (hal_uart_state_t *)handle;
\r
525 if (uartHandle->rx.buffer)
\r
527 *reCount = uartHandle->rx.bufferSofar;
\r
528 return kStatus_HAL_UartSuccess;
\r
530 return kStatus_HAL_UartError;
\r
533 hal_uart_status_t HAL_UartGetSendCount(hal_uart_handle_t handle, uint32_t *seCount)
\r
535 hal_uart_state_t *uartHandle;
\r
538 assert(!HAL_UART_TRANSFER_MODE);
\r
540 uartHandle = (hal_uart_state_t *)handle;
\r
542 if (uartHandle->tx.buffer)
\r
544 *seCount = uartHandle->tx.bufferSofar;
\r
545 return kStatus_HAL_UartSuccess;
\r
547 return kStatus_HAL_UartError;
\r
550 hal_uart_status_t HAL_UartAbortReceive(hal_uart_handle_t handle)
\r
552 hal_uart_state_t *uartHandle;
\r
554 assert(!HAL_UART_TRANSFER_MODE);
\r
556 uartHandle = (hal_uart_state_t *)handle;
\r
558 if (uartHandle->rx.buffer)
\r
560 USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance],
\r
561 USART_FIFOINTENCLR_RXLVL_MASK | USART_FIFOINTENCLR_RXERR_MASK);
\r
562 uartHandle->rx.buffer = NULL;
\r
565 return kStatus_HAL_UartSuccess;
\r
568 hal_uart_status_t HAL_UartAbortSend(hal_uart_handle_t handle)
\r
570 hal_uart_state_t *uartHandle;
\r
572 assert(!HAL_UART_TRANSFER_MODE);
\r
574 uartHandle = (hal_uart_state_t *)handle;
\r
576 if (uartHandle->tx.buffer)
\r
578 USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENCLR_TXLVL_MASK);
\r
579 uartHandle->tx.buffer = NULL;
\r
582 return kStatus_HAL_UartSuccess;
\r
587 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
589 void HAL_UartIsrFunction(hal_uart_handle_t handle)
\r
591 hal_uart_state_t *uartHandle;
\r
593 assert(HAL_UART_TRANSFER_MODE);
\r
595 uartHandle = (hal_uart_state_t *)handle;
\r
598 DisableIRQ(s_UsartIRQ[uartHandle->instance]);
\r
600 USART_TransferHandleIRQ(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
\r
602 NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);
\r
603 EnableIRQ(s_UsartIRQ[uartHandle->instance]);
\r
609 void HAL_UartIsrFunction(hal_uart_handle_t handle)
\r
611 hal_uart_state_t *uartHandle;
\r
613 assert(!HAL_UART_TRANSFER_MODE);
\r
615 uartHandle = (hal_uart_state_t *)handle;
\r
618 DisableIRQ(s_UsartIRQ[uartHandle->instance]);
\r
620 HAL_UartInterruptHandle(s_UsartAdapterBase[uartHandle->instance], (void *)uartHandle);
\r
622 NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);
\r
623 EnableIRQ(s_UsartIRQ[uartHandle->instance]);
\r