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 #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 hal_uart_status_t HAL_UartEnterLowpower(hal_uart_handle_t handle)\r
 344 {\r
 345     assert(handle);\r
 346 \r
 347     return kStatus_HAL_UartSuccess;\r
 348 }\r
 349 \r
 350 hal_uart_status_t HAL_UartExitLowpower(hal_uart_handle_t handle)\r
 351 {\r
 352     assert(handle);\r
 353 \r
 354     return kStatus_HAL_UartSuccess;\r
 355 }\r
 356 \r
 357 #if (defined(UART_ADAPTER_NON_BLOCKING_MODE) && (UART_ADAPTER_NON_BLOCKING_MODE > 0U))\r
 358 \r
 359 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 360 \r
 361 hal_uart_status_t HAL_UartTransferInstallCallback(hal_uart_handle_t handle,\r
 362                                                   hal_uart_transfer_callback_t callback,\r
 363                                                   void *callbackParam)\r
 364 {\r
 365     hal_uart_state_t *uartHandle;\r
 366 \r
 367     assert(handle);\r
 368     assert(HAL_UART_TRANSFER_MODE);\r
 369 \r
 370     uartHandle = (hal_uart_state_t *)handle;\r
 371 \r
 372     uartHandle->callbackParam = callbackParam;\r
 373     uartHandle->callback      = callback;\r
 374 \r
 375     return kStatus_HAL_UartSuccess;\r
 376 }\r
 377 \r
 378 hal_uart_status_t HAL_UartTransferReceiveNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)\r
 379 {\r
 380     hal_uart_state_t *uartHandle;\r
 381     status_t status;\r
 382     assert(handle);\r
 383     assert(transfer);\r
 384     assert(HAL_UART_TRANSFER_MODE);\r
 385 \r
 386     uartHandle = (hal_uart_state_t *)handle;\r
 387 \r
 388     status = USART_TransferReceiveNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,\r
 389                                               (usart_transfer_t *)transfer, NULL);\r
 390 \r
 391     return HAL_UartGetStatus(status);\r
 392 }\r
 393 \r
 394 hal_uart_status_t HAL_UartTransferSendNonBlocking(hal_uart_handle_t handle, hal_uart_transfer_t *transfer)\r
 395 {\r
 396     hal_uart_state_t *uartHandle;\r
 397     status_t status;\r
 398     assert(handle);\r
 399     assert(transfer);\r
 400     assert(HAL_UART_TRANSFER_MODE);\r
 401 \r
 402     uartHandle = (hal_uart_state_t *)handle;\r
 403 \r
 404     status = USART_TransferSendNonBlocking(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle,\r
 405                                            (usart_transfer_t *)transfer);\r
 406 \r
 407     return HAL_UartGetStatus(status);\r
 408 }\r
 409 \r
 410 hal_uart_status_t HAL_UartTransferGetReceiveCount(hal_uart_handle_t handle, uint32_t *count)\r
 411 {\r
 412     hal_uart_state_t *uartHandle;\r
 413     status_t status;\r
 414     assert(handle);\r
 415     assert(count);\r
 416     assert(HAL_UART_TRANSFER_MODE);\r
 417 \r
 418     uartHandle = (hal_uart_state_t *)handle;\r
 419 \r
 420     status =\r
 421         USART_TransferGetReceiveCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);\r
 422 \r
 423     return HAL_UartGetStatus(status);\r
 424 }\r
 425 \r
 426 hal_uart_status_t HAL_UartTransferGetSendCount(hal_uart_handle_t handle, uint32_t *count)\r
 427 {\r
 428     hal_uart_state_t *uartHandle;\r
 429     status_t status;\r
 430     assert(handle);\r
 431     assert(count);\r
 432     assert(HAL_UART_TRANSFER_MODE);\r
 433 \r
 434     uartHandle = (hal_uart_state_t *)handle;\r
 435 \r
 436     status = USART_TransferGetSendCount(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle, count);\r
 437 \r
 438     return HAL_UartGetStatus(status);\r
 439 }\r
 440 \r
 441 hal_uart_status_t HAL_UartTransferAbortReceive(hal_uart_handle_t handle)\r
 442 {\r
 443     hal_uart_state_t *uartHandle;\r
 444     assert(handle);\r
 445     assert(HAL_UART_TRANSFER_MODE);\r
 446 \r
 447     uartHandle = (hal_uart_state_t *)handle;\r
 448 \r
 449     USART_TransferAbortReceive(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);\r
 450 \r
 451     return kStatus_HAL_UartSuccess;\r
 452 }\r
 453 \r
 454 hal_uart_status_t HAL_UartTransferAbortSend(hal_uart_handle_t handle)\r
 455 {\r
 456     hal_uart_state_t *uartHandle;\r
 457     assert(handle);\r
 458     assert(HAL_UART_TRANSFER_MODE);\r
 459 \r
 460     uartHandle = (hal_uart_state_t *)handle;\r
 461 \r
 462     USART_TransferAbortSend(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);\r
 463 \r
 464     return kStatus_HAL_UartSuccess;\r
 465 }\r
 466 \r
 467 #else\r
 468 \r
 469 /* None transactional API with non-blocking mode. */\r
 470 hal_uart_status_t HAL_UartInstallCallback(hal_uart_handle_t handle,\r
 471                                           hal_uart_transfer_callback_t callback,\r
 472                                           void *callbackParam)\r
 473 {\r
 474     hal_uart_state_t *uartHandle;\r
 475 \r
 476     assert(handle);\r
 477     assert(!HAL_UART_TRANSFER_MODE);\r
 478 \r
 479     uartHandle = (hal_uart_state_t *)handle;\r
 480 \r
 481     uartHandle->callbackParam = callbackParam;\r
 482     uartHandle->callback      = callback;\r
 483 \r
 484     return kStatus_HAL_UartSuccess;\r
 485 }\r
 486 \r
 487 hal_uart_status_t HAL_UartReceiveNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)\r
 488 {\r
 489     hal_uart_state_t *uartHandle;\r
 490     assert(handle);\r
 491     assert(data);\r
 492     assert(length);\r
 493     assert(!HAL_UART_TRANSFER_MODE);\r
 494 \r
 495     uartHandle = (hal_uart_state_t *)handle;\r
 496 \r
 497     if (uartHandle->rx.buffer)\r
 498     {\r
 499         return kStatus_HAL_UartRxBusy;\r
 500     }\r
 501 \r
 502     uartHandle->rx.bufferLength = length;\r
 503     uartHandle->rx.bufferSofar  = 0;\r
 504     uartHandle->rx.buffer       = data;\r
 505     USART_EnableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENSET_RXLVL_MASK);\r
 506     return kStatus_HAL_UartSuccess;\r
 507 }\r
 508 \r
 509 hal_uart_status_t HAL_UartSendNonBlocking(hal_uart_handle_t handle, uint8_t *data, size_t length)\r
 510 {\r
 511     hal_uart_state_t *uartHandle;\r
 512     assert(handle);\r
 513     assert(data);\r
 514     assert(length);\r
 515     assert(!HAL_UART_TRANSFER_MODE);\r
 516 \r
 517     uartHandle = (hal_uart_state_t *)handle;\r
 518 \r
 519     if (uartHandle->tx.buffer)\r
 520     {\r
 521         return kStatus_HAL_UartTxBusy;\r
 522     }\r
 523     uartHandle->tx.bufferLength = length;\r
 524     uartHandle->tx.bufferSofar  = 0;\r
 525     uartHandle->tx.buffer       = (volatile uint8_t *)data;\r
 526     USART_EnableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENSET_TXLVL_MASK);\r
 527     return kStatus_HAL_UartSuccess;\r
 528 }\r
 529 \r
 530 hal_uart_status_t HAL_UartGetReceiveCount(hal_uart_handle_t handle, uint32_t *reCount)\r
 531 {\r
 532     hal_uart_state_t *uartHandle;\r
 533     assert(handle);\r
 534     assert(reCount);\r
 535     assert(!HAL_UART_TRANSFER_MODE);\r
 536 \r
 537     uartHandle = (hal_uart_state_t *)handle;\r
 538 \r
 539     if (uartHandle->rx.buffer)\r
 540     {\r
 541         *reCount = uartHandle->rx.bufferSofar;\r
 542         return kStatus_HAL_UartSuccess;\r
 543     }\r
 544     return kStatus_HAL_UartError;\r
 545 }\r
 546 \r
 547 hal_uart_status_t HAL_UartGetSendCount(hal_uart_handle_t handle, uint32_t *seCount)\r
 548 {\r
 549     hal_uart_state_t *uartHandle;\r
 550     assert(handle);\r
 551     assert(seCount);\r
 552     assert(!HAL_UART_TRANSFER_MODE);\r
 553 \r
 554     uartHandle = (hal_uart_state_t *)handle;\r
 555 \r
 556     if (uartHandle->tx.buffer)\r
 557     {\r
 558         *seCount = uartHandle->tx.bufferSofar;\r
 559         return kStatus_HAL_UartSuccess;\r
 560     }\r
 561     return kStatus_HAL_UartError;\r
 562 }\r
 563 \r
 564 hal_uart_status_t HAL_UartAbortReceive(hal_uart_handle_t handle)\r
 565 {\r
 566     hal_uart_state_t *uartHandle;\r
 567     assert(handle);\r
 568     assert(!HAL_UART_TRANSFER_MODE);\r
 569 \r
 570     uartHandle = (hal_uart_state_t *)handle;\r
 571 \r
 572     if (uartHandle->rx.buffer)\r
 573     {\r
 574         USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance],\r
 575                                 USART_FIFOINTENCLR_RXLVL_MASK | USART_FIFOINTENCLR_RXERR_MASK);\r
 576         uartHandle->rx.buffer = NULL;\r
 577     }\r
 578 \r
 579     return kStatus_HAL_UartSuccess;\r
 580 }\r
 581 \r
 582 hal_uart_status_t HAL_UartAbortSend(hal_uart_handle_t handle)\r
 583 {\r
 584     hal_uart_state_t *uartHandle;\r
 585     assert(handle);\r
 586     assert(!HAL_UART_TRANSFER_MODE);\r
 587 \r
 588     uartHandle = (hal_uart_state_t *)handle;\r
 589 \r
 590     if (uartHandle->tx.buffer)\r
 591     {\r
 592         USART_DisableInterrupts(s_UsartAdapterBase[uartHandle->instance], USART_FIFOINTENCLR_TXLVL_MASK);\r
 593         uartHandle->tx.buffer = NULL;\r
 594     }\r
 595 \r
 596     return kStatus_HAL_UartSuccess;\r
 597 }\r
 598 \r
 599 #endif\r
 600 \r
 601 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 602 \r
 603 void HAL_UartIsrFunction(hal_uart_handle_t handle)\r
 604 {\r
 605     hal_uart_state_t *uartHandle;\r
 606     assert(handle);\r
 607     assert(HAL_UART_TRANSFER_MODE);\r
 608 \r
 609     uartHandle = (hal_uart_state_t *)handle;\r
 610 \r
 611 #if 0\r
 612     DisableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 613 #endif\r
 614     USART_TransferHandleIRQ(s_UsartAdapterBase[uartHandle->instance], &uartHandle->hardwareHandle);\r
 615 #if 0\r
 616     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);\r
 617     EnableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 618 #endif\r
 619 }\r
 620 \r
 621 #else\r
 622 \r
 623 void HAL_UartIsrFunction(hal_uart_handle_t handle)\r
 624 {\r
 625     hal_uart_state_t *uartHandle;\r
 626     assert(handle);\r
 627     assert(!HAL_UART_TRANSFER_MODE);\r
 628 \r
 629     uartHandle = (hal_uart_state_t *)handle;\r
 630 \r
 631 #if 0\r
 632     DisableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 633 #endif\r
 634     HAL_UartInterruptHandle(s_UsartAdapterBase[uartHandle->instance], (void *)uartHandle);\r
 635 #if 0\r
 636     NVIC_SetPriority((IRQn_Type)s_UsartIRQ[uartHandle->instance], HAL_UART_ISR_PRIORITY);\r
 637     EnableIRQ(s_UsartIRQ[uartHandle->instance]);\r
 638 #endif\r
 639 }\r
 640 \r
 641 #endif\r
 642 \r
 643 #endif\r