1 /*
2 * Copyright 2018 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9 #include "fsl_common.h"
10 #include "fsl_uart.h"
11
12 #include "fsl_adapter_uart.h"
13
14 /*******************************************************************************
15 * Definitions
16 ******************************************************************************/
17 #ifndef NDEBUG
18 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
19 #undef assert
20 #define assert(n)
21 #endif
22 #endif
23
24 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
25 /*! @brief uart RX state structure. */
26 typedef struct _hal_uart_receive_state
27 {
28 volatile uint8_t *buffer;
29 volatile uint32_t bufferLength;
30 volatile uint32_t bufferSofar;
31 } hal_uart_receive_state_t;
32
33 /*! @brief uart TX state structure. */
34 typedef struct _hal_uart_send_state
35 {
36 volatile uint8_t *buffer;
37 volatile uint32_t bufferLength;
38 volatile uint32_t bufferSofar;
39 } hal_uart_send_state_t;
40 #endif
41 /*! @brief uart state structure. */
42 typedef struct _hal_uart_state
43 {
44 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
45 hal_uart_transfer_callback_t callback;
46 void *callbackParam;
47 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
48 uart_handle_t hardwareHandle;
49 #endif
50 hal_uart_receive_state_t rx;
51 hal_uart_send_state_t tx;
52 #endif
53 uint8_t instance;
54 } hal_uart_state_t;
55
56 /*******************************************************************************
57 * Prototypes
58 ******************************************************************************/
59
60 /*******************************************************************************
61 * Variables
62 ******************************************************************************/
63 static UART_Type *const s_UartAdapterBase[] = UART_BASE_PTRS;
64
65 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
66
67 #if !(defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
68 /* Array of UART IRQ number. */
69 static const IRQn_Type s_UartIRQ[] = UART_RX_TX_IRQS;
70
71 static hal_uart_state_t *s_UartState[sizeof(s_UartAdapterBase) / sizeof(UART_Type *)];
72 #endif
73
74 #endif
75
76 /*******************************************************************************
77 * Code
78 ******************************************************************************/
79
80 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
HAL_UartGetStatus(status_t status)81 static hal_uart_status_t HAL_UartGetStatus(status_t status)
82 {
83 hal_uart_status_t uartStatus = kStatus_HAL_UartError;
84 switch (status)
85 {
86 case kStatus_Success:
87 uartStatus = kStatus_HAL_UartSuccess;
88 break;
89 case kStatus_UART_TxBusy:
90 uartStatus = kStatus_HAL_UartTxBusy;
91 break;
92 case kStatus_UART_RxBusy:
93 uartStatus = kStatus_HAL_UartRxBusy;
94 break;
95 case kStatus_UART_TxIdle:
96 uartStatus = kStatus_HAL_UartTxIdle;
97 break;
98 case kStatus_UART_RxIdle:
99 uartStatus = kStatus_HAL_UartRxIdle;
100 break;
101 case kStatus_UART_BaudrateNotSupport:
102 uartStatus = kStatus_HAL_UartBaudrateNotSupport;
103 break;
104 case kStatus_UART_NoiseError:
105 case kStatus_UART_FramingError:
106 case kStatus_UART_ParityError:
107 uartStatus = kStatus_HAL_UartProtocolError;
108 break;
109 default:
110 /* This comments for MISRA C-2012 Rule 16.4 */
111 break;
112 }
113 return uartStatus;
114 }
115 #else
HAL_UartGetStatus(status_t status)116 static hal_uart_status_t HAL_UartGetStatus(status_t status)
117 {
118 if (kStatus_Success == status)
119 {
120 return kStatus_HAL_UartSuccess;
121 }
122 else
123 {
124 return kStatus_HAL_UartError;
125 }
126 }
127 #endif
128
129 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
130
131 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
HAL_UartCallback(UART_Type * base,uart_handle_t * handle,status_t status,void * callbackParam)132 static void HAL_UartCallback(UART_Type *base, uart_handle_t *handle, status_t status, void *callbackParam)
133 {
134 hal_uart_state_t *uartHandle;
135 hal_uart_status_t uartStatus = HAL_UartGetStatus(status);
136 assert(callbackParam);
137
138 uartHandle = (hal_uart_state_t *)callbackParam;
139
140 if (kStatus_HAL_UartProtocolError == uartStatus)
141 {
142 if (0U != uartHandle->hardwareHandle.rxDataSize)
143 {
144 uartStatus = kStatus_HAL_UartError;
145 }
146 }
147
148 if (NULL != uartHandle->callback)
149 {
150 uartHandle->callback(uartHandle, uartStatus, uartHandle->callbackParam);
151 }
152 }
153
154 #else
155
HAL_UartInterruptHandle(uint8_t instance)156 static void HAL_UartInterruptHandle(uint8_t instance)
157 {
158 hal_uart_state_t *uartHandle = s_UartState[instance];
159 uint32_t status;
160 uint32_t clearStatus = 0;
161
162 if (NULL == uartHandle)
163 {
164 return;
165 }
166
167 status = UART_GetStatusFlags(s_UartAdapterBase[instance]);
168
169 /* Receive data register full */
170 if ((0U != ((uint32_t)kUART_RxDataRegFullFlag & status)) &&
171 (0U != (UART_GetEnabledInterrupts(s_UartAdapterBase[instance]) & (uint32_t)kUART_RxDataRegFullInterruptEnable)))
172 {
173 clearStatus |= (uint32_t)kUART_RxDataRegFullFlag | (uint32_t)kUART_RxOverrunFlag;
174 if (NULL != uartHandle->rx.buffer)
175 {
176 uartHandle->rx.buffer[uartHandle->rx.bufferSofar++] = UART_ReadByte(s_UartAdapterBase[instance]);
177 if (uartHandle->rx.bufferSofar >= uartHandle->rx.bufferLength)
178 {
179 UART_DisableInterrupts(s_UartAdapterBase[instance], (uint32_t)kUART_RxDataRegFullInterruptEnable |
180 (uint32_t)kUART_RxOverrunInterruptEnable);
181 uartHandle->rx.buffer = NULL;
182 if (NULL != uartHandle->callback)
183 {
184 uartHandle->callback(uartHandle, kStatus_HAL_UartRxIdle, uartHandle->callbackParam);
185 }
186 }
187 }
188 }
189
190 /* Send data register empty and the interrupt is enabled. */
191 if ((0U != ((uint32_t)kUART_TxDataRegEmptyFlag & status)) &&
192 (0U !=
193 (UART_GetEnabledInterrupts(s_UartAdapterBase[instance]) & (uint32_t)kUART_TxDataRegEmptyInterruptEnable)))
194 {
195 clearStatus |= (uint32_t)kUART_TxDataRegEmptyFlag | (uint32_t)kUART_TransmissionCompleteFlag;
196 if (NULL != uartHandle->tx.buffer)
197 {
198 UART_WriteByte(s_UartAdapterBase[instance], uartHandle->tx.buffer[uartHandle->tx.bufferSofar++]);
199 if (uartHandle->tx.bufferSofar >= uartHandle->tx.bufferLength)
200 {
201 UART_DisableInterrupts(s_UartAdapterBase[uartHandle->instance],
202 (uint32_t)kUART_TxDataRegEmptyInterruptEnable);
203 uartHandle->tx.buffer = NULL;
204 if (NULL != uartHandle->callback)
205 {
206 uartHandle->callback(uartHandle, kStatus_HAL_UartTxIdle, uartHandle->callbackParam);
207 }
208 }
209 }
210 }
211
212 #if 1
213 (void)UART_ClearStatusFlags(s_UartAdapterBase[instance], clearStatus);
214 #endif
215 }
216 #endif
217
218 #endif
219
HAL_UartInit(hal_uart_handle_t handle,const hal_uart_config_t * uart_config)220 hal_uart_status_t HAL_UartInit(hal_uart_handle_t handle, const hal_uart_config_t *uart_config)
221 {
222 hal_uart_state_t *uartHandle;
223 uart_config_t uartConfig;
224 status_t status;
225 assert(handle);
226 assert(uart_config);
227 assert(uart_config->instance < (sizeof(s_UartAdapterBase) / sizeof(UART_Type *)));
228 assert(s_UartAdapterBase[uart_config->instance]);
229
230 assert(HAL_UART_HANDLE_SIZE >= sizeof(hal_uart_state_t));
231
232 UART_GetDefaultConfig(&uartConfig);
233 uartConfig.baudRate_Bps = uart_config->baudRate_Bps;
234
235 if (kHAL_UartParityEven == uart_config->parityMode)
236 {
237 uartConfig.parityMode = kUART_ParityEven;
238 }
239 else if (kHAL_UartParityOdd == uart_config->parityMode)
240 {
241 uartConfig.parityMode = kUART_ParityOdd;
242 }
243 else
244 {
245 uartConfig.parityMode = kUART_ParityDisabled;
246 }
247 #if defined(FSL_FEATURE_UART_HAS_STOP_BIT_CONFIG_SUPPORT) && FSL_FEATURE_UART_HAS_STOP_BIT_CONFIG_SUPPORT
248 if (kHAL_UartTwoStopBit == uart_config->stopBitCount)
249 {
250 uartConfig.stopBitCount = kUART_TwoStopBit;
251 }
252 else
253 {
254 uartConfig.stopBitCount = kUART_OneStopBit;
255 }
256 #endif
257 uartConfig.enableRx = (bool)uart_config->enableRx;
258 uartConfig.enableTx = (bool)uart_config->enableTx;
259 #if defined(FSL_FEATURE_UART_HAS_MODEM_SUPPORT) && FSL_FEATURE_UART_HAS_MODEM_SUPPORT
260 uartConfig.enableRxRTS = (bool)uart_config->enableRxRTS;
261 uartConfig.enableTxCTS = (bool)uart_config->enableTxCTS;
262 #endif
263 #if defined(FSL_FEATURE_UART_HAS_FIFO) && FSL_FEATURE_UART_HAS_FIFO
264 uartConfig.txFifoWatermark = 0;
265 uartConfig.rxFifoWatermark = 1;
266 #endif
267 status = UART_Init(s_UartAdapterBase[uart_config->instance], &uartConfig, uart_config->srcClock_Hz);
268
269 if (kStatus_Success != status)
270 {
271 return HAL_UartGetStatus(status);
272 }
273
274 uartHandle = (hal_uart_state_t *)handle;
275 uartHandle->instance = uart_config->instance;
276
277 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
278
279 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
280 UART_TransferCreateHandle(s_UartAdapterBase[uart_config->instance], &uartHandle->hardwareHandle,
281 (uart_transfer_callback_t)HAL_UartCallback, handle);
282 #else
283 s_UartState[uartHandle->instance] = uartHandle;
284 /* Enable interrupt in NVIC. */
285 NVIC_SetPriority((IRQn_Type)s_UartIRQ[uart_config->instance], HAL_UART_ISR_PRIORITY);
286 (void)EnableIRQ(s_UartIRQ[uart_config->instance]);
287 #endif
288
289 #endif
290
291 return kStatus_HAL_UartSuccess;
292 }
293
HAL_UartDeinit(hal_uart_handle_t handle)294 hal_uart_status_t HAL_UartDeinit(hal_uart_handle_t handle)
295 {
296 hal_uart_state_t *uartHandle;
297
298 assert(handle);
299
300 uartHandle = (hal_uart_state_t *)handle;
301
302 UART_Deinit(s_UartAdapterBase[uartHandle->instance]);
303
304 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
305
306 #if !(defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
307 s_UartState[uartHandle->instance] = NULL;
308 #endif
309
310 #endif
311
312 return kStatus_HAL_UartSuccess;
313 }
314
HAL_UartReceiveBlocking(hal_uart_handle_t handle,uint8_t * data,size_t length)315 hal_uart_status_t HAL_UartReceiveBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
316 {
317 hal_uart_state_t *uartHandle;
318 status_t status;
319 assert(handle);
320 assert(data);
321 assert(length);
322
323 uartHandle = (hal_uart_state_t *)handle;
324
325 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
326 if (NULL != uartHandle->rx.buffer)
327 {
328 return kStatus_HAL_UartRxBusy;
329 }
330 #endif
331
332 status = UART_ReadBlocking(s_UartAdapterBase[uartHandle->instance], data, length);
333
334 return HAL_UartGetStatus(status);
335 }
336
HAL_UartSendBlocking(hal_uart_handle_t handle,const uint8_t * data,size_t length)337 hal_uart_status_t HAL_UartSendBlocking(hal_uart_handle_t handle, const uint8_t *data, size_t length)
338 {
339 hal_uart_state_t *uartHandle;
340 assert(handle);
341 assert(data);
342 assert(length);
343
344 uartHandle = (hal_uart_state_t *)handle;
345
346 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
347 if (NULL != uartHandle->tx.buffer)
348 {
349 return kStatus_HAL_UartTxBusy;
350 }
351 #endif
352
353 (void)UART_WriteBlocking(s_UartAdapterBase[uartHandle->instance], data, length);
354
355 return kStatus_HAL_UartSuccess;
356 }
357
HAL_UartEnterLowpower(hal_uart_handle_t handle)358 hal_uart_status_t HAL_UartEnterLowpower(hal_uart_handle_t handle)
359 {
360 assert(handle);
361
362 return kStatus_HAL_UartSuccess;
363 }
364
HAL_UartExitLowpower(hal_uart_handle_t handle)365 hal_uart_status_t HAL_UartExitLowpower(hal_uart_handle_t handle)
366 {
367 assert(handle);
368
369 return kStatus_HAL_UartSuccess;
370 }
371
372 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
373
374 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
375
HAL_UartTransferInstallCallback(hal_uart_handle_t handle,hal_uart_transfer_callback_t callback,void * callbackParam)376 hal_uart_status_t HAL_UartTransferInstallCallback(hal_uart_handle_t handle,
377 hal_uart_transfer_callback_t callback,
378 void *callbackParam)
379 {
380 hal_uart_state_t *uartHandle;
381
382 assert(handle);
383 assert(HAL_UART_TRANSFER_MODE);
384
385 uartHandle = (hal_uart_state_t *)handle;
386
387 uartHandle->callbackParam = callbackParam;
388 uartHandle->callback = callback;
389
390 return kStatus_HAL_UartSuccess;
391 }
392
HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle,hal_uart_transfer_t * transfer)393 hal_uart_status_t HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)
394 {
395 hal_uart_state_t *uartHandle;
396 status_t status;
397 assert(handle);
398 assert(transfer);
399 assert(HAL_UART_TRANSFER_MODE);
400
401 uartHandle = (hal_uart_state_t *)handle;
402
403 status = UART_TransferReceiveNonBlocking(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,
404 (uart_transfer_t *)(void *)transfer, NULL);
405
406 return HAL_UartGetStatus(status);
407 }
408
HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle,hal_uart_transfer_t * transfer)409 hal_uart_status_t HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)
410 {
411 hal_uart_state_t *uartHandle;
412 status_t status;
413 assert(handle);
414 assert(transfer);
415 assert(HAL_UART_TRANSFER_MODE);
416
417 uartHandle = (hal_uart_state_t *)handle;
418
419 status = UART_TransferSendNonBlocking(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,
420 (uart_transfer_t *)(void *)transfer);
421
422 return HAL_UartGetStatus(status);
423 }
424
HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle,uint32_t * count)425 hal_uart_status_t HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle, uint32_t *count)
426 {
427 hal_uart_state_t *uartHandle;
428 status_t status;
429 assert(handle);
430 assert(count);
431 assert(HAL_UART_TRANSFER_MODE);
432
433 uartHandle = (hal_uart_state_t *)handle;
434
435 status = UART_TransferGetReceiveCount(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);
436
437 return HAL_UartGetStatus(status);
438 }
439
HAL_UartTransferGetSendCount(hal_uart_handle_t handle,uint32_t * count)440 hal_uart_status_t HAL_UartTransferGetSendCount(hal_uart_handle_t handle, uint32_t *count)
441 {
442 hal_uart_state_t *uartHandle;
443 status_t status;
444 assert(handle);
445 assert(count);
446 assert(HAL_UART_TRANSFER_MODE);
447
448 uartHandle = (hal_uart_state_t *)handle;
449
450 status = UART_TransferGetSendCount(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);
451
452 return HAL_UartGetStatus(status);
453 }
454
HAL_UartTransferAbortReceive(hal_uart_handle_t handle)455 hal_uart_status_t HAL_UartTransferAbortReceive(hal_uart_handle_t handle)
456 {
457 hal_uart_state_t *uartHandle;
458 assert(handle);
459 assert(HAL_UART_TRANSFER_MODE);
460
461 uartHandle = (hal_uart_state_t *)handle;
462
463 UART_TransferAbortReceive(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
464
465 return kStatus_HAL_UartSuccess;
466 }
467
HAL_UartTransferAbortSend(hal_uart_handle_t handle)468 hal_uart_status_t HAL_UartTransferAbortSend(hal_uart_handle_t handle)
469 {
470 hal_uart_state_t *uartHandle;
471 assert(handle);
472 assert(HAL_UART_TRANSFER_MODE);
473
474 uartHandle = (hal_uart_state_t *)handle;
475
476 UART_TransferAbortSend(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
477
478 return kStatus_HAL_UartSuccess;
479 }
480
481 #else
482
483 /* None transactional API with non-blocking mode. */
HAL_UartInstallCallback(hal_uart_handle_t handle,hal_uart_transfer_callback_t callback,void * callbackParam)484 hal_uart_status_t HAL_UartInstallCallback(hal_uart_handle_t handle,
485 hal_uart_transfer_callback_t callback,
486 void *callbackParam)
487 {
488 hal_uart_state_t *uartHandle;
489
490 assert(handle);
491 assert(0U == HAL_UART_TRANSFER_MODE);
492
493 uartHandle = (hal_uart_state_t *)handle;
494
495 uartHandle->callbackParam = callbackParam;
496 uartHandle->callback = callback;
497
498 return kStatus_HAL_UartSuccess;
499 }
500
HAL_UartReceiveNonBlocking(hal_uart_handle_t handle,uint8_t * data,size_t length)501 hal_uart_status_t HAL_UartReceiveNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
502 {
503 hal_uart_state_t *uartHandle;
504 assert(handle);
505 assert(data);
506 assert(length);
507 assert(0U == HAL_UART_TRANSFER_MODE);
508
509 uartHandle = (hal_uart_state_t *)handle;
510
511 if (NULL != uartHandle->rx.buffer)
512 {
513 return kStatus_HAL_UartRxBusy;
514 }
515
516 uartHandle->rx.bufferLength = length;
517 uartHandle->rx.bufferSofar = 0;
518 uartHandle->rx.buffer = data;
519 UART_EnableInterrupts(s_UartAdapterBase[uartHandle->instance],
520 (uint32_t)kUART_RxDataRegFullInterruptEnable | (uint32_t)kUART_RxOverrunInterruptEnable);
521 return kStatus_HAL_UartSuccess;
522 }
523
HAL_UartSendNonBlocking(hal_uart_handle_t handle,uint8_t * data,size_t length)524 hal_uart_status_t HAL_UartSendNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
525 {
526 hal_uart_state_t *uartHandle;
527 assert(handle);
528 assert(data);
529 assert(length);
530 assert(0U == HAL_UART_TRANSFER_MODE);
531
532 uartHandle = (hal_uart_state_t *)handle;
533
534 if (NULL != uartHandle->tx.buffer)
535 {
536 return kStatus_HAL_UartTxBusy;
537 }
538 uartHandle->tx.bufferLength = length;
539 uartHandle->tx.bufferSofar = 0;
540 uartHandle->tx.buffer = (volatile uint8_t *)data;
541 UART_EnableInterrupts(s_UartAdapterBase[uartHandle->instance], (uint32_t)kUART_TxDataRegEmptyInterruptEnable);
542 return kStatus_HAL_UartSuccess;
543 }
544
HAL_UartGetReceiveCount(hal_uart_handle_t handle,uint32_t * reCount)545 hal_uart_status_t HAL_UartGetReceiveCount(hal_uart_handle_t handle, uint32_t *reCount)
546 {
547 hal_uart_state_t *uartHandle;
548 assert(handle);
549 assert(reCount);
550 assert(0U == HAL_UART_TRANSFER_MODE);
551
552 uartHandle = (hal_uart_state_t *)handle;
553
554 if (NULL != uartHandle->rx.buffer)
555 {
556 *reCount = uartHandle->rx.bufferSofar;
557 return kStatus_HAL_UartSuccess;
558 }
559 return kStatus_HAL_UartError;
560 }
561
HAL_UartGetSendCount(hal_uart_handle_t handle,uint32_t * seCount)562 hal_uart_status_t HAL_UartGetSendCount(hal_uart_handle_t handle, uint32_t *seCount)
563 {
564 hal_uart_state_t *uartHandle;
565 assert(handle);
566 assert(seCount);
567 assert(0U == HAL_UART_TRANSFER_MODE);
568
569 uartHandle = (hal_uart_state_t *)handle;
570
571 if (NULL != uartHandle->tx.buffer)
572 {
573 *seCount = uartHandle->tx.bufferSofar;
574 return kStatus_HAL_UartSuccess;
575 }
576 return kStatus_HAL_UartError;
577 }
578
HAL_UartAbortReceive(hal_uart_handle_t handle)579 hal_uart_status_t HAL_UartAbortReceive(hal_uart_handle_t handle)
580 {
581 hal_uart_state_t *uartHandle;
582 assert(handle);
583 assert(0U == HAL_UART_TRANSFER_MODE);
584
585 uartHandle = (hal_uart_state_t *)handle;
586
587 if (NULL != uartHandle->rx.buffer)
588 {
589 UART_DisableInterrupts(s_UartAdapterBase[uartHandle->instance],
590 (uint32_t)kUART_RxDataRegFullInterruptEnable | (uint32_t)kUART_RxOverrunInterruptEnable);
591 uartHandle->rx.buffer = NULL;
592 }
593
594 return kStatus_HAL_UartSuccess;
595 }
596
HAL_UartAbortSend(hal_uart_handle_t handle)597 hal_uart_status_t HAL_UartAbortSend(hal_uart_handle_t handle)
598 {
599 hal_uart_state_t *uartHandle;
600 assert(handle);
601 assert(0U == HAL_UART_TRANSFER_MODE);
602
603 uartHandle = (hal_uart_state_t *)handle;
604
605 if (NULL != uartHandle->tx.buffer)
606 {
607 UART_DisableInterrupts(s_UartAdapterBase[uartHandle->instance], (uint32_t)kUART_TxDataRegEmptyInterruptEnable);
608 uartHandle->tx.buffer = NULL;
609 }
610
611 return kStatus_HAL_UartSuccess;
612 }
613
614 #endif
615
616 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
617
HAL_UartIsrFunction(hal_uart_handle_t handle)618 void HAL_UartIsrFunction(hal_uart_handle_t handle)
619 {
620 hal_uart_state_t *uartHandle;
621 assert(handle);
622 assert(HAL_UART_TRANSFER_MODE);
623
624 uartHandle = (hal_uart_state_t *)handle;
625
626 #if 0
627 DisableIRQ(s_UartIRQ[uartHandle->instance]);
628 #endif
629 UART_TransferHandleIRQ(s_UartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
630 #if 0
631 NVIC_SetPriority((IRQn_Type)s_UartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);
632 EnableIRQ(s_UartIRQ[uartHandle->instance]);
633 #endif
634 }
635
636 #else
637
HAL_UartIsrFunction(hal_uart_handle_t handle)638 void HAL_UartIsrFunction(hal_uart_handle_t handle)
639 {
640 hal_uart_state_t *uartHandle;
641 assert(handle);
642 assert(0U == HAL_UART_TRANSFER_MODE);
643
644 uartHandle = (hal_uart_state_t *)handle;
645
646 #if 0
647 DisableIRQ(s_UartIRQ[uartHandle->instance]);
648 #endif
649 HAL_UartInterruptHandle(uartHandle->instance);
650 #if 0
651 NVIC_SetPriority((IRQn_Type)s_UartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);
652 EnableIRQ(s_UartIRQ[uartHandle->instance]);
653 #endif
654 }
655
656 #if defined(UART0)
657 #if ((!(defined(FSL_FEATURE_SOC_LPSCI_COUNT))) || \
658 ((defined(FSL_FEATURE_SOC_LPSCI_COUNT)) && (FSL_FEATURE_SOC_LPSCI_COUNT == 0)))
659 void UART0_IRQHandler(void);
UART0_IRQHandler(void)660 void UART0_IRQHandler(void)
661 {
662 HAL_UartInterruptHandle(0);
663 SDK_ISR_EXIT_BARRIER;
664 }
665
666 void UART0_RX_TX_IRQHandler(void);
UART0_RX_TX_IRQHandler(void)667 void UART0_RX_TX_IRQHandler(void)
668 {
669 UART0_IRQHandler();
670 SDK_ISR_EXIT_BARRIER;
671 }
672 #endif
673 #endif
674
675 #if defined(UART1)
676 void UART1_IRQHandler(void);
UART1_IRQHandler(void)677 void UART1_IRQHandler(void)
678 {
679 HAL_UartInterruptHandle(1);
680 SDK_ISR_EXIT_BARRIER;
681 }
682
683 void UART1_RX_TX_IRQHandler(void);
UART1_RX_TX_IRQHandler(void)684 void UART1_RX_TX_IRQHandler(void)
685 {
686 UART1_IRQHandler();
687 SDK_ISR_EXIT_BARRIER;
688 }
689 #endif
690
691 #if defined(UART2)
692 void UART2_IRQHandler(void);
UART2_IRQHandler(void)693 void UART2_IRQHandler(void)
694 {
695 HAL_UartInterruptHandle(2);
696 SDK_ISR_EXIT_BARRIER;
697 }
698
699 void UART2_RX_TX_IRQHandler(void);
UART2_RX_TX_IRQHandler(void)700 void UART2_RX_TX_IRQHandler(void)
701 {
702 UART2_IRQHandler();
703 SDK_ISR_EXIT_BARRIER;
704 }
705 #endif
706
707 #if defined(UART3)
708 void UART3_IRQHandler(void);
UART3_IRQHandler(void)709 void UART3_IRQHandler(void)
710 {
711 HAL_UartInterruptHandle(3);
712 SDK_ISR_EXIT_BARRIER;
713 }
714 void UART3_RX_TX_IRQHandler(void);
UART3_RX_TX_IRQHandler(void)715 void UART3_RX_TX_IRQHandler(void)
716 {
717 UART3_IRQHandler();
718 SDK_ISR_EXIT_BARRIER;
719 }
720 #endif
721
722 #if defined(UART4)
723 void UART4_IRQHandler(void);
UART4_IRQHandler(void)724 void UART4_IRQHandler(void)
725 {
726 HAL_UartInterruptHandle(4);
727 SDK_ISR_EXIT_BARRIER;
728 }
729 void UART4_RX_TX_IRQHandler(void);
UART4_RX_TX_IRQHandler(void)730 void UART4_RX_TX_IRQHandler(void)
731 {
732 UART4_IRQHandler();
733 SDK_ISR_EXIT_BARRIER;
734 }
735 #endif
736
737 #if defined(UART5)
738 void UART5_IRQHandler(void);
UART5_IRQHandler(void)739 void UART5_IRQHandler(void)
740 {
741 HAL_UartInterruptHandle(5);
742 SDK_ISR_EXIT_BARRIER;
743 }
744 void UART5_RX_TX_IRQHandler(void);
UART5_RX_TX_IRQHandler(void)745 void UART5_RX_TX_IRQHandler(void)
746 {
747 UART5_IRQHandler();
748 SDK_ISR_EXIT_BARRIER;
749 }
750 #endif
751
752 #if defined(FSL_FEATURE_UART_HAS_SHARED_IRQ0_IRQ1_IRQ2_IRQ3) && FSL_FEATURE_UART_HAS_SHARED_IRQ0_IRQ1_IRQ2_IRQ3
UART0_UART1_UART2_UART3_IRQHandler(void)753 void UART0_UART1_UART2_UART3_IRQHandler(void)
754 {
755 for (uint32_t instance = 0U; instance < 4U; instance++)
756 {
757 HAL_UartInterruptHandle(instance);
758 }
759 SDK_ISR_EXIT_BARRIER;
760 }
761 #endif /* FSL_FEATURE_UART_HAS_SHARED_IRQ0_IRQ1_IRQ2_IRQ3 */
762
763 #endif
764
765 #endif
766
