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_usart.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     usart_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 USART_Type *const s_UsartAdapterBase[] = USART_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 USART IRQ number. */
69 static const IRQn_Type s_UsartIRQ[] = USART_IRQS;
70 
71 static hal_uart_state_t *s_UartState[sizeof(s_UsartAdapterBase) / sizeof(USART_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_USART_TxBusy:
90             uartStatus = kStatus_HAL_UartTxBusy;
91             break;
92         case kStatus_USART_RxBusy:
93             uartStatus = kStatus_HAL_UartRxBusy;
94             break;
95         case kStatus_USART_TxIdle:
96             uartStatus = kStatus_HAL_UartTxIdle;
97             break;
98         case kStatus_USART_RxIdle:
99             uartStatus = kStatus_HAL_UartRxIdle;
100             break;
101         case kStatus_USART_BaudrateNotSupport:
102             uartStatus = kStatus_HAL_UartBaudrateNotSupport;
103             break;
104         case kStatus_USART_NoiseError:
105         case kStatus_USART_FramingError:
106         case kStatus_USART_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(USART_Type * base,usart_handle_t * handle,status_t status,void * callbackParam)132 static void HAL_UartCallback(USART_Type *base, usart_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 (uartHandle->hardwareHandle.rxDataSize)
143         {
144             uartStatus = kStatus_HAL_UartError;
145         }
146     }
147 
148     if (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 
161     if (NULL == uartHandle)
162     {
163         return;
164     }
165 
166     status = USART_GetStatusFlags(s_UsartAdapterBase[instance]);
167 
168     /* Receive data register full */
169     if ((USART_STAT_RXRDY_MASK & status) &&
170         (USART_GetEnabledInterrupts(s_UsartAdapterBase[instance]) & kUSART_RxReadyInterruptEnable))
171     {
172         if (uartHandle->rx.buffer)
173         {
174             uartHandle->rx.buffer[uartHandle->rx.bufferSofar++] = USART_ReadByte(s_UsartAdapterBase[instance]);
175             if (uartHandle->rx.bufferSofar >= uartHandle->rx.bufferLength)
176             {
177                 USART_DisableInterrupts(s_UsartAdapterBase[instance],
178                                         kUSART_RxReadyInterruptEnable | kUSART_HardwareOverRunInterruptEnable);
179                 uartHandle->rx.buffer = NULL;
180                 if (uartHandle->callback)
181                 {
182                     uartHandle->callback(uartHandle, kStatus_HAL_UartRxIdle, uartHandle->callbackParam);
183                 }
184             }
185         }
186     }
187 
188     /* Send data register empty and the interrupt is enabled. */
189     if ((USART_STAT_TXRDY_MASK & status) &&
190         (USART_GetEnabledInterrupts(s_UsartAdapterBase[instance]) & kUSART_TxReadyInterruptEnable))
191     {
192         if (uartHandle->tx.buffer)
193         {
194             USART_WriteByte(s_UsartAdapterBase[instance], uartHandle->tx.buffer[uartHandle->tx.bufferSofar++]);
195             if (uartHandle->tx.bufferSofar >= uartHandle->tx.bufferLength)
196             {
197                 USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance], kUSART_TxReadyInterruptEnable);
198                 uartHandle->tx.buffer = NULL;
199                 if (uartHandle->callback)
200                 {
201                     uartHandle->callback(uartHandle, kStatus_HAL_UartTxIdle, uartHandle->callbackParam);
202                 }
203             }
204         }
205     }
206 
207 #if 1
208     USART_ClearStatusFlags(s_UsartAdapterBase[instance], status);
209 #endif
210 }
211 #endif
212 
213 #endif
214 
HAL_UartInit(hal_uart_handle_t handle,const hal_uart_config_t * uart_config)215 hal_uart_status_t HAL_UartInit(hal_uart_handle_t handle, const hal_uart_config_t *uart_config)
216 {
217     hal_uart_state_t *uartHandle;
218     usart_config_t usartConfig;
219     status_t status;
220     assert(handle);
221     assert(uart_config);
222     assert(uart_config->instance < (sizeof(s_UsartAdapterBase) / sizeof(USART_Type *)));
223     assert(s_UsartAdapterBase[uart_config->instance]);
224 
225     assert(HAL_UART_HANDLE_SIZE >= sizeof(hal_uart_state_t));
226 
227     USART_GetDefaultConfig(&usartConfig);
228     usartConfig.baudRate_Bps = uart_config->baudRate_Bps;
229 
230     if (kHAL_UartParityEven == uart_config->parityMode)
231     {
232         usartConfig.parityMode = kUSART_ParityEven;
233     }
234     else if (kHAL_UartParityOdd == uart_config->parityMode)
235     {
236         usartConfig.parityMode = kUSART_ParityOdd;
237     }
238     else
239     {
240         usartConfig.parityMode = kUSART_ParityDisabled;
241     }
242 
243     if (kHAL_UartTwoStopBit == uart_config->stopBitCount)
244     {
245         usartConfig.stopBitCount = kUSART_TwoStopBit;
246     }
247     else
248     {
249         usartConfig.stopBitCount = kUSART_OneStopBit;
250     }
251     usartConfig.enableRx = (bool)uart_config->enableRx;
252     usartConfig.enableTx = (bool)uart_config->enableTx;
253 
254     status = USART_Init(s_UsartAdapterBase[uart_config->instance], &usartConfig, uart_config->srcClock_Hz);
255 
256     if (kStatus_Success != status)
257     {
258         return HAL_UartGetStatus(status);
259     }
260 
261     uartHandle           = (hal_uart_state_t *)handle;
262     uartHandle->instance = uart_config->instance;
263 
264 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
265 
266 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
267     USART_TransferCreateHandle(s_UsartAdapterBase[uart_config->instance], &uartHandle->hardwareHandle,
268                                (usart_transfer_callback_t)HAL_UartCallback, handle);
269 #else
270     s_UartState[uartHandle->instance] = uartHandle;
271     /* Enable interrupt in NVIC. */
272     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uart_config->instance], HAL_UART_ISR_PRIORITY);
273     EnableIRQ(s_UsartIRQ[uart_config->instance]);
274 #endif
275 
276 #endif
277 
278     return kStatus_HAL_UartSuccess;
279 }
280 
HAL_UartDeinit(hal_uart_handle_t handle)281 hal_uart_status_t HAL_UartDeinit(hal_uart_handle_t handle)
282 {
283     hal_uart_state_t *uartHandle;
284 
285     assert(handle);
286 
287     uartHandle = (hal_uart_state_t *)handle;
288 
289     USART_Deinit(s_UsartAdapterBase[uartHandle->instance]);
290 
291 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
292 
293 #if !(defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
294     s_UartState[uartHandle->instance] = NULL;
295 #endif
296 
297 #endif
298 
299     return kStatus_HAL_UartSuccess;
300 }
301 
HAL_UartReceiveBlocking(hal_uart_handle_t handle,uint8_t * data,size_t length)302 hal_uart_status_t HAL_UartReceiveBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
303 {
304     hal_uart_state_t *uartHandle;
305     status_t status;
306     assert(handle);
307     assert(data);
308     assert(length);
309 
310     uartHandle = (hal_uart_state_t *)handle;
311 
312 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
313     if (uartHandle->rx.buffer)
314     {
315         return kStatus_HAL_UartRxBusy;
316     }
317 #endif
318 
319     status = USART_ReadBlocking(s_UsartAdapterBase[uartHandle->instance], data, length);
320 
321     return HAL_UartGetStatus(status);
322 }
323 
HAL_UartSendBlocking(hal_uart_handle_t handle,const uint8_t * data,size_t length)324 hal_uart_status_t HAL_UartSendBlocking(hal_uart_handle_t handle, const uint8_t *data, size_t length)
325 {
326     hal_uart_state_t *uartHandle;
327     assert(handle);
328     assert(data);
329     assert(length);
330 
331     uartHandle = (hal_uart_state_t *)handle;
332 
333 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
334     if (uartHandle->tx.buffer)
335     {
336         return kStatus_HAL_UartTxBusy;
337     }
338 #endif
339 
340     (void)USART_WriteBlocking(s_UsartAdapterBase[uartHandle->instance], data, length);
341 
342     return kStatus_HAL_UartSuccess;
343 }
344 
HAL_UartEnterLowpower(hal_uart_handle_t handle)345 hal_uart_status_t HAL_UartEnterLowpower(hal_uart_handle_t handle)
346 {
347     assert(handle);
348 
349     return kStatus_HAL_UartSuccess;
350 }
351 
HAL_UartExitLowpower(hal_uart_handle_t handle)352 hal_uart_status_t HAL_UartExitLowpower(hal_uart_handle_t handle)
353 {
354     assert(handle);
355 
356     return kStatus_HAL_UartSuccess;
357 }
358 
359 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))
360 
361 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
362 
HAL_UartTransferInstallCallback(hal_uart_handle_t handle,hal_uart_transfer_callback_t callback,void * callbackParam)363 hal_uart_status_t HAL_UartTransferInstallCallback(hal_uart_handle_t handle,
364                                                   hal_uart_transfer_callback_t callback,
365                                                   void *callbackParam)
366 {
367     hal_uart_state_t *uartHandle;
368 
369     assert(handle);
370     assert(HAL_UART_TRANSFER_MODE);
371 
372     uartHandle = (hal_uart_state_t *)handle;
373 
374     uartHandle->callbackParam = callbackParam;
375     uartHandle->callback      = callback;
376 
377     return kStatus_HAL_UartSuccess;
378 }
379 
HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle,hal_uart_transfer_t * transfer)380 hal_uart_status_t HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)
381 {
382     hal_uart_state_t *uartHandle;
383     status_t status;
384     assert(handle);
385     assert(transfer);
386     assert(HAL_UART_TRANSFER_MODE);
387 
388     uartHandle = (hal_uart_state_t *)handle;
389 
390     status = USART_TransferReceiveNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,
391                                               (usart_transfer_t *)transfer, NULL);
392 
393     return HAL_UartGetStatus(status);
394 }
395 
HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle,hal_uart_transfer_t * transfer)396 hal_uart_status_t HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)
397 {
398     hal_uart_state_t *uartHandle;
399     status_t status;
400     assert(handle);
401     assert(transfer);
402     assert(HAL_UART_TRANSFER_MODE);
403 
404     uartHandle = (hal_uart_state_t *)handle;
405 
406     status = USART_TransferSendNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,
407                                            (usart_transfer_t *)transfer);
408 
409     return HAL_UartGetStatus(status);
410 }
411 
HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle,uint32_t * count)412 hal_uart_status_t HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle, uint32_t *count)
413 {
414     hal_uart_state_t *uartHandle;
415     status_t status;
416     assert(handle);
417     assert(count);
418     assert(HAL_UART_TRANSFER_MODE);
419 
420     uartHandle = (hal_uart_state_t *)handle;
421 
422     status =
423         USART_TransferGetReceiveCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);
424 
425     return HAL_UartGetStatus(status);
426 }
427 
HAL_UartTransferGetSendCount(hal_uart_handle_t handle,uint32_t * count)428 hal_uart_status_t HAL_UartTransferGetSendCount(hal_uart_handle_t handle, uint32_t *count)
429 {
430     hal_uart_state_t *uartHandle;
431     status_t status;
432     assert(handle);
433     assert(count);
434     assert(HAL_UART_TRANSFER_MODE);
435 
436     uartHandle = (hal_uart_state_t *)handle;
437 
438     status = USART_TransferGetSendCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);
439 
440     return HAL_UartGetStatus(status);
441 }
442 
HAL_UartTransferAbortReceive(hal_uart_handle_t handle)443 hal_uart_status_t HAL_UartTransferAbortReceive(hal_uart_handle_t handle)
444 {
445     hal_uart_state_t *uartHandle;
446     assert(handle);
447     assert(HAL_UART_TRANSFER_MODE);
448 
449     uartHandle = (hal_uart_state_t *)handle;
450 
451     USART_TransferAbortReceive(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
452 
453     return kStatus_HAL_UartSuccess;
454 }
455 
HAL_UartTransferAbortSend(hal_uart_handle_t handle)456 hal_uart_status_t HAL_UartTransferAbortSend(hal_uart_handle_t handle)
457 {
458     hal_uart_state_t *uartHandle;
459     assert(handle);
460     assert(HAL_UART_TRANSFER_MODE);
461 
462     uartHandle = (hal_uart_state_t *)handle;
463 
464     USART_TransferAbortSend(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
465 
466     return kStatus_HAL_UartSuccess;
467 }
468 
469 #else
470 
471 /* None transactional API with non-blocking mode. */
HAL_UartInstallCallback(hal_uart_handle_t handle,hal_uart_transfer_callback_t callback,void * callbackParam)472 hal_uart_status_t HAL_UartInstallCallback(hal_uart_handle_t handle,
473                                           hal_uart_transfer_callback_t callback,
474                                           void *callbackParam)
475 {
476     hal_uart_state_t *uartHandle;
477 
478     assert(handle);
479     assert(!HAL_UART_TRANSFER_MODE);
480 
481     uartHandle = (hal_uart_state_t *)handle;
482 
483     uartHandle->callbackParam = callbackParam;
484     uartHandle->callback      = callback;
485 
486     return kStatus_HAL_UartSuccess;
487 }
488 
HAL_UartReceiveNonBlocking(hal_uart_handle_t handle,uint8_t * data,size_t length)489 hal_uart_status_t HAL_UartReceiveNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
490 {
491     hal_uart_state_t *uartHandle;
492     assert(handle);
493     assert(data);
494     assert(length);
495     assert(!HAL_UART_TRANSFER_MODE);
496 
497     uartHandle = (hal_uart_state_t *)handle;
498 
499     if (uartHandle->rx.buffer)
500     {
501         return kStatus_HAL_UartRxBusy;
502     }
503 
504     uartHandle->rx.bufferLength = length;
505     uartHandle->rx.bufferSofar  = 0;
506     uartHandle->rx.buffer       = data;
507     USART_EnableInterrupts(s_UsartAdapterBase[uartHandle->instance],
508                            kUSART_RxReadyInterruptEnable | kUSART_HardwareOverRunInterruptEnable);
509     return kStatus_HAL_UartSuccess;
510 }
511 
HAL_UartSendNonBlocking(hal_uart_handle_t handle,uint8_t * data,size_t length)512 hal_uart_status_t HAL_UartSendNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)
513 {
514     hal_uart_state_t *uartHandle;
515     assert(handle);
516     assert(data);
517     assert(length);
518     assert(!HAL_UART_TRANSFER_MODE);
519 
520     uartHandle = (hal_uart_state_t *)handle;
521 
522     if (uartHandle->tx.buffer)
523     {
524         return kStatus_HAL_UartTxBusy;
525     }
526     uartHandle->tx.bufferLength = length;
527     uartHandle->tx.bufferSofar  = 0;
528     uartHandle->tx.buffer       = (volatile uint8_t *)data;
529     USART_EnableInterrupts(s_UsartAdapterBase[uartHandle->instance], kUSART_TxReadyInterruptEnable);
530     return kStatus_HAL_UartSuccess;
531 }
532 
HAL_UartGetReceiveCount(hal_uart_handle_t handle,uint32_t * reCount)533 hal_uart_status_t HAL_UartGetReceiveCount(hal_uart_handle_t handle, uint32_t *reCount)
534 {
535     hal_uart_state_t *uartHandle;
536     assert(handle);
537     assert(reCount);
538     assert(!HAL_UART_TRANSFER_MODE);
539 
540     uartHandle = (hal_uart_state_t *)handle;
541 
542     if (uartHandle->rx.buffer)
543     {
544         *reCount = uartHandle->rx.bufferSofar;
545         return kStatus_HAL_UartSuccess;
546     }
547     return kStatus_HAL_UartError;
548 }
549 
HAL_UartGetSendCount(hal_uart_handle_t handle,uint32_t * seCount)550 hal_uart_status_t HAL_UartGetSendCount(hal_uart_handle_t handle, uint32_t *seCount)
551 {
552     hal_uart_state_t *uartHandle;
553     assert(handle);
554     assert(seCount);
555     assert(!HAL_UART_TRANSFER_MODE);
556 
557     uartHandle = (hal_uart_state_t *)handle;
558 
559     if (uartHandle->tx.buffer)
560     {
561         *seCount = uartHandle->tx.bufferSofar;
562         return kStatus_HAL_UartSuccess;
563     }
564     return kStatus_HAL_UartError;
565 }
566 
HAL_UartAbortReceive(hal_uart_handle_t handle)567 hal_uart_status_t HAL_UartAbortReceive(hal_uart_handle_t handle)
568 {
569     hal_uart_state_t *uartHandle;
570     assert(handle);
571     assert(!HAL_UART_TRANSFER_MODE);
572 
573     uartHandle = (hal_uart_state_t *)handle;
574 
575     if (uartHandle->rx.buffer)
576     {
577         USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance],
578                                 kUSART_RxReadyInterruptEnable | kUSART_HardwareOverRunInterruptEnable);
579         uartHandle->rx.buffer = NULL;
580     }
581 
582     return kStatus_HAL_UartSuccess;
583 }
584 
HAL_UartAbortSend(hal_uart_handle_t handle)585 hal_uart_status_t HAL_UartAbortSend(hal_uart_handle_t handle)
586 {
587     hal_uart_state_t *uartHandle;
588     assert(handle);
589     assert(!HAL_UART_TRANSFER_MODE);
590 
591     uartHandle = (hal_uart_state_t *)handle;
592 
593     if (uartHandle->tx.buffer)
594     {
595         USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance], kUSART_TxReadyInterruptEnable);
596         uartHandle->tx.buffer = NULL;
597     }
598 
599     return kStatus_HAL_UartSuccess;
600 }
601 
602 #endif
603 
604 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
605 
HAL_UartIsrFunction(hal_uart_handle_t handle)606 void HAL_UartIsrFunction(hal_uart_handle_t handle)
607 {
608     hal_uart_state_t *uartHandle;
609     assert(handle);
610     assert(HAL_UART_TRANSFER_MODE);
611 
612     uartHandle = (hal_uart_state_t *)handle;
613 
614 #if 0
615     DisableIRQ(s_UsartIRQ[uartHandle->instance]);
616 #endif
617     USART_TransferHandleIRQ(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);
618 #if 0
619     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);
620     EnableIRQ(s_UsartIRQ[uartHandle->instance]);
621 #endif
622 }
623 
624 #else
625 
HAL_UartIsrFunction(hal_uart_handle_t handle)626 void HAL_UartIsrFunction(hal_uart_handle_t handle)
627 {
628     hal_uart_state_t *uartHandle;
629     assert(handle);
630     assert(!HAL_UART_TRANSFER_MODE);
631 
632     uartHandle = (hal_uart_state_t *)handle;
633 
634 #if 0
635     DisableIRQ(s_UsartIRQ[uartHandle->instance]);
636 #endif
637     HAL_UartInterruptHandle(uartHandle->instance);
638 #if 0
639     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);
640     EnableIRQ(s_UsartIRQ[uartHandle->instance]);
641 #endif
642 }
643 
644 #if defined(USART0)
USART0_IRQHandler(void)645 void USART0_IRQHandler(void)
646 {
647     HAL_UartInterruptHandle(0);
648 }
649 #endif
650 
651 #if defined(USART1)
USART1_IRQHandler(void)652 void USART1_IRQHandler(void)
653 {
654     HAL_UartInterruptHandle(1);
655 }
656 #endif
657 
658 #if defined(USART2)
USART2_IRQHandler(void)659 void USART2_IRQHandler(void)
660 {
661     HAL_UartInterruptHandle(2);
662 }
663 #endif
664 
665 #if defined(USART3)
PIN_INT6_USART3_IRQHandler(void)666 void PIN_INT6_USART3_IRQHandler(void)
667 {
668     HAL_UartInterruptHandle(3);
669 }
670 #endif
671 
672 #if defined(USART4)
PIN_INT7_USART4_IRQHandler(void)673 void PIN_INT7_USART4_IRQHandler(void)
674 {
675     HAL_UartInterruptHandle(4);
676 }
677 #endif
678 #endif
679 
680 #endif
681