git.sur5r.net Git - freertos/blob

   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 <string.h>\r
  11 \r
  12 #include "serial_manager.h"\r
  13 \r
  14 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  15 \r
  16 #include "generic_list.h"\r
  17 \r
  18 /*\r
  19  * The OSA_USED macro can only be defined when the OSA component is used.\r
  20  * If the source code of the OSA component does not exist, the OSA_USED cannot be defined.\r
  21  * OR, If OSA component is not added into project event the OSA source code exists, the OSA_USED\r
  22  * also cannot be defined.\r
  23  * The source code path of the OSA component is <MCUXpresso_SDK>/components/osa.\r
  24  *\r
  25  */\r
  26 #if defined(OSA_USED)\r
  27 \r
  28 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
  29 #include "common_task.h"\r
  30 #else\r
  31 #include "fsl_os_abstraction.h"\r
  32 #endif\r
  33 \r
  34 #endif\r
  35 \r
  36 #endif\r
  37 \r
  38 /*******************************************************************************\r
  39  * Definitions\r
  40  ******************************************************************************/\r
  41 \r
  42 #ifndef NDEBUG\r
  43 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))\r
  44 #undef assert\r
  45 #define assert(n)\r
  46 #endif\r
  47 #endif\r
  48 \r
  49 #define SERIAL_EVENT_DATA_RECEIVED (1U << 0)\r
  50 #define SERIAL_EVENT_DATA_SENT (1U << 1)\r
  51 \r
  52 #define SERIAL_MANAGER_WRITE_TAG 0xAABB5754U\r
  53 #define SERIAL_MANAGER_READ_TAG 0xBBAA5244U\r
  54 \r
  55 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  56 typedef enum _serial_manager_transmission_mode\r
  57 {\r
  58     kSerialManager_TransmissionBlocking = 0x0U,    /*!< Blocking transmission*/\r
  59     kSerialManager_TransmissionNonBlocking = 0x1U, /*!< None blocking transmission*/\r
  60 } serial_manager_transmission_mode_t;\r
  61 \r
  62 /* TX transfer structure */\r
  63 typedef struct _serial_manager_transfer\r
  64 {\r
  65     uint8_t *buffer;\r
  66     volatile uint32_t length;\r
  67     volatile uint32_t soFar;\r
  68     serial_manager_transmission_mode_t mode;\r
  69     serial_manager_status_t status;\r
  70 } serial_manager_transfer_t;\r
  71 #endif\r
  72 \r
  73 /* write handle structure */\r
  74 typedef struct _serial_manager_send_handle\r
  75 {\r
  76 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  77     list_element_t link; /*!< list element of the link */\r
  78     serial_manager_transfer_t transfer;\r
  79 #endif\r
  80     struct _serial_manager_handle *serialManagerHandle;\r
  81 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  82     serial_manager_callback_t callback;\r
  83     void *callbackParam;\r
  84     uint32_t tag;\r
  85 #endif\r
  86 } serial_manager_write_handle_t;\r
  87 \r
  88 typedef serial_manager_write_handle_t serial_manager_read_handle_t;\r
  89 \r
  90 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
  91 /* receive state structure */\r
  92 typedef struct _serial_manager_read_ring_buffer\r
  93 {\r
  94     uint8_t *ringBuffer;\r
  95     uint32_t ringBufferSize;\r
  96     volatile uint32_t ringHead;\r
  97     volatile uint32_t ringTail;\r
  98 } serial_manager_read_ring_buffer_t;\r
  99 #endif\r
 100 \r
 101 #if defined(__CC_ARM)\r
 102 #pragma anon_unions\r
 103 #endif\r
 104 /* The serial manager handle structure */\r
 105 typedef struct _serial_manager_handle\r
 106 {\r
 107 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 108     list_t runningWriteHandleHead;   /*!< The queue of running write handle */\r
 109     list_t completedWriteHandleHead; /*!< The queue of completed write handle */\r
 110 #endif\r
 111     serial_manager_read_handle_t *openedReadHandleHead;\r
 112     uint32_t openedWriteHandleCount;\r
 113     union\r
 114     {\r
 115         uint8_t lowLevelhandleBuffer[1];\r
 116 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 117         uint8_t uartHandleBuffer[SERIAL_PORT_UART_HANDLE_SIZE];\r
 118 #endif\r
 119 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 120         uint8_t usbcdcHandleBuffer[SERIAL_PORT_USB_CDC_HANDLE_SIZE];\r
 121 #endif\r
 122 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 123         uint8_t swoHandleBuffer[SERIAL_PORT_SWO_HANDLE_SIZE];\r
 124 #endif\r
 125     };\r
 126 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 127     serial_manager_read_ring_buffer_t ringBuffer;\r
 128 #endif\r
 129 \r
 130 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 131 \r
 132 #if defined(OSA_USED)\r
 133 \r
 134 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 135     common_task_message_t commontaskMsg;\r
 136 #else\r
 137     uint8_t event[OSA_EVENT_HANDLE_SIZE]; /*!< Event instance */\r
 138     uint8_t taskId[OSA_TASK_HANDLE_SIZE]; /*!< Task handle */\r
 139 #endif\r
 140 \r
 141 #endif\r
 142 \r
 143 #endif\r
 144 \r
 145     serial_port_type_t type;\r
 146 } serial_manager_handle_t;\r
 147 \r
 148 /*******************************************************************************\r
 149  * Prototypes\r
 150  ******************************************************************************/\r
 151 \r
 152 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 153 serial_manager_status_t Serial_UartInit(serial_handle_t serialHandle, void *config);\r
 154 serial_manager_status_t Serial_UartDeinit(serial_handle_t serialHandle);\r
 155 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
 156 #if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 157 serial_manager_status_t Serial_UartRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
 158 #endif\r
 159 serial_manager_status_t Serial_UartCancelWrite(serial_handle_t serialHandle);\r
 160 serial_manager_status_t Serial_UartInstallTxCallback(serial_handle_t serialHandle,\r
 161                                                      serial_manager_callback_t callback,\r
 162                                                      void *callbackParam);\r
 163 serial_manager_status_t Serial_UartInstallRxCallback(serial_handle_t serialHandle,\r
 164                                                      serial_manager_callback_t callback,\r
 165                                                      void *callbackParam);\r
 166 void Serial_UartIsrFunction(serial_handle_t serialHandle);\r
 167 #endif\r
 168 \r
 169 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 170 serial_manager_status_t Serial_UsbCdcInit(serial_handle_t serialHandle, void *config);\r
 171 serial_manager_status_t Serial_UsbCdcDeinit(serial_handle_t serialHandle);\r
 172 serial_manager_status_t Serial_UsbCdcWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
 173 serial_manager_status_t Serial_UsbCdcCancelWrite(serial_handle_t serialHandle);\r
 174 serial_manager_status_t Serial_UsbCdcInstallTxCallback(serial_handle_t serialHandle,\r
 175                                                        serial_manager_callback_t callback,\r
 176                                                        void *callbackParam);\r
 177 serial_manager_status_t Serial_UsbCdcInstallRxCallback(serial_handle_t serialHandle,\r
 178                                                        serial_manager_callback_t callback,\r
 179                                                        void *callbackParam);\r
 180 void Serial_UsbCdcIsrFunction(serial_handle_t serialHandle);\r
 181 #endif\r
 182 \r
 183 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 184 serial_manager_status_t Serial_SwoInit(serial_handle_t serialHandle, void *config);\r
 185 serial_manager_status_t Serial_SwoDeinit(serial_handle_t serialHandle);\r
 186 serial_manager_status_t Serial_SwoWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
 187 #if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 188 serial_manager_status_t Serial_SwoRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
 189 #endif\r
 190 serial_manager_status_t Serial_SwoCancelWrite(serial_handle_t serialHandle);\r
 191 serial_manager_status_t Serial_SwoInstallTxCallback(serial_handle_t serialHandle,\r
 192                                                     serial_manager_callback_t callback,\r
 193                                                     void *callbackParam);\r
 194 serial_manager_status_t Serial_SwoInstallRxCallback(serial_handle_t serialHandle,\r
 195                                                     serial_manager_callback_t callback,\r
 196                                                     void *callbackParam);\r
 197 void Serial_SwoIsrFunction(serial_handle_t serialHandle);\r
 198 #endif\r
 199 \r
 200 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 201 static void SerialManager_Task(void *param);\r
 202 #endif\r
 203 \r
 204 /*******************************************************************************\r
 205  * Variables\r
 206  ******************************************************************************/\r
 207 \r
 208 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 209 \r
 210 #if defined(OSA_USED)\r
 211 \r
 212 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 213 \r
 214 #else\r
 215                                           /*\r
 216                                            * \brief Defines the serial manager task's stack\r
 217                                            */\r
 218 OSA_TASK_DEFINE(SerialManager_Task, SERIAL_MANAGER_TASK_PRIORITY, 1, SERIAL_MANAGER_TASK_STACK_SIZE, false);\r
 219 #endif\r
 220 \r
 221 #endif\r
 222 \r
 223 #endif\r
 224 \r
 225 /*******************************************************************************\r
 226  * Code\r
 227  ******************************************************************************/\r
 228 \r
 229 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 230 static void SerialManager_AddTail(list_t *queue, serial_manager_write_handle_t *node)\r
 231 {\r
 232     LIST_AddTail(queue, &node->link);\r
 233 }\r
 234 \r
 235 static void SerialManager_RemoveHead(list_t *queue)\r
 236 {\r
 237     LIST_RemoveHead(queue);\r
 238 }\r
 239 #endif\r
 240 \r
 241 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 242 \r
 243 static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle)\r
 244 {\r
 245     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 246     serial_manager_write_handle_t *writeHandle =\r
 247         (serial_manager_write_handle_t *)LIST_GetHead(&handle->runningWriteHandleHead);\r
 248 \r
 249     if (writeHandle)\r
 250     {\r
 251         switch (handle->type)\r
 252         {\r
 253 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 254             case kSerialPort_Uart:\r
 255                 status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 256                                           writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 257                 break;\r
 258 #endif\r
 259 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 260             case kSerialPort_UsbCdc:\r
 261                 status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 262                                             writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 263                 break;\r
 264 #endif\r
 265 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 266             case kSerialPort_Swo:\r
 267                 status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 268                                          writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 269                 break;\r
 270 #endif\r
 271             default:\r
 272                 break;\r
 273         }\r
 274     }\r
 275     return status;\r
 276 }\r
 277 \r
 278 #else\r
 279 \r
 280 static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle,\r
 281                                                           serial_manager_write_handle_t *writeHandle,\r
 282                                                           uint8_t *buffer,\r
 283                                                           uint32_t length)\r
 284 {\r
 285     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 286 \r
 287     if (writeHandle)\r
 288     {\r
 289         switch (handle->type)\r
 290         {\r
 291 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 292             case kSerialPort_Uart:\r
 293                 status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 294                 break;\r
 295 #endif\r
 296 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 297             case kSerialPort_UsbCdc:\r
 298                 status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 299                 break;\r
 300 #endif\r
 301 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 302             case kSerialPort_Swo:\r
 303                 status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 304                 break;\r
 305 #endif\r
 306             default:\r
 307                 break;\r
 308         }\r
 309     }\r
 310     return status;\r
 311 }\r
 312 \r
 313 static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,\r
 314                                                           serial_manager_read_handle_t *readHandle,\r
 315                                                           uint8_t *buffer,\r
 316                                                           uint32_t length)\r
 317 {\r
 318     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 319 \r
 320     if (readHandle)\r
 321     {\r
 322         switch (handle->type)\r
 323         {\r
 324 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 325             case kSerialPort_Uart:\r
 326                 status = Serial_UartRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 327                 break;\r
 328 #endif\r
 329 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 330             case kSerialPort_UsbCdc:\r
 331                 status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 332                 break;\r
 333 #endif\r
 334 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 335             case kSerialPort_Swo:\r
 336                 status = Serial_SwoRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 337                 break;\r
 338 #endif\r
 339             default:\r
 340                 break;\r
 341         }\r
 342     }\r
 343     return status;\r
 344 }\r
 345 #endif\r
 346 \r
 347 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 348 static void SerialManager_IsrFunction(serial_manager_handle_t *handle)\r
 349 {\r
 350     uint32_t regPrimask = DisableGlobalIRQ();\r
 351     switch (handle->type)\r
 352     {\r
 353 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 354         case kSerialPort_Uart:\r
 355             Serial_UartIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 356             break;\r
 357 #endif\r
 358 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 359         case kSerialPort_UsbCdc:\r
 360             Serial_UsbCdcIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 361             break;\r
 362 #endif\r
 363 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 364         case kSerialPort_Swo:\r
 365             Serial_SwoIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 366             break;\r
 367 #endif\r
 368         default:\r
 369             break;\r
 370     }\r
 371     EnableGlobalIRQ(regPrimask);\r
 372 }\r
 373 \r
 374 static void SerialManager_Task(void *param)\r
 375 {\r
 376     serial_manager_handle_t *handle = (serial_manager_handle_t *)param;\r
 377     serial_manager_write_handle_t *serialWriteHandle;\r
 378     serial_manager_read_handle_t *serialReadHandle;\r
 379     serial_manager_callback_message_t msg;\r
 380     if (NULL != handle)\r
 381     {\r
 382 #if defined(OSA_USED)\r
 383 \r
 384 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 385 #else\r
 386         osa_event_flags_t ev = 0;\r
 387 \r
 388         do\r
 389         {\r
 390             if (KOSA_StatusSuccess ==\r
 391                 OSA_EventWait((osa_event_handle_t)handle->event, osaEventFlagsAll_c, false, osaWaitForever_c, &ev))\r
 392             {\r
 393                 if (ev & SERIAL_EVENT_DATA_SENT)\r
 394 #endif\r
 395 \r
 396 #endif\r
 397         {\r
 398             serialWriteHandle = (serial_manager_write_handle_t *)LIST_GetHead(&handle->completedWriteHandleHead);\r
 399             while (NULL != serialWriteHandle)\r
 400             {\r
 401                 SerialManager_RemoveHead(&handle->completedWriteHandleHead);\r
 402                 msg.buffer = serialWriteHandle->transfer.buffer;\r
 403                 msg.length = serialWriteHandle->transfer.soFar;\r
 404                 serialWriteHandle->transfer.buffer = NULL;\r
 405                 if (serialWriteHandle->callback)\r
 406                 {\r
 407                     serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,\r
 408                                                 serialWriteHandle->transfer.status);\r
 409                 }\r
 410                 serialWriteHandle = (serial_manager_write_handle_t *)LIST_GetHead(&handle->completedWriteHandleHead);\r
 411             }\r
 412         }\r
 413 #if defined(OSA_USED)\r
 414 \r
 415 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 416 #else\r
 417                 if (ev & SERIAL_EVENT_DATA_RECEIVED)\r
 418 #endif\r
 419 \r
 420 #endif\r
 421         {\r
 422             serialReadHandle = handle->openedReadHandleHead;\r
 423             if ((serialReadHandle) && (serialReadHandle->transfer.buffer) &&\r
 424                 (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length))\r
 425             {\r
 426                 msg.buffer = serialReadHandle->transfer.buffer;\r
 427                 msg.length = serialReadHandle->transfer.soFar;\r
 428                 serialReadHandle->transfer.buffer = NULL;\r
 429                 if (serialReadHandle->callback)\r
 430                 {\r
 431                     serialReadHandle->callback(serialReadHandle->callbackParam, &msg,\r
 432                                                serialReadHandle->transfer.status);\r
 433                 }\r
 434             }\r
 435         }\r
 436 #if defined(OSA_USED)\r
 437 \r
 438 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 439 #else\r
 440             }\r
 441         } while (gUseRtos_c);\r
 442 #endif\r
 443 \r
 444 #endif\r
 445     }\r
 446 }\r
 447 #endif\r
 448 \r
 449 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 450 static void SerialManager_TxCallback(void *callbackParam,\r
 451                                      serial_manager_callback_message_t *message,\r
 452                                      serial_manager_status_t status)\r
 453 {\r
 454     serial_manager_handle_t *handle;\r
 455     serial_manager_write_handle_t *writeHandle;\r
 456 \r
 457     assert(callbackParam);\r
 458     assert(message);\r
 459 \r
 460     handle = (serial_manager_handle_t *)callbackParam;\r
 461 \r
 462     writeHandle = (serial_manager_write_handle_t *)LIST_GetHead(&handle->runningWriteHandleHead);\r
 463 \r
 464     if (NULL != writeHandle)\r
 465     {\r
 466         SerialManager_RemoveHead(&handle->runningWriteHandleHead);\r
 467         SerialManager_StartWriting(handle);\r
 468         writeHandle->transfer.soFar = message->length;\r
 469         writeHandle->transfer.status = status;\r
 470         if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)\r
 471         {\r
 472             SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);\r
 473 #if defined(OSA_USED)\r
 474 \r
 475 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 476             handle->commontaskMsg.callback = SerialManager_Task;\r
 477             handle->commontaskMsg.callbackParam = handle;\r
 478             COMMON_TASK_post_message(&handle->commontaskMsg);\r
 479 #else\r
 480             (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_SENT);\r
 481 #endif\r
 482 \r
 483 #else\r
 484             SerialManager_Task(handle);\r
 485 #endif\r
 486         }\r
 487         else\r
 488         {\r
 489             writeHandle->transfer.buffer = NULL;\r
 490         }\r
 491     }\r
 492 }\r
 493 \r
 494 static void SerialManager_RxCallback(void *callbackParam,\r
 495                                      serial_manager_callback_message_t *message,\r
 496                                      serial_manager_status_t status)\r
 497 {\r
 498     serial_manager_handle_t *handle;\r
 499     uint32_t ringBufferLength;\r
 500 \r
 501     assert(callbackParam);\r
 502     assert(message);\r
 503 \r
 504     handle = (serial_manager_handle_t *)callbackParam;\r
 505 \r
 506     status = kStatus_SerialManager_Notify;\r
 507 \r
 508     for (int i = 0; i < message->length; i++)\r
 509     {\r
 510         handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];\r
 511         if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)\r
 512         {\r
 513             handle->ringBuffer.ringHead = 0U;\r
 514         }\r
 515         if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)\r
 516         {\r
 517             status = kStatus_SerialManager_RingBufferOverflow;\r
 518             handle->ringBuffer.ringTail++;\r
 519             if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 520             {\r
 521                 handle->ringBuffer.ringTail = 0U;\r
 522             }\r
 523         }\r
 524     }\r
 525 \r
 526     ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 527     ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;\r
 528 \r
 529     if ((handle->openedReadHandleHead) && (handle->openedReadHandleHead->transfer.buffer))\r
 530     {\r
 531         if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
 532         {\r
 533             int remainLength =\r
 534                 handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;\r
 535             for (int i = 0; i < MIN(ringBufferLength, remainLength); i++)\r
 536             {\r
 537                 handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =\r
 538                     handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
 539                 handle->ringBuffer.ringTail++;\r
 540                 handle->openedReadHandleHead->transfer.soFar++;\r
 541                 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 542                 {\r
 543                     handle->ringBuffer.ringTail = 0U;\r
 544                 }\r
 545             }\r
 546             ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);\r
 547         }\r
 548 \r
 549         if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
 550         {\r
 551         }\r
 552         else\r
 553         {\r
 554             if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)\r
 555             {\r
 556                 handle->openedReadHandleHead->transfer.buffer = NULL;\r
 557             }\r
 558             else\r
 559             {\r
 560                 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;\r
 561 \r
 562 #if defined(OSA_USED)\r
 563 \r
 564 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 565                 handle->commontaskMsg.callback = SerialManager_Task;\r
 566                 handle->commontaskMsg.callbackParam = handle;\r
 567                 COMMON_TASK_post_message(&handle->commontaskMsg);\r
 568 #else\r
 569                 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_RECEIVED);\r
 570 #endif\r
 571 \r
 572 #else\r
 573                 SerialManager_Task(handle);\r
 574 #endif\r
 575             }\r
 576         }\r
 577     }\r
 578 \r
 579     if (ringBufferLength)\r
 580     {\r
 581         message->buffer = NULL;\r
 582         message->length = ringBufferLength;\r
 583         if ((NULL != handle->openedReadHandleHead->callback))\r
 584         {\r
 585             handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);\r
 586         }\r
 587     }\r
 588 }\r
 589 \r
 590 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,\r
 591                                                    uint8_t *buffer,\r
 592                                                    uint32_t length,\r
 593                                                    serial_manager_transmission_mode_t mode)\r
 594 {\r
 595     serial_manager_write_handle_t *serialWriteHandle;\r
 596     serial_manager_handle_t *handle;\r
 597     serial_manager_status_t status = kStatus_SerialManager_Success;\r
 598     uint32_t primask;\r
 599     uint8_t isEmpty = 0U;\r
 600 \r
 601     assert(writeHandle);\r
 602     assert(buffer);\r
 603     assert(length);\r
 604 \r
 605     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 606     handle = serialWriteHandle->serialManagerHandle;\r
 607 \r
 608     assert(handle);\r
 609     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
 610     assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));\r
 611 \r
 612     primask = DisableGlobalIRQ();\r
 613     if (serialWriteHandle->transfer.buffer)\r
 614     {\r
 615         EnableGlobalIRQ(primask);\r
 616         return kStatus_SerialManager_Busy;\r
 617     }\r
 618     serialWriteHandle->transfer.buffer = buffer;\r
 619     serialWriteHandle->transfer.length = length;\r
 620     serialWriteHandle->transfer.soFar = 0U;\r
 621     serialWriteHandle->transfer.mode = mode;\r
 622 \r
 623     if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))\r
 624     {\r
 625         isEmpty = 1U;\r
 626     }\r
 627     SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);\r
 628     EnableGlobalIRQ(primask);\r
 629 \r
 630     if (isEmpty)\r
 631     {\r
 632         status = SerialManager_StartWriting(handle);\r
 633         if (kStatus_SerialManager_Success != status)\r
 634         {\r
 635             return status;\r
 636         }\r
 637     }\r
 638 \r
 639     if (kSerialManager_TransmissionBlocking == mode)\r
 640     {\r
 641         while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)\r
 642         {\r
 643 #if defined(__GIC_PRIO_BITS)\r
 644             if ((__get_CPSR() & CPSR_M_Msk) == 0x13)\r
 645 #else\r
 646             if (__get_IPSR())\r
 647 #endif\r
 648             {\r
 649                 SerialManager_IsrFunction(handle);\r
 650             }\r
 651         }\r
 652     }\r
 653     return kStatus_SerialManager_Success;\r
 654 }\r
 655 \r
 656 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,\r
 657                                                   uint8_t *buffer,\r
 658                                                   uint32_t length,\r
 659                                                   serial_manager_transmission_mode_t mode,\r
 660                                                   uint32_t *receivedLength)\r
 661 {\r
 662     serial_manager_read_handle_t *serialReadHandle;\r
 663     serial_manager_handle_t *handle;\r
 664     uint32_t dataLength;\r
 665     uint32_t primask;\r
 666 \r
 667     assert(readHandle);\r
 668     assert(buffer);\r
 669     assert(length);\r
 670 \r
 671     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 672     handle = serialReadHandle->serialManagerHandle;\r
 673 \r
 674     assert(handle);\r
 675     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
 676     assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));\r
 677 \r
 678     primask = DisableGlobalIRQ();\r
 679     if (serialReadHandle->transfer.buffer)\r
 680     {\r
 681         EnableGlobalIRQ(primask);\r
 682         return kStatus_SerialManager_Busy;\r
 683     }\r
 684     serialReadHandle->transfer.buffer = buffer;\r
 685     serialReadHandle->transfer.length = length;\r
 686     serialReadHandle->transfer.soFar = 0U;\r
 687     serialReadHandle->transfer.mode = mode;\r
 688 \r
 689     dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 690     dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
 691 \r
 692     for (; serialReadHandle->transfer.soFar < MIN(dataLength, length); serialReadHandle->transfer.soFar++)\r
 693     {\r
 694         buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
 695         handle->ringBuffer.ringTail++;\r
 696         if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 697         {\r
 698             handle->ringBuffer.ringTail = 0U;\r
 699         }\r
 700     }\r
 701     EnableGlobalIRQ(primask);\r
 702 \r
 703     if (receivedLength)\r
 704     {\r
 705         *receivedLength = serialReadHandle->transfer.soFar;\r
 706         serialReadHandle->transfer.buffer = NULL;\r
 707     }\r
 708     else\r
 709     {\r
 710         if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
 711         {\r
 712             serialReadHandle->transfer.buffer = NULL;\r
 713             if (kSerialManager_TransmissionNonBlocking == mode)\r
 714             {\r
 715                 if (serialReadHandle->callback)\r
 716                 {\r
 717                     serial_manager_callback_message_t msg;\r
 718                     msg.buffer = buffer;\r
 719                     msg.length = serialReadHandle->transfer.soFar;\r
 720                     serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);\r
 721                 }\r
 722             }\r
 723         }\r
 724 \r
 725         if (kSerialManager_TransmissionBlocking == mode)\r
 726         {\r
 727             while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)\r
 728             {\r
 729             }\r
 730         }\r
 731     }\r
 732 \r
 733     return kStatus_SerialManager_Success;\r
 734 }\r
 735 \r
 736 #else\r
 737 \r
 738 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
 739 {\r
 740     serial_manager_write_handle_t *serialWriteHandle;\r
 741     serial_manager_handle_t *handle;\r
 742 \r
 743     assert(writeHandle);\r
 744     assert(buffer);\r
 745     assert(length);\r
 746 \r
 747     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 748     handle = serialWriteHandle->serialManagerHandle;\r
 749 \r
 750     assert(handle);\r
 751 \r
 752     return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);\r
 753 }\r
 754 \r
 755 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
 756 {\r
 757     serial_manager_read_handle_t *serialReadHandle;\r
 758     serial_manager_handle_t *handle;\r
 759 \r
 760     assert(readHandle);\r
 761     assert(buffer);\r
 762     assert(length);\r
 763 \r
 764     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 765     handle = serialReadHandle->serialManagerHandle;\r
 766 \r
 767     assert(handle);\r
 768 \r
 769     return SerialManager_StartReading(handle, serialReadHandle, buffer, length);\r
 770 }\r
 771 #endif\r
 772 \r
 773 serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config)\r
 774 {\r
 775     serial_manager_handle_t *handle;\r
 776     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 777 \r
 778     assert(config);\r
 779 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 780     assert(config->ringBuffer);\r
 781     assert(config->ringBufferSize);\r
 782 #endif\r
 783     assert(serialHandle);\r
 784     if (SERIAL_MANAGER_HANDLE_SIZE < sizeof(serial_manager_handle_t))\r
 785     {\r
 786         return kStatus_SerialManager_Error;\r
 787     }\r
 788 \r
 789     handle = (serial_manager_handle_t *)serialHandle;\r
 790 \r
 791     memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);\r
 792 \r
 793 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 794 \r
 795 #if defined(OSA_USED)\r
 796 \r
 797 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 798 \r
 799     COMMON_TASK_init();\r
 800 \r
 801 #else\r
 802     if (KOSA_StatusSuccess != OSA_EventCreate((osa_event_handle_t)handle->event, true))\r
 803     {\r
 804         return kStatus_SerialManager_Error;\r
 805     }\r
 806 \r
 807     if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))\r
 808     {\r
 809         return kStatus_SerialManager_Error;\r
 810     }\r
 811 #endif\r
 812 \r
 813 #endif\r
 814 \r
 815 #endif\r
 816 \r
 817     handle->type = config->type;\r
 818 \r
 819 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 820     handle->ringBuffer.ringBuffer = config->ringBuffer;\r
 821     handle->ringBuffer.ringBufferSize = config->ringBufferSize;\r
 822 #endif\r
 823 \r
 824     switch (config->type)\r
 825     {\r
 826 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 827         case kSerialPort_Uart:\r
 828             status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 829 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 830             if (kStatus_SerialManager_Success == status)\r
 831             {\r
 832                 status = Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 833                                                       SerialManager_TxCallback, handle);\r
 834                 if (kStatus_SerialManager_Success == status)\r
 835                 {\r
 836                     status = Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 837                                                           SerialManager_RxCallback, handle);\r
 838                 }\r
 839             }\r
 840 #endif\r
 841             break;\r
 842 #endif\r
 843 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 844         case kSerialPort_UsbCdc:\r
 845             status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 846 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 847             if (kStatus_SerialManager_Success == status)\r
 848             {\r
 849                 status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 850                                                         SerialManager_TxCallback, handle);\r
 851                 if (kStatus_SerialManager_Success == status)\r
 852                 {\r
 853                     status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 854                                                             SerialManager_RxCallback, handle);\r
 855                 }\r
 856             }\r
 857 #endif\r
 858             break;\r
 859 #endif\r
 860 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 861         case kSerialPort_Swo:\r
 862             status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 863 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 864             if (kStatus_SerialManager_Success == status)\r
 865             {\r
 866                 status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 867                                                      SerialManager_TxCallback, handle);\r
 868             }\r
 869 #endif\r
 870             break;\r
 871 #endif\r
 872         default:\r
 873             break;\r
 874     }\r
 875 \r
 876     return status;\r
 877 }\r
 878 \r
 879 serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)\r
 880 {\r
 881     serial_manager_handle_t *handle;\r
 882 \r
 883     assert(serialHandle);\r
 884 \r
 885     handle = (serial_manager_handle_t *)serialHandle;\r
 886 \r
 887     if ((handle->openedReadHandleHead) || (handle->openedWriteHandleCount))\r
 888     {\r
 889         return kStatus_SerialManager_Busy;\r
 890     }\r
 891 \r
 892     switch (handle->type)\r
 893     {\r
 894 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 895         case kSerialPort_Uart:\r
 896             Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 897             break;\r
 898 #endif\r
 899 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 900         case kSerialPort_UsbCdc:\r
 901             Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 902             break;\r
 903 #endif\r
 904 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 905         case kSerialPort_Swo:\r
 906             Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 907             break;\r
 908 #endif\r
 909         default:\r
 910             break;\r
 911     }\r
 912 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 913 \r
 914 #if defined(OSA_USED)\r
 915 \r
 916 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 917 #else\r
 918     OSA_EventDestroy((osa_event_handle_t)handle->event);\r
 919     OSA_TaskDestroy((osa_task_handle_t)handle->taskId);\r
 920 #endif\r
 921 \r
 922 #endif\r
 923 \r
 924 #endif\r
 925 \r
 926     return kStatus_SerialManager_Success;\r
 927 }\r
 928 \r
 929 serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)\r
 930 {\r
 931     serial_manager_handle_t *handle;\r
 932     serial_manager_write_handle_t *serialWriteHandle;\r
 933 \r
 934     assert(serialHandle);\r
 935     assert(writeHandle);\r
 936     if (SERIAL_MANAGER_WRITE_HANDLE_SIZE < sizeof(serial_manager_write_handle_t))\r
 937     {\r
 938         return kStatus_SerialManager_Error;\r
 939     }\r
 940     handle = (serial_manager_handle_t *)serialHandle;\r
 941     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 942 \r
 943     memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
 944 \r
 945     handle->openedWriteHandleCount++;\r
 946 \r
 947     serialWriteHandle->serialManagerHandle = handle;\r
 948 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 949     serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;\r
 950 #endif\r
 951 \r
 952     return kStatus_SerialManager_Success;\r
 953 }\r
 954 \r
 955 serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)\r
 956 {\r
 957     serial_manager_handle_t *handle;\r
 958     serial_manager_write_handle_t *serialWriteHandle;\r
 959 \r
 960     assert(writeHandle);\r
 961 \r
 962     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 963     handle = (serial_manager_handle_t *)serialWriteHandle->serialManagerHandle;\r
 964 \r
 965     assert(handle);\r
 966 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 967     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
 968 #endif\r
 969 \r
 970 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 971     SerialManager_CancelWriting(writeHandle);\r
 972 #endif\r
 973 \r
 974     handle->openedWriteHandleCount--;\r
 975     memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
 976 \r
 977     return kStatus_SerialManager_Success;\r
 978 }\r
 979 \r
 980 serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)\r
 981 {\r
 982     serial_manager_handle_t *handle;\r
 983     serial_manager_read_handle_t *serialReadHandle;\r
 984 \r
 985     assert(serialHandle);\r
 986     assert(readHandle);\r
 987     if (SERIAL_MANAGER_READ_HANDLE_SIZE < sizeof(serial_manager_read_handle_t))\r
 988     {\r
 989         return kStatus_SerialManager_Error;\r
 990     }\r
 991     handle = (serial_manager_handle_t *)serialHandle;\r
 992     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 993 \r
 994     if (handle->openedReadHandleHead)\r
 995     {\r
 996         return kStatus_SerialManager_Busy;\r
 997     }\r
 998     memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
 999 \r
1000     handle->openedReadHandleHead = serialReadHandle;\r
1001 \r
1002     serialReadHandle->serialManagerHandle = handle;\r
1003 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1004     serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;\r
1005 #endif\r
1006 \r
1007     return kStatus_SerialManager_Success;\r
1008 }\r
1009 \r
1010 serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)\r
1011 {\r
1012     serial_manager_handle_t *handle;\r
1013     serial_manager_read_handle_t *serialReadHandle;\r
1014 \r
1015     assert(readHandle);\r
1016 \r
1017     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1018     handle = (serial_manager_handle_t *)serialReadHandle->serialManagerHandle;\r
1019 \r
1020     assert(handle);\r
1021 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1022     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1023 #endif\r
1024 \r
1025 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1026     SerialManager_CancelReading(readHandle);\r
1027 #endif\r
1028 \r
1029     handle->openedReadHandleHead = NULL;\r
1030     memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
1031 \r
1032     return kStatus_SerialManager_Success;\r
1033 }\r
1034 \r
1035 serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
1036 {\r
1037 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1038     return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);\r
1039 #else\r
1040     return SerialManager_Write(writeHandle, buffer, length);\r
1041 #endif\r
1042 }\r
1043 \r
1044 serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
1045 {\r
1046 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1047     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);\r
1048 #else\r
1049     return SerialManager_Read(readHandle, buffer, length);\r
1050 #endif\r
1051 }\r
1052 \r
1053 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1054 serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,\r
1055                                                        uint8_t *buffer,\r
1056                                                        uint32_t length)\r
1057 {\r
1058     return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);\r
1059 }\r
1060 \r
1061 serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
1062 {\r
1063     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);\r
1064 }\r
1065 \r
1066 serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)\r
1067 {\r
1068     serial_manager_write_handle_t *serialWriteHandle;\r
1069     uint32_t primask;\r
1070     uint8_t isNotUsed = 0;\r
1071 \r
1072     assert(writeHandle);\r
1073 \r
1074     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1075 \r
1076     assert(serialWriteHandle->serialManagerHandle);\r
1077     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1078 \r
1079     if ((serialWriteHandle->transfer.buffer) &&\r
1080         (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))\r
1081     {\r
1082         return kStatus_SerialManager_Error;\r
1083     }\r
1084 \r
1085     primask = DisableGlobalIRQ();\r
1086     if (serialWriteHandle !=\r
1087         (serial_manager_write_handle_t *)LIST_GetHead(&serialWriteHandle->serialManagerHandle->runningWriteHandleHead))\r
1088     {\r
1089         LIST_RemoveElement(&serialWriteHandle->link);\r
1090         isNotUsed = 1;\r
1091     }\r
1092     EnableGlobalIRQ(primask);\r
1093 \r
1094     if (isNotUsed)\r
1095     {\r
1096         serialWriteHandle->transfer.soFar = 0;\r
1097         serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;\r
1098 \r
1099         SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);\r
1100 #if defined(OSA_USED)\r
1101 \r
1102 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
1103         serialWriteHandle->serialManagerHandle->commontaskMsg.callback = SerialManager_Task;\r
1104         serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;\r
1105         COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);\r
1106 #else\r
1107         (void)OSA_EventSet((osa_event_handle_t)serialWriteHandle->serialManagerHandle->event, SERIAL_EVENT_DATA_SENT);\r
1108 #endif\r
1109 \r
1110 #else\r
1111         SerialManager_Task(serialWriteHandle->serialManagerHandle);\r
1112 #endif\r
1113     }\r
1114     else\r
1115     {\r
1116         switch (serialWriteHandle->serialManagerHandle->type)\r
1117         {\r
1118 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
1119             case kSerialPort_Uart:\r
1120                 Serial_UartCancelWrite(\r
1121                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1122                 break;\r
1123 #endif\r
1124 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
1125             case kSerialPort_UsbCdc:\r
1126                 Serial_UsbCdcCancelWrite(\r
1127                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1128                 break;\r
1129 #endif\r
1130 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
1131             case kSerialPort_Swo:\r
1132                 Serial_SwoCancelWrite(\r
1133                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1134                 break;\r
1135 #endif\r
1136             default:\r
1137                 break;\r
1138         }\r
1139     }\r
1140 \r
1141     SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);\r
1142 \r
1143     return kStatus_SerialManager_Success;\r
1144 }\r
1145 \r
1146 serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)\r
1147 {\r
1148     serial_manager_read_handle_t *serialReadHandle;\r
1149     serial_manager_callback_message_t msg;\r
1150     uint8_t *buffer;\r
1151     uint32_t primask;\r
1152 \r
1153     assert(readHandle);\r
1154 \r
1155     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1156 \r
1157     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1158 \r
1159     if ((serialReadHandle->transfer.buffer) && (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))\r
1160     {\r
1161         return kStatus_SerialManager_Error;\r
1162     }\r
1163 \r
1164     primask = DisableGlobalIRQ();\r
1165     buffer = serialReadHandle->transfer.buffer;\r
1166     serialReadHandle->transfer.buffer = NULL;\r
1167     serialReadHandle->transfer.length = 0;\r
1168     msg.buffer = buffer;\r
1169     msg.length = serialReadHandle->transfer.soFar;\r
1170     EnableGlobalIRQ(primask);\r
1171 \r
1172     if (buffer)\r
1173     {\r
1174         if (serialReadHandle->callback)\r
1175         {\r
1176             serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);\r
1177         }\r
1178     }\r
1179     return kStatus_SerialManager_Success;\r
1180 }\r
1181 \r
1182 serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,\r
1183                                               uint8_t *buffer,\r
1184                                               uint32_t length,\r
1185                                               uint32_t *receivedLength)\r
1186 {\r
1187     assert(receivedLength);\r
1188 \r
1189     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);\r
1190 }\r
1191 \r
1192 serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,\r
1193                                                         serial_manager_callback_t callback,\r
1194                                                         void *callbackParam)\r
1195 {\r
1196     serial_manager_write_handle_t *serialWriteHandle;\r
1197 \r
1198     assert(writeHandle);\r
1199 \r
1200     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1201 \r
1202     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1203 \r
1204     serialWriteHandle->callbackParam = callbackParam;\r
1205     serialWriteHandle->callback = callback;\r
1206 \r
1207     return kStatus_SerialManager_Success;\r
1208 }\r
1209 \r
1210 serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,\r
1211                                                         serial_manager_callback_t callback,\r
1212                                                         void *callbackParam)\r
1213 {\r
1214     serial_manager_read_handle_t *serialReadHandle;\r
1215 \r
1216     assert(readHandle);\r
1217 \r
1218     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1219 \r
1220     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1221 \r
1222     serialReadHandle->callbackParam = callbackParam;\r
1223     serialReadHandle->callback = callback;\r
1224 \r
1225     return kStatus_SerialManager_Success;\r
1226 }\r
1227 #endif\r
1228 \r
1229 serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)\r
1230 {\r
1231     assert(serialHandle);\r
1232 \r
1233     return kStatus_SerialManager_Success;\r
1234 }\r
1235 \r
1236 serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)\r
1237 {\r
1238     assert(serialHandle);\r
1239 \r
1240     return kStatus_SerialManager_Success;\r
1241 }\r