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

   1 /*\r
   2  * Copyright 2018-2019 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 #include "serial_port_internal.h"\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_label_t runningWriteHandleHead;   /*!< The queue of running write handle */\r
 109     list_label_t completedWriteHandleHead; /*!< The queue of completed write handle */\r
 110 #endif\r
 111     serial_manager_read_handle_t *volatile openedReadHandleHead;\r
 112     volatile 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 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 126         uint8_t usbcdcVirtualHandleBuffer[SERIAL_PORT_USB_VIRTUAL_HANDLE_SIZE];\r
 127 #endif\r
 128     };\r
 129 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 130     serial_manager_read_ring_buffer_t ringBuffer;\r
 131 #endif\r
 132 \r
 133 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 134 \r
 135 #if defined(OSA_USED)\r
 136 \r
 137 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 138     common_task_message_t commontaskMsg;\r
 139 #else\r
 140     uint8_t event[OSA_EVENT_HANDLE_SIZE]; /*!< Event instance */\r
 141     uint8_t taskId[OSA_TASK_HANDLE_SIZE]; /*!< Task handle */\r
 142 #endif\r
 143 \r
 144 #endif\r
 145 \r
 146 #endif\r
 147 \r
 148     serial_port_type_t type;\r
 149 } serial_manager_handle_t;\r
 150 \r
 151 /*******************************************************************************\r
 152  * Prototypes\r
 153  ******************************************************************************/\r
 154 \r
 155 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 156 static void SerialManager_Task(void *param);\r
 157 #endif\r
 158 \r
 159 /*******************************************************************************\r
 160  * Variables\r
 161  ******************************************************************************/\r
 162 \r
 163 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 164 \r
 165 #if defined(OSA_USED)\r
 166 \r
 167 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 168 \r
 169 #else\r
 170                                           /*\r
 171                                            * \brief Defines the serial manager task's stack\r
 172                                            */\r
 173 OSA_TASK_DEFINE(SerialManager_Task, SERIAL_MANAGER_TASK_PRIORITY, 1, SERIAL_MANAGER_TASK_STACK_SIZE, false);\r
 174 #endif\r
 175 \r
 176 #endif\r
 177 \r
 178 #endif\r
 179 \r
 180 /*******************************************************************************\r
 181  * Code\r
 182  ******************************************************************************/\r
 183 \r
 184 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 185 static void SerialManager_AddTail(list_label_t *queue, serial_manager_write_handle_t *node)\r
 186 {\r
 187     (void)LIST_AddTail(queue, &node->link);\r
 188 }\r
 189 \r
 190 static void SerialManager_RemoveHead(list_label_t *queue)\r
 191 {\r
 192     (void)LIST_RemoveHead(queue);\r
 193 }\r
 194 #endif\r
 195 \r
 196 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 197 \r
 198 static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle)\r
 199 {\r
 200     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 201     serial_manager_write_handle_t *writeHandle =\r
 202         (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
 203 \r
 204     if (writeHandle != NULL)\r
 205     {\r
 206         switch (handle->type)\r
 207         {\r
 208 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 209             case kSerialPort_Uart:\r
 210                 status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 211                                           writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 212                 break;\r
 213 #endif\r
 214 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 215             case kSerialPort_UsbCdc:\r
 216                 status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 217                                             writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 218                 break;\r
 219 #endif\r
 220 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 221             case kSerialPort_Swo:\r
 222                 status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 223                                          writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 224                 break;\r
 225 #endif\r
 226 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 227             case kSerialPort_UsbCdcVirtual:\r
 228                 status = Serial_UsbCdcVirtualWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 229                                                    writeHandle->transfer.buffer, writeHandle->transfer.length);\r
 230                 break;\r
 231 #endif\r
 232             default:\r
 233                 status = kStatus_SerialManager_Error;\r
 234                 break;\r
 235         }\r
 236     }\r
 237     return status;\r
 238 }\r
 239 \r
 240 static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,\r
 241                                                           serial_manager_read_handle_t *readHandle,\r
 242                                                           uint8_t *buffer,\r
 243                                                           uint32_t length)\r
 244 {\r
 245     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 246 \r
 247     if (NULL != readHandle)\r
 248     {\r
 249 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 250         if (handle->type == kSerialPort_UsbCdc)\r
 251         {\r
 252             status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 253         }\r
 254 #endif\r
 255 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 256         if (handle->type == kSerialPort_UsbCdcVirtual)\r
 257         {\r
 258             status = Serial_UsbCdcVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 259         }\r
 260 #endif\r
 261     }\r
 262     return status;\r
 263 }\r
 264 \r
 265 #else\r
 266 \r
 267 static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle,\r
 268                                                           serial_manager_write_handle_t *writeHandle,\r
 269                                                           uint8_t *buffer,\r
 270                                                           uint32_t length)\r
 271 {\r
 272     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 273 \r
 274     if (NULL != writeHandle)\r
 275     {\r
 276         switch (handle->type)\r
 277         {\r
 278 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 279             case kSerialPort_Uart:\r
 280                 status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 281                 break;\r
 282 #endif\r
 283 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 284             case kSerialPort_UsbCdc:\r
 285                 status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 286                 break;\r
 287 #endif\r
 288 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 289             case kSerialPort_Swo:\r
 290                 status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 291                 break;\r
 292 #endif\r
 293 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 294             case kSerialPort_UsbCdcVirtual:\r
 295                 status = Serial_UsbCdcVirtualWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 296                 break;\r
 297 #endif\r
 298             default:\r
 299                 status = kStatus_SerialManager_Error;\r
 300                 break;\r
 301         }\r
 302     }\r
 303     return status;\r
 304 }\r
 305 \r
 306 static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,\r
 307                                                           serial_manager_read_handle_t *readHandle,\r
 308                                                           uint8_t *buffer,\r
 309                                                           uint32_t length)\r
 310 {\r
 311     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 312 \r
 313     if (NULL != readHandle)\r
 314     {\r
 315         switch (handle->type)\r
 316         {\r
 317 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 318             case kSerialPort_Uart:\r
 319                 status = Serial_UartRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 320                 break;\r
 321 #endif\r
 322 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 323             case kSerialPort_UsbCdc:\r
 324                 status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 325                 break;\r
 326 #endif\r
 327 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 328             case kSerialPort_Swo:\r
 329                 status = Serial_SwoRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 330                 break;\r
 331 #endif\r
 332 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 333             case kSerialPort_UsbCdcVirtual:\r
 334                 status = Serial_UsbCdcVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
 335                 break;\r
 336 #endif\r
 337             default:\r
 338                 status = kStatus_SerialManager_Error;\r
 339                 break;\r
 340         }\r
 341     }\r
 342     return status;\r
 343 }\r
 344 #endif\r
 345 \r
 346 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 347 static void SerialManager_IsrFunction(serial_manager_handle_t *handle)\r
 348 {\r
 349     uint32_t regPrimask = DisableGlobalIRQ();\r
 350     switch (handle->type)\r
 351     {\r
 352 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 353         case kSerialPort_Uart:\r
 354             Serial_UartIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 355             break;\r
 356 #endif\r
 357 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 358         case kSerialPort_UsbCdc:\r
 359             Serial_UsbCdcIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 360             break;\r
 361 #endif\r
 362 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 363         case kSerialPort_Swo:\r
 364             Serial_SwoIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 365             break;\r
 366 #endif\r
 367 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 368         case kSerialPort_UsbCdcVirtual:\r
 369             Serial_UsbCdcVirtualIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 370             break;\r
 371 #endif\r
 372         default:\r
 373             /*MISRA rule 16.4*/\r
 374             break;\r
 375     }\r
 376     EnableGlobalIRQ(regPrimask);\r
 377 }\r
 378 \r
 379 static void SerialManager_Task(void *param)\r
 380 {\r
 381     serial_manager_handle_t *handle = (serial_manager_handle_t *)param;\r
 382     serial_manager_write_handle_t *serialWriteHandle;\r
 383     serial_manager_read_handle_t *serialReadHandle;\r
 384     uint32_t primask;\r
 385     serial_manager_callback_message_t msg;\r
 386 \r
 387     if (NULL != handle)\r
 388     {\r
 389 #if defined(OSA_USED)\r
 390 \r
 391 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 392 #else\r
 393         osa_event_flags_t ev = 0;\r
 394 \r
 395         do\r
 396         {\r
 397             if (KOSA_StatusSuccess ==\r
 398                 OSA_EventWait((osa_event_handle_t)handle->event, osaEventFlagsAll_c, false, osaWaitForever_c, &ev))\r
 399             {\r
 400                 if (ev & SERIAL_EVENT_DATA_SENT)\r
 401 #endif\r
 402 \r
 403 #endif\r
 404         {\r
 405             serialWriteHandle =\r
 406                 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
 407             while (NULL != serialWriteHandle)\r
 408             {\r
 409                 SerialManager_RemoveHead(&handle->completedWriteHandleHead);\r
 410                 msg.buffer                         = serialWriteHandle->transfer.buffer;\r
 411                 msg.length                         = serialWriteHandle->transfer.soFar;\r
 412                 serialWriteHandle->transfer.buffer = NULL;\r
 413                 if (NULL != serialWriteHandle->callback)\r
 414                 {\r
 415                     serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,\r
 416                                                 serialWriteHandle->transfer.status);\r
 417                 }\r
 418                 serialWriteHandle =\r
 419                     (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
 420             }\r
 421         }\r
 422 #if defined(OSA_USED)\r
 423 \r
 424 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 425 #else\r
 426                 if (ev & SERIAL_EVENT_DATA_RECEIVED)\r
 427 #endif\r
 428 \r
 429 #endif\r
 430         {\r
 431             primask          = DisableGlobalIRQ();\r
 432             serialReadHandle = handle->openedReadHandleHead;\r
 433             EnableGlobalIRQ(primask);\r
 434 \r
 435             if (NULL != serialReadHandle)\r
 436             {\r
 437                 if (NULL != serialReadHandle->transfer.buffer)\r
 438                 {\r
 439                     if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
 440                     {\r
 441                         msg.buffer                        = serialReadHandle->transfer.buffer;\r
 442                         msg.length                        = serialReadHandle->transfer.soFar;\r
 443                         serialReadHandle->transfer.buffer = NULL;\r
 444                         if (NULL != serialReadHandle->callback)\r
 445                         {\r
 446                             serialReadHandle->callback(serialReadHandle->callbackParam, &msg,\r
 447                                                        serialReadHandle->transfer.status);\r
 448                         }\r
 449                     }\r
 450                 }\r
 451             }\r
 452         }\r
 453 #if defined(OSA_USED)\r
 454 \r
 455 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 456 #else\r
 457             }\r
 458         } while (gUseRtos_c);\r
 459 #endif\r
 460 \r
 461 #endif\r
 462     }\r
 463 }\r
 464 #endif\r
 465 \r
 466 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 467 static void SerialManager_TxCallback(void *callbackParam,\r
 468                                      serial_manager_callback_message_t *message,\r
 469                                      serial_manager_status_t status)\r
 470 {\r
 471     serial_manager_handle_t *handle;\r
 472     serial_manager_write_handle_t *writeHandle;\r
 473 \r
 474     assert(callbackParam);\r
 475     assert(message);\r
 476 \r
 477     handle = (serial_manager_handle_t *)callbackParam;\r
 478 \r
 479     writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
 480 \r
 481     if (NULL != writeHandle)\r
 482     {\r
 483         SerialManager_RemoveHead(&handle->runningWriteHandleHead);\r
 484         (void)SerialManager_StartWriting(handle);\r
 485         writeHandle->transfer.soFar  = message->length;\r
 486         writeHandle->transfer.status = status;\r
 487         if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)\r
 488         {\r
 489             SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);\r
 490 #if defined(OSA_USED)\r
 491 \r
 492 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 493             handle->commontaskMsg.callback      = SerialManager_Task;\r
 494             handle->commontaskMsg.callbackParam = handle;\r
 495             COMMON_TASK_post_message(&handle->commontaskMsg);\r
 496 #else\r
 497             (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_SENT);\r
 498 #endif\r
 499 \r
 500 #else\r
 501             SerialManager_Task(handle);\r
 502 #endif\r
 503         }\r
 504         else\r
 505         {\r
 506             writeHandle->transfer.buffer = NULL;\r
 507         }\r
 508     }\r
 509 }\r
 510 \r
 511 static void SerialManager_RxCallback(void *callbackParam,\r
 512                                      serial_manager_callback_message_t *message,\r
 513                                      serial_manager_status_t status)\r
 514 {\r
 515     serial_manager_handle_t *handle;\r
 516     uint32_t ringBufferLength;\r
 517     uint32_t primask;\r
 518 \r
 519     assert(callbackParam);\r
 520     assert(message);\r
 521 \r
 522     handle = (serial_manager_handle_t *)callbackParam;\r
 523 \r
 524     status = kStatus_SerialManager_Notify;\r
 525 \r
 526     for (uint32_t i = 0; i < message->length; i++)\r
 527     {\r
 528         handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];\r
 529         if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)\r
 530         {\r
 531             handle->ringBuffer.ringHead = 0U;\r
 532         }\r
 533         if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)\r
 534         {\r
 535             status = kStatus_SerialManager_RingBufferOverflow;\r
 536             handle->ringBuffer.ringTail++;\r
 537             if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 538             {\r
 539                 handle->ringBuffer.ringTail = 0U;\r
 540             }\r
 541         }\r
 542     }\r
 543 \r
 544     ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 545     ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;\r
 546 \r
 547     primask = DisableGlobalIRQ();\r
 548     if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->transfer.buffer))\r
 549     {\r
 550         if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
 551         {\r
 552             uint32_t remainLength =\r
 553                 handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;\r
 554             for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)\r
 555             {\r
 556                 handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =\r
 557                     handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
 558                 handle->ringBuffer.ringTail++;\r
 559                 handle->openedReadHandleHead->transfer.soFar++;\r
 560                 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 561                 {\r
 562                     handle->ringBuffer.ringTail = 0U;\r
 563                 }\r
 564             }\r
 565             ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);\r
 566         }\r
 567 \r
 568         if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
 569         {\r
 570         }\r
 571         else\r
 572         {\r
 573             if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)\r
 574             {\r
 575                 handle->openedReadHandleHead->transfer.buffer = NULL;\r
 576             }\r
 577             else\r
 578             {\r
 579                 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;\r
 580 \r
 581 #if defined(OSA_USED)\r
 582 \r
 583 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 584                 handle->commontaskMsg.callback      = SerialManager_Task;\r
 585                 handle->commontaskMsg.callbackParam = handle;\r
 586                 COMMON_TASK_post_message(&handle->commontaskMsg);\r
 587 #else\r
 588                 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_RECEIVED);\r
 589 #endif\r
 590 \r
 591 #else\r
 592                 SerialManager_Task(handle);\r
 593 #endif\r
 594             }\r
 595         }\r
 596     }\r
 597 \r
 598     if (0U != ringBufferLength)\r
 599     {\r
 600         message->buffer = NULL;\r
 601         message->length = ringBufferLength;\r
 602         if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))\r
 603         {\r
 604             handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);\r
 605         }\r
 606     }\r
 607 \r
 608     ringBufferLength = handle->ringBuffer.ringBufferSize - 1U - ringBufferLength;\r
 609 \r
 610     if (NULL != handle->openedReadHandleHead)\r
 611     {\r
 612         (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);\r
 613     }\r
 614     EnableGlobalIRQ(primask);\r
 615 }\r
 616 \r
 617 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,\r
 618                                                    uint8_t *buffer,\r
 619                                                    uint32_t length,\r
 620                                                    serial_manager_transmission_mode_t mode)\r
 621 {\r
 622     serial_manager_write_handle_t *serialWriteHandle;\r
 623     serial_manager_handle_t *handle;\r
 624     serial_manager_status_t status = kStatus_SerialManager_Success;\r
 625     uint32_t primask;\r
 626     uint8_t isEmpty = 0U;\r
 627 \r
 628     assert(writeHandle);\r
 629     assert(buffer);\r
 630     assert(length);\r
 631 \r
 632     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 633     handle            = serialWriteHandle->serialManagerHandle;\r
 634 \r
 635     assert(handle);\r
 636     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
 637     assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));\r
 638 \r
 639     primask = DisableGlobalIRQ();\r
 640     if (NULL != serialWriteHandle->transfer.buffer)\r
 641     {\r
 642         EnableGlobalIRQ(primask);\r
 643         return kStatus_SerialManager_Busy;\r
 644     }\r
 645     serialWriteHandle->transfer.buffer = buffer;\r
 646     serialWriteHandle->transfer.length = length;\r
 647     serialWriteHandle->transfer.soFar  = 0U;\r
 648     serialWriteHandle->transfer.mode   = mode;\r
 649 \r
 650     if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))\r
 651     {\r
 652         isEmpty = 1U;\r
 653     }\r
 654     SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);\r
 655     EnableGlobalIRQ(primask);\r
 656 \r
 657     if (0U != isEmpty)\r
 658     {\r
 659         status = SerialManager_StartWriting(handle);\r
 660         if ((serial_manager_status_t)kStatus_SerialManager_Success != status)\r
 661         {\r
 662             return status;\r
 663         }\r
 664     }\r
 665 \r
 666     if (kSerialManager_TransmissionBlocking == mode)\r
 667     {\r
 668         while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)\r
 669         {\r
 670 #if defined(__GIC_PRIO_BITS)\r
 671             if (0x13 == (__get_CPSR() & CPSR_M_Msk))\r
 672 #else\r
 673             if (0U != __get_IPSR())\r
 674 #endif\r
 675             {\r
 676                 SerialManager_IsrFunction(handle);\r
 677             }\r
 678         }\r
 679     }\r
 680     return kStatus_SerialManager_Success;\r
 681 }\r
 682 \r
 683 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,\r
 684                                                   uint8_t *buffer,\r
 685                                                   uint32_t length,\r
 686                                                   serial_manager_transmission_mode_t mode,\r
 687                                                   uint32_t *receivedLength)\r
 688 {\r
 689     serial_manager_read_handle_t *serialReadHandle;\r
 690     serial_manager_handle_t *handle;\r
 691     uint32_t dataLength;\r
 692     uint32_t primask;\r
 693 \r
 694     assert(readHandle);\r
 695     assert(buffer);\r
 696     assert(length);\r
 697 \r
 698     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 699     handle           = serialReadHandle->serialManagerHandle;\r
 700 \r
 701     assert(handle);\r
 702     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
 703     assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));\r
 704 \r
 705     primask = DisableGlobalIRQ();\r
 706     if (NULL != serialReadHandle->transfer.buffer)\r
 707     {\r
 708         EnableGlobalIRQ(primask);\r
 709         return kStatus_SerialManager_Busy;\r
 710     }\r
 711     serialReadHandle->transfer.buffer = buffer;\r
 712     serialReadHandle->transfer.length = length;\r
 713     serialReadHandle->transfer.soFar  = 0U;\r
 714     serialReadHandle->transfer.mode   = mode;\r
 715 \r
 716     dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 717     dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
 718 \r
 719     for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);\r
 720          serialReadHandle->transfer.soFar++)\r
 721     {\r
 722         buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
 723         handle->ringBuffer.ringTail++;\r
 724         if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 725         {\r
 726             handle->ringBuffer.ringTail = 0U;\r
 727         }\r
 728     }\r
 729 \r
 730     dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 731     dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
 732     dataLength = handle->ringBuffer.ringBufferSize - 1U - dataLength;\r
 733 \r
 734     (void)SerialManager_StartReading(handle, readHandle, NULL, dataLength);\r
 735 \r
 736     if (NULL != receivedLength)\r
 737     {\r
 738         *receivedLength                   = serialReadHandle->transfer.soFar;\r
 739         serialReadHandle->transfer.buffer = NULL;\r
 740         EnableGlobalIRQ(primask);\r
 741     }\r
 742     else\r
 743     {\r
 744         if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
 745         {\r
 746             serialReadHandle->transfer.buffer = NULL;\r
 747             EnableGlobalIRQ(primask);\r
 748             if (kSerialManager_TransmissionNonBlocking == mode)\r
 749             {\r
 750                 if (NULL != serialReadHandle->callback)\r
 751                 {\r
 752                     serial_manager_callback_message_t msg;\r
 753                     msg.buffer = buffer;\r
 754                     msg.length = serialReadHandle->transfer.soFar;\r
 755                     serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);\r
 756                 }\r
 757             }\r
 758         }\r
 759         else\r
 760         {\r
 761             EnableGlobalIRQ(primask);\r
 762         }\r
 763 \r
 764         if (kSerialManager_TransmissionBlocking == mode)\r
 765         {\r
 766             while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)\r
 767             {\r
 768             }\r
 769         }\r
 770     }\r
 771 \r
 772     return kStatus_SerialManager_Success;\r
 773 }\r
 774 \r
 775 #else\r
 776 \r
 777 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
 778 {\r
 779     serial_manager_write_handle_t *serialWriteHandle;\r
 780     serial_manager_handle_t *handle;\r
 781 \r
 782     assert(writeHandle);\r
 783     assert(buffer);\r
 784     assert(length);\r
 785 \r
 786     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 787     handle            = serialWriteHandle->serialManagerHandle;\r
 788 \r
 789     assert(handle);\r
 790 \r
 791     return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);\r
 792 }\r
 793 \r
 794 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
 795 {\r
 796     serial_manager_read_handle_t *serialReadHandle;\r
 797     serial_manager_handle_t *handle;\r
 798 \r
 799     assert(readHandle);\r
 800     assert(buffer);\r
 801     assert(length);\r
 802 \r
 803     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 804     handle           = serialReadHandle->serialManagerHandle;\r
 805 \r
 806     assert(handle);\r
 807 \r
 808     return SerialManager_StartReading(handle, serialReadHandle, buffer, length);\r
 809 }\r
 810 #endif\r
 811 \r
 812 serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config)\r
 813 {\r
 814     serial_manager_handle_t *handle;\r
 815     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 816 \r
 817     assert(config);\r
 818 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 819     assert(config->ringBuffer);\r
 820     assert(config->ringBufferSize);\r
 821 #endif\r
 822     assert(serialHandle);\r
 823     assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));\r
 824 \r
 825     handle = (serial_manager_handle_t *)serialHandle;\r
 826 \r
 827     (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);\r
 828 \r
 829 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 830 \r
 831 #if defined(OSA_USED)\r
 832 \r
 833 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 834 \r
 835     COMMON_TASK_init();\r
 836 \r
 837 #else\r
 838     if (KOSA_StatusSuccess != OSA_EventCreate((osa_event_handle_t)handle->event, true))\r
 839     {\r
 840         return kStatus_SerialManager_Error;\r
 841     }\r
 842 \r
 843     if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))\r
 844     {\r
 845         return kStatus_SerialManager_Error;\r
 846     }\r
 847 #endif\r
 848 \r
 849 #endif\r
 850 \r
 851 #endif\r
 852 \r
 853     handle->type = config->type;\r
 854 \r
 855 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 856     handle->ringBuffer.ringBuffer     = config->ringBuffer;\r
 857     handle->ringBuffer.ringBufferSize = config->ringBufferSize;\r
 858 #endif\r
 859 \r
 860     switch (config->type)\r
 861     {\r
 862 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 863         case kSerialPort_Uart:\r
 864             status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 865 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 866             if ((serial_manager_status_t)kStatus_SerialManager_Success == status)\r
 867             {\r
 868                 status = Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 869                                                       SerialManager_TxCallback, handle);\r
 870                 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)\r
 871                 {\r
 872                     status = Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 873                                                           SerialManager_RxCallback, handle);\r
 874                 }\r
 875             }\r
 876 #endif\r
 877             break;\r
 878 #endif\r
 879 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 880         case kSerialPort_UsbCdc:\r
 881             status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 882 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 883             if (kStatus_SerialManager_Success == status)\r
 884             {\r
 885                 status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 886                                                         SerialManager_TxCallback, handle);\r
 887                 if (kStatus_SerialManager_Success == status)\r
 888                 {\r
 889                     status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 890                                                             SerialManager_RxCallback, handle);\r
 891                 }\r
 892             }\r
 893 #endif\r
 894             break;\r
 895 #endif\r
 896 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 897         case kSerialPort_Swo:\r
 898             status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 899 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 900             if (kStatus_SerialManager_Success == status)\r
 901             {\r
 902                 status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 903                                                      SerialManager_TxCallback, handle);\r
 904             }\r
 905 #endif\r
 906             break;\r
 907 #endif\r
 908 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 909         case kSerialPort_UsbCdcVirtual:\r
 910             status = Serial_UsbCdcVirtualInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 911 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 912             if (kStatus_SerialManager_Success == status)\r
 913             {\r
 914                 status = Serial_UsbCdcVirtualInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 915                                                                SerialManager_TxCallback, handle);\r
 916                 if (kStatus_SerialManager_Success == status)\r
 917                 {\r
 918                     status = Serial_UsbCdcVirtualInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 919                                                                    SerialManager_RxCallback, handle);\r
 920                 }\r
 921             }\r
 922 #endif\r
 923             break;\r
 924 #endif\r
 925         default:\r
 926             /*MISRA rule 16.4*/\r
 927             break;\r
 928     }\r
 929 \r
 930     return status;\r
 931 }\r
 932 \r
 933 serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)\r
 934 {\r
 935     serial_manager_handle_t *handle;\r
 936     uint32_t primask;\r
 937 \r
 938     assert(serialHandle);\r
 939 \r
 940     handle = (serial_manager_handle_t *)serialHandle;\r
 941 \r
 942     primask = DisableGlobalIRQ();\r
 943     if ((NULL != handle->openedReadHandleHead) || (0U != handle->openedWriteHandleCount))\r
 944     {\r
 945         EnableGlobalIRQ(primask);\r
 946         return kStatus_SerialManager_Busy;\r
 947     }\r
 948     EnableGlobalIRQ(primask);\r
 949 \r
 950     switch (handle->type)\r
 951     {\r
 952 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 953         case kSerialPort_Uart:\r
 954             (void)Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 955             break;\r
 956 #endif\r
 957 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 958         case kSerialPort_UsbCdc:\r
 959             (void)Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 960             break;\r
 961 #endif\r
 962 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 963         case kSerialPort_Swo:\r
 964             (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 965             break;\r
 966 #endif\r
 967 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 968         case kSerialPort_UsbCdcVirtual:\r
 969             (void)Serial_UsbCdcVirtualDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 970             break;\r
 971 #endif\r
 972         default:\r
 973             /*MISRA rule 16.4*/\r
 974             break;\r
 975     }\r
 976 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 977 \r
 978 #if defined(OSA_USED)\r
 979 \r
 980 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 981 #else\r
 982     OSA_EventDestroy((osa_event_handle_t)handle->event);\r
 983     OSA_TaskDestroy((osa_task_handle_t)handle->taskId);\r
 984 #endif\r
 985 \r
 986 #endif\r
 987 \r
 988 #endif\r
 989 \r
 990     return kStatus_SerialManager_Success;\r
 991 }\r
 992 \r
 993 serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)\r
 994 {\r
 995     serial_manager_handle_t *handle;\r
 996     serial_manager_write_handle_t *serialWriteHandle;\r
 997     uint32_t primask;\r
 998 \r
 999     assert(serialHandle);\r
1000     assert(writeHandle);\r
1001     assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));\r
1002 \r
1003     handle            = (serial_manager_handle_t *)serialHandle;\r
1004     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1005 \r
1006     (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
1007 \r
1008     primask = DisableGlobalIRQ();\r
1009     handle->openedWriteHandleCount++;\r
1010     EnableGlobalIRQ(primask);\r
1011 \r
1012     serialWriteHandle->serialManagerHandle = handle;\r
1013 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1014     serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;\r
1015 #endif\r
1016 \r
1017     return kStatus_SerialManager_Success;\r
1018 }\r
1019 \r
1020 serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)\r
1021 {\r
1022     serial_manager_handle_t *handle;\r
1023     serial_manager_write_handle_t *serialWriteHandle;\r
1024     uint32_t primask;\r
1025 \r
1026     assert(writeHandle);\r
1027 \r
1028     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1029     handle            = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;\r
1030 \r
1031     assert(handle);\r
1032 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1033     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1034 #endif\r
1035 \r
1036 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1037     (void)SerialManager_CancelWriting(writeHandle);\r
1038 #endif\r
1039     primask = DisableGlobalIRQ();\r
1040     if (handle->openedWriteHandleCount > 0U)\r
1041     {\r
1042         handle->openedWriteHandleCount--;\r
1043     }\r
1044     EnableGlobalIRQ(primask);\r
1045 \r
1046     (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
1047 \r
1048     return kStatus_SerialManager_Success;\r
1049 }\r
1050 \r
1051 serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)\r
1052 {\r
1053     serial_manager_handle_t *handle;\r
1054     serial_manager_read_handle_t *serialReadHandle;\r
1055     uint32_t primask;\r
1056 \r
1057     assert(serialHandle);\r
1058     assert(readHandle);\r
1059     assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));\r
1060 \r
1061     handle           = (serial_manager_handle_t *)serialHandle;\r
1062     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1063 \r
1064     primask = DisableGlobalIRQ();\r
1065     if (handle->openedReadHandleHead != NULL)\r
1066     {\r
1067         EnableGlobalIRQ(primask);\r
1068         return kStatus_SerialManager_Busy;\r
1069     }\r
1070     handle->openedReadHandleHead = serialReadHandle;\r
1071     EnableGlobalIRQ(primask);\r
1072 \r
1073     (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
1074 \r
1075     serialReadHandle->serialManagerHandle = handle;\r
1076 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1077     serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;\r
1078 #endif\r
1079 \r
1080     return kStatus_SerialManager_Success;\r
1081 }\r
1082 \r
1083 serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)\r
1084 {\r
1085     serial_manager_handle_t *handle;\r
1086     serial_manager_read_handle_t *serialReadHandle;\r
1087     uint32_t primask;\r
1088 \r
1089     assert(readHandle);\r
1090 \r
1091     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1092     handle           = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;\r
1093 \r
1094     assert(handle && (handle->openedReadHandleHead == serialReadHandle));\r
1095 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1096     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1097 #endif\r
1098 \r
1099 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1100     (void)SerialManager_CancelReading(readHandle);\r
1101 #endif\r
1102 \r
1103     primask                      = DisableGlobalIRQ();\r
1104     handle->openedReadHandleHead = NULL;\r
1105     EnableGlobalIRQ(primask);\r
1106 \r
1107     (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
1108 \r
1109     return kStatus_SerialManager_Success;\r
1110 }\r
1111 \r
1112 serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
1113 {\r
1114 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1115     return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);\r
1116 #else\r
1117     return SerialManager_Write(writeHandle, buffer, length);\r
1118 #endif\r
1119 }\r
1120 \r
1121 serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
1122 {\r
1123 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1124     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);\r
1125 #else\r
1126     return SerialManager_Read(readHandle, buffer, length);\r
1127 #endif\r
1128 }\r
1129 \r
1130 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1131 serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,\r
1132                                                        uint8_t *buffer,\r
1133                                                        uint32_t length)\r
1134 {\r
1135     return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);\r
1136 }\r
1137 \r
1138 serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
1139 {\r
1140     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);\r
1141 }\r
1142 \r
1143 serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)\r
1144 {\r
1145     serial_manager_write_handle_t *serialWriteHandle;\r
1146     uint32_t primask;\r
1147     uint8_t isNotUsed = 0;\r
1148 \r
1149     assert(writeHandle);\r
1150 \r
1151     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1152 \r
1153     assert(serialWriteHandle->serialManagerHandle);\r
1154     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1155 \r
1156     if ((NULL != serialWriteHandle->transfer.buffer) &&\r
1157         (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))\r
1158     {\r
1159         return kStatus_SerialManager_Error;\r
1160     }\r
1161 \r
1162     primask = DisableGlobalIRQ();\r
1163     if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(\r
1164                                  &serialWriteHandle->serialManagerHandle->runningWriteHandleHead))\r
1165     {\r
1166         (void)LIST_RemoveElement(&serialWriteHandle->link);\r
1167         isNotUsed = 1;\r
1168     }\r
1169     EnableGlobalIRQ(primask);\r
1170 \r
1171     if (0U != isNotUsed)\r
1172     {\r
1173         serialWriteHandle->transfer.soFar  = 0;\r
1174         serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;\r
1175 \r
1176         SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);\r
1177 #if defined(OSA_USED)\r
1178 \r
1179 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
1180         serialWriteHandle->serialManagerHandle->commontaskMsg.callback      = SerialManager_Task;\r
1181         serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;\r
1182         COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);\r
1183 #else\r
1184         (void)OSA_EventSet((osa_event_handle_t)serialWriteHandle->serialManagerHandle->event, SERIAL_EVENT_DATA_SENT);\r
1185 #endif\r
1186 \r
1187 #else\r
1188         SerialManager_Task(serialWriteHandle->serialManagerHandle);\r
1189 #endif\r
1190     }\r
1191     else\r
1192     {\r
1193         switch (serialWriteHandle->serialManagerHandle->type)\r
1194         {\r
1195 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
1196             case kSerialPort_Uart:\r
1197                 (void)Serial_UartCancelWrite(\r
1198                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1199                 break;\r
1200 #endif\r
1201 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
1202             case kSerialPort_UsbCdc:\r
1203                 (void)Serial_UsbCdcCancelWrite(\r
1204                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1205                 break;\r
1206 #endif\r
1207 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
1208             case kSerialPort_Swo:\r
1209                 (void)Serial_SwoCancelWrite(\r
1210                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1211                 break;\r
1212 #endif\r
1213 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
1214             case kSerialPort_UsbCdcVirtual:\r
1215                 (void)Serial_UsbCdcVirtualCancelWrite(\r
1216                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1217                 break;\r
1218 #endif\r
1219             default:\r
1220                 /*MISRA rule 16.4*/\r
1221                 break;\r
1222         }\r
1223     }\r
1224 \r
1225     (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);\r
1226 \r
1227     return kStatus_SerialManager_Success;\r
1228 }\r
1229 \r
1230 serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)\r
1231 {\r
1232     serial_manager_read_handle_t *serialReadHandle;\r
1233     serial_manager_callback_message_t msg;\r
1234     uint8_t *buffer;\r
1235     uint32_t primask;\r
1236 \r
1237     assert(readHandle);\r
1238 \r
1239     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1240 \r
1241     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1242 \r
1243     if ((NULL != serialReadHandle->transfer.buffer) &&\r
1244         (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))\r
1245     {\r
1246         return kStatus_SerialManager_Error;\r
1247     }\r
1248 \r
1249     primask                           = DisableGlobalIRQ();\r
1250     buffer                            = serialReadHandle->transfer.buffer;\r
1251     serialReadHandle->transfer.buffer = NULL;\r
1252     serialReadHandle->transfer.length = 0;\r
1253     msg.buffer                        = buffer;\r
1254     msg.length                        = serialReadHandle->transfer.soFar;\r
1255     EnableGlobalIRQ(primask);\r
1256 \r
1257     if (NULL != buffer)\r
1258     {\r
1259         if (NULL != serialReadHandle->callback)\r
1260         {\r
1261             serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);\r
1262         }\r
1263     }\r
1264     return kStatus_SerialManager_Success;\r
1265 }\r
1266 \r
1267 serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,\r
1268                                               uint8_t *buffer,\r
1269                                               uint32_t length,\r
1270                                               uint32_t *receivedLength)\r
1271 {\r
1272     assert(receivedLength);\r
1273 \r
1274     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);\r
1275 }\r
1276 \r
1277 serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,\r
1278                                                         serial_manager_callback_t callback,\r
1279                                                         void *callbackParam)\r
1280 {\r
1281     serial_manager_write_handle_t *serialWriteHandle;\r
1282 \r
1283     assert(writeHandle);\r
1284 \r
1285     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1286 \r
1287     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1288 \r
1289     serialWriteHandle->callbackParam = callbackParam;\r
1290     serialWriteHandle->callback      = callback;\r
1291 \r
1292     return kStatus_SerialManager_Success;\r
1293 }\r
1294 \r
1295 serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,\r
1296                                                         serial_manager_callback_t callback,\r
1297                                                         void *callbackParam)\r
1298 {\r
1299     serial_manager_read_handle_t *serialReadHandle;\r
1300 \r
1301     assert(readHandle);\r
1302 \r
1303     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1304 \r
1305     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1306 \r
1307     serialReadHandle->callbackParam = callbackParam;\r
1308     serialReadHandle->callback      = callback;\r
1309 \r
1310     return kStatus_SerialManager_Success;\r
1311 }\r
1312 #endif\r
1313 \r
1314 serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)\r
1315 {\r
1316     serial_manager_handle_t *handle;\r
1317     serial_manager_status_t status = kStatus_SerialManager_Error;\r
1318 \r
1319     assert(serialHandle);\r
1320 \r
1321     handle = (serial_manager_handle_t *)serialHandle;\r
1322 \r
1323     switch (handle->type)\r
1324     {\r
1325 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
1326         case kSerialPort_Uart:\r
1327             status = Serial_UartEnterLowpower(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
1328             break;\r
1329 #endif\r
1330 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
1331         case kSerialPort_UsbCdc:\r
1332             break;\r
1333 #endif\r
1334 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
1335         case kSerialPort_Swo:\r
1336             break;\r
1337 #endif\r
1338 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
1339         case kSerialPort_UsbCdcVirtual:\r
1340             break;\r
1341 #endif\r
1342         default:\r
1343             /*MISRA rule 16.4*/\r
1344             break;\r
1345     }\r
1346     return status;\r
1347 }\r
1348 \r
1349 serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)\r
1350 {\r
1351     serial_manager_handle_t *handle;\r
1352     serial_manager_status_t status = kStatus_SerialManager_Error;\r
1353 \r
1354     assert(serialHandle);\r
1355 \r
1356     handle = (serial_manager_handle_t *)serialHandle;\r
1357 \r
1358     switch (handle->type)\r
1359     {\r
1360 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
1361         case kSerialPort_Uart:\r
1362             status = Serial_UartExitLowpower(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
1363             break;\r
1364 #endif\r
1365 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
1366         case kSerialPort_UsbCdc:\r
1367             break;\r
1368 #endif\r
1369 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
1370         case kSerialPort_Swo:\r
1371             break;\r
1372 #endif\r
1373 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
1374         case kSerialPort_UsbCdcVirtual:\r
1375             break;\r
1376 #endif\r
1377         default:\r
1378             /*MISRA rule 16.4*/\r
1379             break;\r
1380     }\r
1381     return status;\r
1382 }\r