git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/component/uart/usart_adapter.c

   1 /*\r
   2  * Copyright 2018 NXP\r
   3  * All rights reserved.\r
   4  *\r
   5  *\r
   6  * SPDX-License-Identifier: BSD-3-Clause\r
   7  */\r
   8 \r
   9 #include "fsl_common.h"\r
  10 #include "fsl_usart.h"\r
  11 #include "fsl_flexcomm.h"\r
  12 \r
  13 #include "uart.h"\r
  14 \r
  15 /*******************************************************************************\r
  16  * Definitions\r
  17  ******************************************************************************/\r
  18 #ifndef NDEBUG\r
  19 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))\r
  20 #undef assert\r
  21 #define assert(n)\r
  22 #endif\r
  23 #endif\r
  24 \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
  28 {\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
  33 \r
  34 /*! @brief uart TX state structure. */\r
  35 typedef struct _hal_uart_send_state\r
  36 {\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
  41 #endif\r
  42 /*! @brief uart state structure. */\r
  43 typedef struct _hal_uart_state\r
  44 {\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
  50 #endif\r
  51     hal_uart_receive_state_t rx;\r
  52     hal_uart_send_state_t tx;\r
  53 #endif\r
  54     uint8_t instance;\r
  55 } hal_uart_state_t;\r
  56 \r
  57 /*******************************************************************************\r
  58  * Prototypes\r
  59  ******************************************************************************/\r
  60 \r
  61 /*******************************************************************************\r
  62  * Variables\r
  63  ******************************************************************************/\r
  64 static USART_Type *const s_UsartAdapterBase[] = USART_BASE_PTRS;\r
  65 \r
  66 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
  67 \r
  68 /* Array of USART IRQ number. */\r
  69 static const IRQn_Type s_UsartIRQ[] = USART_IRQS;\r
  70 \r
  71 #if !(defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
  72 #endif\r
  73 \r
  74 #endif\r
  75 \r
  76 /*******************************************************************************\r
  77  * Code\r
  78  ******************************************************************************/\r
  79 \r
  80 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
  81 static hal_uart_status_t HAL_UartGetStatus(status_t status)\r
  82 {\r
  83     hal_uart_status_t uartStatus = kStatus_HAL_UartError;\r
  84     switch (status)\r
  85     {\r
  86         case kStatus_Success:\r
  87             uartStatus = kStatus_HAL_UartSuccess;\r
  88             break;\r
  89         case kStatus_USART_TxBusy:\r
  90             uartStatus = kStatus_HAL_UartTxBusy;\r
  91             break;\r
  92         case kStatus_USART_RxBusy:\r
  93             uartStatus = kStatus_HAL_UartRxBusy;\r
  94             break;\r
  95         case kStatus_USART_TxIdle:\r
  96             uartStatus = kStatus_HAL_UartTxIdle;\r
  97             break;\r
  98         case kStatus_USART_RxIdle:\r
  99             uartStatus = kStatus_HAL_UartRxIdle;\r
 100             break;\r
 101         case kStatus_USART_BaudrateNotSupport:\r
 102             uartStatus = kStatus_HAL_UartBaudrateNotSupport;\r
 103             break;\r
 104         case kStatus_USART_NoiseError:\r
 105         case kStatus_USART_FramingError:\r
 106         case kStatus_USART_ParityError:\r
 107             uartStatus = kStatus_HAL_UartProtocolError;\r
 108             break;\r
 109         default:\r
 110             break;\r
 111     }\r
 112     return uartStatus;\r
 113 }\r
 114 #else\r
 115 static hal_uart_status_t HAL_UartGetStatus(status_t status)\r
 116 {\r
 117     if (kStatus_Success == status)\r
 118     {\r
 119         return kStatus_HAL_UartSuccess;\r
 120     }\r
 121     else\r
 122     {\r
 123         return kStatus_HAL_UartError;\r
 124     }\r
 125 }\r
 126 #endif\r
 127 \r
 128 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 129 \r
 130 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 131 static void HAL_UartCallback(USART_Type *base, usart_handle_t *handle, status_t status, void *callbackParam)\r
 132 {\r
 133     hal_uart_state_t *uartHandle;\r
 134     hal_uart_status_t uartStatus = HAL_UartGetStatus(status);\r
 135     assert(callbackParam);\r
 136 \r
 137     uartHandle = (hal_uart_state_t *)callbackParam;\r
 138 \r
 139     if (kStatus_HAL_UartProtocolError == uartStatus)\r
 140     {\r
 141         if (uartHandle->hardwareHandle.rxDataSize)\r
 142         {\r
 143             uartStatus = kStatus_HAL_UartError;\r
 144         }\r
 145     }\r
 146 \r
 147     if (uartHandle->callback)\r
 148     {\r
 149         uartHandle->callback(uartHandle, uartStatus, uartHandle->callbackParam);\r
 150     }\r
 151 }\r
 152 \r
 153 #else\r
 154 \r
 155 static void HAL_UartInterruptHandle(USART_Type *base, void *handle)\r
 156 {\r
 157     hal_uart_state_t *uartHandle = (hal_uart_state_t *)handle;\r
 158     uint32_t status;\r
 159     uint8_t instance;\r
 160 \r
 161     if (NULL == uartHandle)\r
 162     {\r
 163         return;\r
 164     }\r
 165     instance = uartHandle->instance;\r
 166 \r
 167     status = USART_GetStatusFlags(s_UsartAdapterBase[instance]);\r
 168 \r
 169     /* Receive data register full */\r
 170     if ((USART_FIFOSTAT_RXNOTEMPTY_MASK & status) &&\r
 171         (USART_GetEnabledInterrupts(s_UsartAdapterBase[instance]) & USART_FIFOINTENSET_RXLVL_MASK))\r
 172     {\r
 173         if (uartHandle->rx.buffer)\r
 174         {\r
 175             uartHandle->rx.buffer[uartHandle->rx.bufferSofar++] = USART_ReadByte(s_UsartAdapterBase[instance]);\r
 176             if (uartHandle->rx.bufferSofar >= uartHandle->rx.bufferLength)\r
 177             {\r
 178                 USART_DisableInterrupts(s_UsartAdapterBase[instance],\r
 179                                         USART_FIFOINTENCLR_RXLVL_MASK | USART_FIFOINTENCLR_RXERR_MASK);\r
 180                 if (uartHandle->callback)\r
 181                 {\r
 182                     uartHandle->rx.buffer = NULL;\r
 183                     uartHandle->callback(uartHandle, kStatus_HAL_UartRxIdle, uartHandle->callbackParam);\r
 184                 }\r
 185             }\r
 186         }\r
 187     }\r
 188 \r
 189     /* Send data register empty and the interrupt is enabled. */\r
 190     if ((USART_FIFOSTAT_TXNOTFULL_MASK & status) &&\r
 191         (USART_GetEnabledInterrupts(s_UsartAdapterBase[instance]) & USART_FIFOINTENSET_TXLVL_MASK))\r
 192     {\r
 193         if (uartHandle->tx.buffer)\r
 194         {\r
 195             USART_WriteByte(s_UsartAdapterBase[instance], uartHandle->tx.buffer[uartHandle->tx.bufferSofar++]);\r
 196             if (uartHandle->tx.bufferSofar >= uartHandle->tx.bufferLength)\r
 197             {\r
 198                 USART_DisableInterrupts(s_UsartAdapterBase[instance], USART_FIFOINTENCLR_TXLVL_MASK);\r
 199                 if (uartHandle->callback)\r
 200                 {\r
 201                     uartHandle->tx.buffer = NULL;\r
 202                     uartHandle->callback(uartHandle, kStatus_HAL_UartTxIdle, uartHandle->callbackParam);\r
 203                 }\r
 204             }\r
 205         }\r
 206     }\r
 207 \r
 208 #if 1\r
 209     USART_ClearStatusFlags(s_UsartAdapterBase[instance], status);\r
 210 #endif\r
 211 }\r
 212 #endif\r
 213 \r
 214 #endif\r
 215 \r
 216 hal_uart_status_t HAL_UartInit(hal_uart_handle_t handle, hal_uart_config_t *config)\r
 217 {\r
 218     hal_uart_state_t *uartHandle;\r
 219     usart_config_t usartConfig;\r
 220     status_t status;\r
 221     assert(handle);\r
 222     assert(config);\r
 223     assert(config->instance < (sizeof(s_UsartAdapterBase) / sizeof(USART_Type *)));\r
 224     assert(s_UsartAdapterBase[config->instance]);\r
 225 \r
 226     if (HAL_UART_HANDLE_SIZE < sizeof(hal_uart_state_t))\r
 227     {\r
 228         return kStatus_HAL_UartError;\r
 229     }\r
 230 \r
 231     USART_GetDefaultConfig(&usartConfig);\r
 232     usartConfig.baudRate_Bps = config->baudRate_Bps;\r
 233 \r
 234     if (kHAL_UartParityEven == config->parityMode)\r
 235     {\r
 236         usartConfig.parityMode = kUSART_ParityEven;\r
 237     }\r
 238     else if (kHAL_UartParityOdd == config->parityMode)\r
 239     {\r
 240         usartConfig.parityMode = kUSART_ParityOdd;\r
 241     }\r
 242     else\r
 243     {\r
 244         usartConfig.parityMode = kUSART_ParityDisabled;\r
 245     }\r
 246 \r
 247     if (kHAL_UartTwoStopBit == config->stopBitCount)\r
 248     {\r
 249         usartConfig.stopBitCount = kUSART_TwoStopBit;\r
 250     }\r
 251     else\r
 252     {\r
 253         usartConfig.stopBitCount = kUSART_OneStopBit;\r
 254     }\r
 255     usartConfig.enableRx = config->enableRx;\r
 256     usartConfig.enableTx = config->enableTx;\r
 257     usartConfig.txWatermark = kUSART_TxFifo0;\r
 258     usartConfig.rxWatermark = kUSART_RxFifo1;\r
 259 \r
 260     status = USART_Init(s_UsartAdapterBase[config->instance], &usartConfig, config->srcClock_Hz);\r
 261 \r
 262     if (kStatus_Success != status)\r
 263     {\r
 264         return HAL_UartGetStatus(status);\r
 265     }\r
 266 \r
 267     uartHandle = (hal_uart_state_t *)handle;\r
 268     uartHandle->instance = config->instance;\r
 269 \r
 270 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 271 \r
 272 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 273     USART_TransferCreateHandle(s_UsartAdapterBase[config->instance], &uartHandle->hardwareHandle,\r
 274                                (usart_transfer_callback_t)HAL_UartCallback, handle);\r
 275 #else\r
 276     /* Enable interrupt in NVIC. */\r
 277     FLEXCOMM_SetIRQHandler(s_UsartAdapterBase[config->instance], (flexcomm_irq_handler_t)HAL_UartInterruptHandle,\r
 278                            handle);\r
 279     EnableIRQ(s_UsartIRQ[config->instance]);\r
 280 #endif\r
 281 \r
 282 #endif\r
 283 \r
 284     return kStatus_HAL_UartSuccess;\r
 285 }\r
 286 \r
 287 hal_uart_status_t HAL_UartDeinit(hal_uart_handle_t handle)\r
 288 {\r
 289     hal_uart_state_t *uartHandle;\r
 290 \r
 291     assert(handle);\r
 292 \r
 293     uartHandle = (hal_uart_state_t *)handle;\r
 294 \r
 295     USART_Deinit(s_UsartAdapterBase[uartHandle->instance]);\r
 296 \r
 297     return kStatus_HAL_UartSuccess;\r
 298 }\r
 299 \r
 300 hal_uart_status_t HAL_UartReceiveBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)\r
 301 {\r
 302     hal_uart_state_t *uartHandle;\r
 303     status_t status;\r
 304     assert(handle);\r
 305     assert(data);\r
 306     assert(length);\r
 307 \r
 308     uartHandle = (hal_uart_state_t *)handle;\r
 309 \r
 310 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 311     if (uartHandle->rx.buffer)\r
 312     {\r
 313         return kStatus_HAL_UartRxBusy;\r
 314     }\r
 315 #endif\r
 316 \r
 317     status = USART_ReadBlocking(s_UsartAdapterBase[uartHandle->instance], data, length);\r
 318 \r
 319     return HAL_UartGetStatus(status);\r
 320 }\r
 321 \r
 322 hal_uart_status_t HAL_UartSendBlocking(hal_uart_handle_t handle, const uint8_t *data, size_t length)\r
 323 {\r
 324     hal_uart_state_t *uartHandle;\r
 325     assert(handle);\r
 326     assert(data);\r
 327     assert(length);\r
 328 \r
 329     uartHandle = (hal_uart_state_t *)handle;\r
 330 \r
 331 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 332     if (uartHandle->tx.buffer)\r
 333     {\r
 334         return kStatus_HAL_UartTxBusy;\r
 335     }\r
 336 #endif\r
 337 \r
 338     USART_WriteBlocking(s_UsartAdapterBase[uartHandle->instance], data, length);\r
 339 \r
 340     return kStatus_HAL_UartSuccess;\r
 341 }\r
 342 \r
 343 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 344 \r
 345 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 346 \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
 350 {\r
 351     hal_uart_state_t *uartHandle;\r
 352 \r
 353     assert(handle);\r
 354     assert(HAL_UART_TRANSFER_MODE);\r
 355 \r
 356     uartHandle = (hal_uart_state_t *)handle;\r
 357 \r
 358     uartHandle->callbackParam = callbackParam;\r
 359     uartHandle->callback = callback;\r
 360 \r
 361     return kStatus_HAL_UartSuccess;\r
 362 }\r
 363 \r
 364 hal_uart_status_t HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)\r
 365 {\r
 366     hal_uart_state_t *uartHandle;\r
 367     status_t status;\r
 368     assert(handle);\r
 369     assert(transfer);\r
 370     assert(HAL_UART_TRANSFER_MODE);\r
 371 \r
 372     uartHandle = (hal_uart_state_t *)handle;\r
 373 \r
 374     status = USART_TransferReceiveNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,\r
 375                                               (usart_transfer_t *)transfer, NULL);\r
 376 \r
 377     return HAL_UartGetStatus(status);\r
 378 }\r
 379 \r
 380 hal_uart_status_t HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)\r
 381 {\r
 382     hal_uart_state_t *uartHandle;\r
 383     status_t status;\r
 384     assert(handle);\r
 385     assert(transfer);\r
 386     assert(HAL_UART_TRANSFER_MODE);\r
 387 \r
 388     uartHandle = (hal_uart_state_t *)handle;\r
 389 \r
 390     status = USART_TransferSendNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,\r
 391                                            (usart_transfer_t *)transfer);\r
 392 \r
 393     return HAL_UartGetStatus(status);\r
 394 }\r
 395 \r
 396 hal_uart_status_t HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle, uint32_t *count)\r
 397 {\r
 398     hal_uart_state_t *uartHandle;\r
 399     status_t status;\r
 400     assert(handle);\r
 401     assert(count);\r
 402     assert(HAL_UART_TRANSFER_MODE);\r
 403 \r
 404     uartHandle = (hal_uart_state_t *)handle;\r
 405 \r
 406     status =\r
 407         USART_TransferGetReceiveCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);\r
 408 \r
 409     return HAL_UartGetStatus(status);\r
 410 }\r
 411 \r
 412 hal_uart_status_t HAL_UartTransferGetSendCount(hal_uart_handle_t handle, uint32_t *count)\r
 413 {\r
 414     hal_uart_state_t *uartHandle;\r
 415     status_t status;\r
 416     assert(handle);\r
 417     assert(count);\r
 418     assert(HAL_UART_TRANSFER_MODE);\r
 419 \r
 420     uartHandle = (hal_uart_state_t *)handle;\r
 421 \r
 422     status = USART_TransferGetSendCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);\r
 423 \r
 424     return HAL_UartGetStatus(status);\r
 425 }\r
 426 \r
 427 hal_uart_status_t HAL_UartTransferAbortReceive(hal_uart_handle_t handle)\r
 428 {\r
 429     hal_uart_state_t *uartHandle;\r
 430     assert(handle);\r
 431     assert(HAL_UART_TRANSFER_MODE);\r
 432 \r
 433     uartHandle = (hal_uart_state_t *)handle;\r
 434 \r
 435     USART_TransferAbortReceive(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);\r
 436 \r
 437     return kStatus_HAL_UartSuccess;\r
 438 }\r
 439 \r
 440 hal_uart_status_t HAL_UartTransferAbortSend(hal_uart_handle_t handle)\r
 441 {\r
 442     hal_uart_state_t *uartHandle;\r
 443     assert(handle);\r
 444     assert(HAL_UART_TRANSFER_MODE);\r
 445 \r
 446     uartHandle = (hal_uart_state_t *)handle;\r
 447 \r
 448     USART_TransferAbortSend(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);\r
 449 \r
 450     return kStatus_HAL_UartSuccess;\r
 451 }\r
 452 \r
 453 #else\r
 454 \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
 459 {\r
 460     hal_uart_state_t *uartHandle;\r
 461 \r
 462     assert(handle);\r
 463     assert(!HAL_UART_TRANSFER_MODE);\r
 464 \r
 465     uartHandle = (hal_uart_state_t *)handle;\r
 466 \r
 467     uartHandle->callbackParam = callbackParam;\r
 468     uartHandle->callback = callback;\r
 469 \r
 470     return kStatus_HAL_UartSuccess;\r
 471 }\r
 472 \r
 473 hal_uart_status_t HAL_UartReceiveNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)\r
 474 {\r
 475     hal_uart_state_t *uartHandle;\r
 476     assert(handle);\r
 477     assert(data);\r
 478     assert(length);\r
 479     assert(!HAL_UART_TRANSFER_MODE);\r
 480 \r
 481     uartHandle = (hal_uart_state_t *)handle;\r
 482 \r
 483     if (uartHandle->rx.buffer)\r
 484     {\r
 485         return kStatus_HAL_UartRxBusy;\r
 486     }\r
 487 \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
 493 }\r
 494 \r
 495 hal_uart_status_t HAL_UartSendNonBlocking(hal_uart_handle_t handle, const uint8_t *data, size_t length)\r
 496 {\r
 497     hal_uart_state_t *uartHandle;\r
 498     assert(handle);\r
 499     assert(data);\r
 500     assert(length);\r
 501     assert(!HAL_UART_TRANSFER_MODE);\r
 502 \r
 503     uartHandle = (hal_uart_state_t *)handle;\r
 504 \r
 505     if (uartHandle->tx.buffer)\r
 506     {\r
 507         return kStatus_HAL_UartTxBusy;\r
 508     }\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
 514 }\r
 515 \r
 516 hal_uart_status_t HAL_UartGetReceiveCount(hal_uart_handle_t handle, uint32_t *count)\r
 517 {\r
 518     hal_uart_state_t *uartHandle;\r
 519     assert(handle);\r
 520     assert(count);\r
 521     assert(!HAL_UART_TRANSFER_MODE);\r
 522 \r
 523     uartHandle = (hal_uart_state_t *)handle;\r
 524 \r
 525     if (uartHandle->rx.buffer)\r
 526     {\r
 527         *count = uartHandle->rx.bufferSofar;\r
 528         return kStatus_HAL_UartSuccess;\r
 529     }\r
 530     return kStatus_HAL_UartError;\r
 531 }\r
 532 \r
 533 hal_uart_status_t HAL_UartGetSendCount(hal_uart_handle_t handle, uint32_t *count)\r
 534 {\r
 535     hal_uart_state_t *uartHandle;\r
 536     assert(handle);\r
 537     assert(count);\r
 538     assert(!HAL_UART_TRANSFER_MODE);\r
 539 \r
 540     uartHandle = (hal_uart_state_t *)handle;\r
 541 \r
 542     if (uartHandle->tx.buffer)\r
 543     {\r
 544         *count = uartHandle->tx.bufferSofar;\r
 545         return kStatus_HAL_UartSuccess;\r
 546     }\r
 547     return kStatus_HAL_UartError;\r
 548 }\r
 549 \r
 550 hal_uart_status_t HAL_UartAbortReceive(hal_uart_handle_t handle)\r
 551 {\r
 552     hal_uart_state_t *uartHandle;\r
 553     assert(handle);\r
 554     assert(!HAL_UART_TRANSFER_MODE);\r
 555 \r
 556     uartHandle = (hal_uart_state_t *)handle;\r
 557 \r
 558     if (uartHandle->rx.buffer)\r
 559     {\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
 563     }\r
 564 \r
 565     return kStatus_HAL_UartSuccess;\r
 566 }\r
 567 \r
 568 hal_uart_status_t HAL_UartAbortSend(hal_uart_handle_t handle)\r
 569 {\r
 570     hal_uart_state_t *uartHandle;\r
 571     assert(handle);\r
 572     assert(!HAL_UART_TRANSFER_MODE);\r
 573 \r
 574     uartHandle = (hal_uart_state_t *)handle;\r
 575 \r
 576     if (uartHandle->tx.buffer)\r
 577     {\r
 578         USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENCLR_TXLVL_MASK);\r
 579         uartHandle->tx.buffer = NULL;\r
 580     }\r
 581 \r
 582     return kStatus_HAL_UartSuccess;\r
 583 }\r
 584 \r
 585 #endif\r
 586 \r
 587 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 588 \r
 589 void HAL_UartIsrFunction(hal_uart_handle_t handle)\r
 590 {\r
 591     hal_uart_state_t *uartHandle;\r
 592     assert(handle);\r
 593     assert(HAL_UART_TRANSFER_MODE);\r
 594 \r
 595     uartHandle = (hal_uart_state_t *)handle;\r
 596 \r
 597 #if 0\r
 598     DisableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 599 #endif\r
 600     USART_TransferHandleIRQ(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);\r
 601 #if 0\r
 602     EnableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 603 #endif\r
 604 }\r
 605 \r
 606 #else\r
 607 \r
 608 void HAL_UartIsrFunction(hal_uart_handle_t handle)\r
 609 {\r
 610     hal_uart_state_t *uartHandle;\r
 611     assert(handle);\r
 612     assert(!HAL_UART_TRANSFER_MODE);\r
 613 \r
 614     uartHandle = (hal_uart_state_t *)handle;\r
 615 \r
 616 #if 0\r
 617     DisableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 618 #endif\r
 619     HAL_UartInterruptHandle(s_UsartAdapterBase[uartHandle->instance], (void *)uartHandle);\r
 620 #if 0\r
 621     EnableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 622 #endif\r
 623 }\r
 624 \r
 625 #endif\r
 626 \r
 627 #endif\r