git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M0+_LPC51U68_GCC_IAR_KEIL/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 #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
  71 #endif\r
  72 \r
  73 #endif\r
  74 \r
  75 /*******************************************************************************\r
  76  * Code\r
  77  ******************************************************************************/\r
  78 \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
  81 {\r
  82     hal_uart_status_t uartStatus = kStatus_HAL_UartError;\r
  83     switch (status)\r
  84     {\r
  85         case kStatus_Success:\r
  86             uartStatus = kStatus_HAL_UartSuccess;\r
  87             break;\r
  88         case kStatus_USART_TxBusy:\r
  89             uartStatus = kStatus_HAL_UartTxBusy;\r
  90             break;\r
  91         case kStatus_USART_RxBusy:\r
  92             uartStatus = kStatus_HAL_UartRxBusy;\r
  93             break;\r
  94         case kStatus_USART_TxIdle:\r
  95             uartStatus = kStatus_HAL_UartTxIdle;\r
  96             break;\r
  97         case kStatus_USART_RxIdle:\r
  98             uartStatus = kStatus_HAL_UartRxIdle;\r
  99             break;\r
 100         case kStatus_USART_BaudrateNotSupport:\r
 101             uartStatus = kStatus_HAL_UartBaudrateNotSupport;\r
 102             break;\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
 107             break;\r
 108         default:\r
 109             break;\r
 110     }\r
 111     return uartStatus;\r
 112 }\r
 113 #else\r
 114 static hal_uart_status_t HAL_UartGetStatus(status_t status)\r
 115 {\r
 116     if (kStatus_Success == status)\r
 117     {\r
 118         return kStatus_HAL_UartSuccess;\r
 119     }\r
 120     else\r
 121     {\r
 122         return kStatus_HAL_UartError;\r
 123     }\r
 124 }\r
 125 #endif\r
 126 \r
 127 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 128 \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
 131 {\r
 132     hal_uart_state_t *uartHandle;\r
 133     hal_uart_status_t uartStatus = HAL_UartGetStatus(status);\r
 134     assert(callbackParam);\r
 135 \r
 136     uartHandle = (hal_uart_state_t *)callbackParam;\r
 137 \r
 138     if (kStatus_HAL_UartProtocolError == uartStatus)\r
 139     {\r
 140         if (uartHandle->hardwareHandle.rxDataSize)\r
 141         {\r
 142             uartStatus = kStatus_HAL_UartError;\r
 143         }\r
 144     }\r
 145 \r
 146     if (uartHandle->callback)\r
 147     {\r
 148         uartHandle->callback(uartHandle, uartStatus, uartHandle->callbackParam);\r
 149     }\r
 150 }\r
 151 \r
 152 #else\r
 153 \r
 154 static void HAL_UartInterruptHandle(USART_Type *base, void *handle)\r
 155 {\r
 156     hal_uart_state_t *uartHandle = (hal_uart_state_t *)handle;\r
 157     uint32_t status;\r
 158     uint8_t instance;\r
 159 \r
 160     if (NULL == uartHandle)\r
 161     {\r
 162         return;\r
 163     }\r
 164     instance = uartHandle->instance;\r
 165 \r
 166     status = USART_GetStatusFlags(s_UsartAdapterBase[instance]);\r
 167 \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
 171     {\r
 172         if (uartHandle->rx.buffer)\r
 173         {\r
 174             uartHandle->rx.buffer[uartHandle->rx.bufferSofar++] = USART_ReadByte(s_UsartAdapterBase[instance]);\r
 175             if (uartHandle->rx.bufferSofar >= uartHandle->rx.bufferLength)\r
 176             {\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
 181                 {\r
 182                     uartHandle->callback(uartHandle, kStatus_HAL_UartRxIdle, uartHandle->callbackParam);\r
 183                 }\r
 184             }\r
 185         }\r
 186     }\r
 187 \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
 191     {\r
 192         if (uartHandle->tx.buffer)\r
 193         {\r
 194             USART_WriteByte(s_UsartAdapterBase[instance], uartHandle->tx.buffer[uartHandle->tx.bufferSofar++]);\r
 195             if (uartHandle->tx.bufferSofar >= uartHandle->tx.bufferLength)\r
 196             {\r
 197                 USART_DisableInterrupts(s_UsartAdapterBase[instance], USART_FIFOINTENCLR_TXLVL_MASK);\r
 198                 uartHandle->tx.buffer = NULL;\r
 199                 if (uartHandle->callback)\r
 200                 {\r
 201                     uartHandle->callback(uartHandle, kStatus_HAL_UartTxIdle, uartHandle->callbackParam);\r
 202                 }\r
 203             }\r
 204         }\r
 205     }\r
 206 \r
 207 #if 1\r
 208     USART_ClearStatusFlags(s_UsartAdapterBase[instance], status);\r
 209 #endif\r
 210 }\r
 211 #endif\r
 212 \r
 213 #endif\r
 214 \r
 215 hal_uart_status_t HAL_UartInit(hal_uart_handle_t handle, hal_uart_config_t *config)\r
 216 {\r
 217     hal_uart_state_t *uartHandle;\r
 218     usart_config_t usartConfig;\r
 219     status_t status;\r
 220     assert(handle);\r
 221     assert(config);\r
 222     assert(config->instance < (sizeof(s_UsartAdapterBase) / sizeof(USART_Type *)));\r
 223     assert(s_UsartAdapterBase[config->instance]);\r
 224 \r
 225     if (HAL_UART_HANDLE_SIZE < sizeof(hal_uart_state_t))\r
 226     {\r
 227         return kStatus_HAL_UartError;\r
 228     }\r
 229 \r
 230     USART_GetDefaultConfig(&usartConfig);\r
 231     usartConfig.baudRate_Bps = config->baudRate_Bps;\r
 232 \r
 233     if (kHAL_UartParityEven == config->parityMode)\r
 234     {\r
 235         usartConfig.parityMode = kUSART_ParityEven;\r
 236     }\r
 237     else if (kHAL_UartParityOdd == config->parityMode)\r
 238     {\r
 239         usartConfig.parityMode = kUSART_ParityOdd;\r
 240     }\r
 241     else\r
 242     {\r
 243         usartConfig.parityMode = kUSART_ParityDisabled;\r
 244     }\r
 245 \r
 246     if (kHAL_UartTwoStopBit == config->stopBitCount)\r
 247     {\r
 248         usartConfig.stopBitCount = kUSART_TwoStopBit;\r
 249     }\r
 250     else\r
 251     {\r
 252         usartConfig.stopBitCount = kUSART_OneStopBit;\r
 253     }\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
 258 \r
 259     status = USART_Init(s_UsartAdapterBase[config->instance], &usartConfig, config->srcClock_Hz);\r
 260 \r
 261     if (kStatus_Success != status)\r
 262     {\r
 263         return HAL_UartGetStatus(status);\r
 264     }\r
 265 \r
 266     uartHandle           = (hal_uart_state_t *)handle;\r
 267     uartHandle->instance = config->instance;\r
 268 \r
 269 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 270 \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
 274 #else\r
 275     /* Enable interrupt in NVIC. */\r
 276     FLEXCOMM_SetIRQHandler(s_UsartAdapterBase[config->instance], (flexcomm_irq_handler_t)HAL_UartInterruptHandle,\r
 277                            handle);\r
 278     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[config->instance], HAL_UART_ISR_PRIORITY);\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, 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 *reCount)\r
 517 {\r
 518     hal_uart_state_t *uartHandle;\r
 519     assert(handle);\r
 520     assert(reCount);\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         *reCount = 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 *seCount)\r
 534 {\r
 535     hal_uart_state_t *uartHandle;\r
 536     assert(handle);\r
 537     assert(seCount);\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         *seCount = 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     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);\r
 603     EnableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 604 #endif\r
 605 }\r
 606 \r
 607 #else\r
 608 \r
 609 void HAL_UartIsrFunction(hal_uart_handle_t handle)\r
 610 {\r
 611     hal_uart_state_t *uartHandle;\r
 612     assert(handle);\r
 613     assert(!HAL_UART_TRANSFER_MODE);\r
 614 \r
 615     uartHandle = (hal_uart_state_t *)handle;\r
 616 \r
 617 #if 0\r
 618     DisableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 619 #endif\r
 620     HAL_UartInterruptHandle(s_UsartAdapterBase[uartHandle->instance], (void *)uartHandle);\r
 621 #if 0\r
 622     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);\r
 623     EnableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 624 #endif\r
 625 }\r
 626 \r
 627 #endif\r
 628 \r
 629 #endif\r