git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/component/serial_manager/serial_port_uart.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 "serial_manager.h"\r
  11 #include "serial_port_internal.h"\r
  12 \r
  13 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
  14 #include "uart.h"\r
  15 \r
  16 #include "serial_port_uart.h"\r
  17 \r
  18 /*******************************************************************************\r
  19  * Definitions\r
  20  ******************************************************************************/\r
  21 #ifndef NDEBUG\r
  22 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))\r
  23 #undef assert\r
  24 #define assert(n)\r
  25 #endif\r
  26 #endif\r
  27 \r
  28 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  29 #define SERIAL_PORT_UART_RECEIVE_DATA_LENGTH 1U\r
  30 \r
  31 typedef struct _serial_uart_send_state\r
  32 {\r
  33     serial_manager_callback_t callback;\r
  34     void *callbackParam;\r
  35     uint8_t *buffer;\r
  36     uint32_t length;\r
  37     volatile uint8_t busy;\r
  38 } serial_uart_send_state_t;\r
  39 \r
  40 typedef struct _serial_uart_recv_state\r
  41 {\r
  42     serial_manager_callback_t callback;\r
  43     void *callbackParam;\r
  44     volatile uint8_t busy;\r
  45     uint8_t readBuffer[SERIAL_PORT_UART_RECEIVE_DATA_LENGTH];\r
  46 } serial_uart_recv_state_t;\r
  47 #endif\r
  48 \r
  49 typedef struct _serial_uart_state\r
  50 {\r
  51 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  52     serial_uart_send_state_t tx;\r
  53     serial_uart_recv_state_t rx;\r
  54 #endif\r
  55     uint8_t usartHandleBuffer[HAL_UART_HANDLE_SIZE];\r
  56 } serial_uart_state_t;\r
  57 \r
  58 /*******************************************************************************\r
  59  * Prototypes\r
  60  ******************************************************************************/\r
  61 \r
  62 /*******************************************************************************\r
  63  * Code\r
  64  ******************************************************************************/\r
  65 \r
  66 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  67 /* UART user callback */\r
  68 static void Serial_UartCallback(hal_uart_handle_t handle, hal_uart_status_t status, void *userData)\r
  69 {\r
  70     serial_uart_state_t *serialUartHandle;\r
  71     serial_manager_callback_message_t msg;\r
  72 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
  73     hal_uart_transfer_t transfer;\r
  74 #endif\r
  75 \r
  76     if (NULL == userData)\r
  77     {\r
  78         return;\r
  79     }\r
  80 \r
  81     serialUartHandle = (serial_uart_state_t *)userData;\r
  82 \r
  83     if ((hal_uart_status_t)kStatus_HAL_UartRxIdle == status)\r
  84     {\r
  85         if ((NULL != serialUartHandle->rx.callback))\r
  86         {\r
  87             msg.buffer = &serialUartHandle->rx.readBuffer[0];\r
  88             msg.length = sizeof(serialUartHandle->rx.readBuffer);\r
  89             serialUartHandle->rx.callback(serialUartHandle->rx.callbackParam, &msg, kStatus_SerialManager_Success);\r
  90         }\r
  91 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
  92         transfer.data     = &serialUartHandle->rx.readBuffer[0];\r
  93         transfer.dataSize = sizeof(serialUartHandle->rx.readBuffer);\r
  94         if (kStatus_HAL_UartSuccess ==\r
  95             HAL_UartTransferReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))\r
  96 #else\r
  97         if ((hal_uart_status_t)kStatus_HAL_UartSuccess ==\r
  98             HAL_UartReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),\r
  99                                        &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer)))\r
 100 #endif\r
 101         {\r
 102             serialUartHandle->rx.busy = 1U;\r
 103         }\r
 104         else\r
 105         {\r
 106             serialUartHandle->rx.busy = 0U;\r
 107         }\r
 108     }\r
 109     else if ((hal_uart_status_t)kStatus_HAL_UartTxIdle == status)\r
 110     {\r
 111         if (0U != serialUartHandle->tx.busy)\r
 112         {\r
 113             serialUartHandle->tx.busy = 0U;\r
 114             if ((NULL != serialUartHandle->tx.callback))\r
 115             {\r
 116                 msg.buffer = serialUartHandle->tx.buffer;\r
 117                 msg.length = serialUartHandle->tx.length;\r
 118                 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &msg, kStatus_SerialManager_Success);\r
 119             }\r
 120         }\r
 121     }\r
 122     else\r
 123     {\r
 124     }\r
 125 }\r
 126 #endif\r
 127 \r
 128 serial_manager_status_t Serial_UartInit(serial_handle_t serialHandle, void *serialConfig)\r
 129 {\r
 130     serial_uart_state_t *serialUartHandle;\r
 131     serial_port_uart_config_t *uartConfig;\r
 132     hal_uart_config_t config;\r
 133 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 134 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 135     hal_uart_transfer_t transfer;\r
 136 #endif\r
 137 #endif\r
 138 \r
 139     assert(serialConfig);\r
 140     assert(serialHandle);\r
 141     assert(SERIAL_PORT_UART_HANDLE_SIZE >= sizeof(serial_uart_state_t));\r
 142 \r
 143     uartConfig       = (serial_port_uart_config_t *)serialConfig;\r
 144     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 145 \r
 146     config.baudRate_Bps = uartConfig->baudRate;\r
 147     config.parityMode   = (hal_uart_parity_mode_t)uartConfig->parityMode;\r
 148     config.stopBitCount = (hal_uart_stop_bit_count_t)uartConfig->stopBitCount;\r
 149     config.enableRx     = uartConfig->enableRx;\r
 150     config.enableTx     = uartConfig->enableTx;\r
 151     config.srcClock_Hz  = uartConfig->clockRate;\r
 152     config.instance     = uartConfig->instance;\r
 153 \r
 154     if (kStatus_HAL_UartSuccess != HAL_UartInit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &config))\r
 155     {\r
 156         return kStatus_SerialManager_Error;\r
 157     }\r
 158 \r
 159 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 160 \r
 161 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 162     if (kStatus_HAL_UartSuccess !=\r
 163         HAL_UartTransferInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),\r
 164                                         Serial_UartCallback, serialUartHandle))\r
 165 #else\r
 166     if (kStatus_HAL_UartSuccess != HAL_UartInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),\r
 167                                                            Serial_UartCallback, serialUartHandle))\r
 168 #endif\r
 169     {\r
 170         return kStatus_SerialManager_Error;\r
 171     }\r
 172 \r
 173     if (0U != uartConfig->enableRx)\r
 174     {\r
 175         serialUartHandle->rx.busy = 1U;\r
 176 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 177         transfer.data     = &serialUartHandle->rx.readBuffer[0];\r
 178         transfer.dataSize = sizeof(serialUartHandle->rx.readBuffer);\r
 179         if (kStatus_HAL_UartSuccess !=\r
 180             HAL_UartTransferReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))\r
 181 #else\r
 182         if (kStatus_HAL_UartSuccess !=\r
 183             HAL_UartReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),\r
 184                                        &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer)))\r
 185 #endif\r
 186         {\r
 187             serialUartHandle->rx.busy = 0U;\r
 188             return kStatus_SerialManager_Error;\r
 189         }\r
 190     }\r
 191 #endif\r
 192 \r
 193     return kStatus_SerialManager_Success;\r
 194 }\r
 195 \r
 196 serial_manager_status_t Serial_UartDeinit(serial_handle_t serialHandle)\r
 197 {\r
 198     serial_uart_state_t *serialUartHandle;\r
 199 \r
 200     assert(serialHandle);\r
 201 \r
 202     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 203 \r
 204 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 205 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 206     (void)HAL_UartTransferAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));\r
 207 #else\r
 208     (void)HAL_UartAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));\r
 209 #endif\r
 210 #endif\r
 211     (void)HAL_UartDeinit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));\r
 212 \r
 213 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 214     serialUartHandle->tx.busy = 0U;\r
 215     serialUartHandle->rx.busy = 0U;\r
 216 #endif\r
 217 \r
 218     return kStatus_SerialManager_Success;\r
 219 }\r
 220 \r
 221 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 222 \r
 223 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)\r
 224 {\r
 225     serial_uart_state_t *serialUartHandle;\r
 226 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 227     hal_uart_transfer_t transfer;\r
 228 #endif\r
 229 \r
 230     assert(serialHandle);\r
 231     assert(buffer);\r
 232     assert(length);\r
 233 \r
 234     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 235 \r
 236     if (0U != serialUartHandle->tx.busy)\r
 237     {\r
 238         return kStatus_SerialManager_Busy;\r
 239     }\r
 240     serialUartHandle->tx.busy = 1U;\r
 241 \r
 242     serialUartHandle->tx.buffer = buffer;\r
 243     serialUartHandle->tx.length = length;\r
 244 \r
 245 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 246     transfer.data     = buffer;\r
 247     transfer.dataSize = length;\r
 248     if (kStatus_HAL_UartSuccess !=\r
 249         HAL_UartTransferSendNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))\r
 250 #else\r
 251     if (kStatus_HAL_UartSuccess !=\r
 252         HAL_UartSendNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length))\r
 253 #endif\r
 254     {\r
 255         serialUartHandle->tx.busy = 0U;\r
 256         return kStatus_SerialManager_Error;\r
 257     }\r
 258     return kStatus_SerialManager_Success;\r
 259 }\r
 260 \r
 261 #else\r
 262 \r
 263 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)\r
 264 {\r
 265     serial_uart_state_t *serialUartHandle;\r
 266 \r
 267     assert(serialHandle);\r
 268     assert(buffer);\r
 269     assert(length);\r
 270 \r
 271     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 272 \r
 273     return (serial_manager_status_t)HAL_UartSendBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),\r
 274                                                          buffer, length);\r
 275 }\r
 276 \r
 277 serial_manager_status_t Serial_UartRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)\r
 278 {\r
 279     serial_uart_state_t *serialUartHandle;\r
 280 \r
 281     assert(serialHandle);\r
 282     assert(buffer);\r
 283     assert(length);\r
 284 \r
 285     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 286 \r
 287     return (serial_manager_status_t)HAL_UartReceiveBlocking(\r
 288         ((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length);\r
 289 }\r
 290 \r
 291 #endif\r
 292 \r
 293 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 294 serial_manager_status_t Serial_UartCancelWrite(serial_handle_t serialHandle)\r
 295 {\r
 296     serial_uart_state_t *serialUartHandle;\r
 297     serial_manager_callback_message_t msg;\r
 298     uint32_t primask;\r
 299     uint8_t isBusy = 0U;\r
 300 \r
 301     assert(serialHandle);\r
 302 \r
 303     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 304 \r
 305     primask                   = DisableGlobalIRQ();\r
 306     isBusy                    = serialUartHandle->tx.busy;\r
 307     serialUartHandle->tx.busy = 0U;\r
 308     EnableGlobalIRQ(primask);\r
 309 \r
 310 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))\r
 311     (void)HAL_UartTransferAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));\r
 312 #else\r
 313     (void)HAL_UartAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));\r
 314 #endif\r
 315     if (0U != isBusy)\r
 316     {\r
 317         if ((NULL != serialUartHandle->tx.callback))\r
 318         {\r
 319             msg.buffer = serialUartHandle->tx.buffer;\r
 320             msg.length = serialUartHandle->tx.length;\r
 321             serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &msg, kStatus_SerialManager_Canceled);\r
 322         }\r
 323     }\r
 324     return kStatus_SerialManager_Success;\r
 325 }\r
 326 \r
 327 serial_manager_status_t Serial_UartInstallTxCallback(serial_handle_t serialHandle,\r
 328                                                      serial_manager_callback_t callback,\r
 329                                                      void *callbackParam)\r
 330 {\r
 331     serial_uart_state_t *serialUartHandle;\r
 332 \r
 333     assert(serialHandle);\r
 334 \r
 335     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 336 \r
 337     serialUartHandle->tx.callback      = callback;\r
 338     serialUartHandle->tx.callbackParam = callbackParam;\r
 339 \r
 340     return kStatus_SerialManager_Success;\r
 341 }\r
 342 \r
 343 serial_manager_status_t Serial_UartInstallRxCallback(serial_handle_t serialHandle,\r
 344                                                      serial_manager_callback_t callback,\r
 345                                                      void *callbackParam)\r
 346 {\r
 347     serial_uart_state_t *serialUartHandle;\r
 348 \r
 349     assert(serialHandle);\r
 350 \r
 351     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 352 \r
 353     serialUartHandle->rx.callback      = callback;\r
 354     serialUartHandle->rx.callbackParam = callbackParam;\r
 355 \r
 356     return kStatus_SerialManager_Success;\r
 357 }\r
 358 \r
 359 void Serial_UartIsrFunction(serial_handle_t serialHandle)\r
 360 {\r
 361     serial_uart_state_t *serialUartHandle;\r
 362 \r
 363     assert(serialHandle);\r
 364 \r
 365     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 366 \r
 367     HAL_UartIsrFunction(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));\r
 368 }\r
 369 #endif\r
 370 \r
 371 serial_manager_status_t Serial_UartEnterLowpower(serial_handle_t serialHandle)\r
 372 {\r
 373     serial_uart_state_t *serialUartHandle;\r
 374 \r
 375     assert(serialHandle);\r
 376 \r
 377     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 378 \r
 379     if (kStatus_HAL_UartSuccess != HAL_UartEnterLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0])))\r
 380     {\r
 381         return kStatus_SerialManager_Error;\r
 382     }\r
 383 \r
 384     return kStatus_SerialManager_Success;\r
 385 }\r
 386 \r
 387 serial_manager_status_t Serial_UartExitLowpower(serial_handle_t serialHandle)\r
 388 {\r
 389     serial_uart_state_t *serialUartHandle;\r
 390 \r
 391     assert(serialHandle);\r
 392 \r
 393     serialUartHandle = (serial_uart_state_t *)serialHandle;\r
 394 \r
 395     if (kStatus_HAL_UartSuccess != HAL_UartExitLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0])))\r
 396     {\r
 397         return kStatus_SerialManager_Error;\r
 398     }\r
 399 \r
 400     return kStatus_SerialManager_Success;\r
 401 }\r
 402 \r
 403 #endif\r