git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M0+_LPC51U68_LPCXpresso/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_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 #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_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_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 (readHandle != NULL)\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 (writeHandle != NULL)\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 (readHandle != NULL)\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     serial_manager_callback_message_t msg;\r
 385     if (NULL != handle)\r
 386     {\r
 387 #if defined(OSA_USED)\r
 388 \r
 389 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 390 #else\r
 391         osa_event_flags_t ev = 0;\r
 392 \r
 393         do\r
 394         {\r
 395             if (KOSA_StatusSuccess ==\r
 396                 OSA_EventWait((osa_event_handle_t)handle->event, osaEventFlagsAll_c, false, osaWaitForever_c, &ev))\r
 397             {\r
 398                 if (ev & SERIAL_EVENT_DATA_SENT)\r
 399 #endif\r
 400 \r
 401 #endif\r
 402         {\r
 403             serialWriteHandle =\r
 404                 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
 405             while (NULL != serialWriteHandle)\r
 406             {\r
 407                 SerialManager_RemoveHead(&handle->completedWriteHandleHead);\r
 408                 msg.buffer                         = serialWriteHandle->transfer.buffer;\r
 409                 msg.length                         = serialWriteHandle->transfer.soFar;\r
 410                 serialWriteHandle->transfer.buffer = NULL;\r
 411                 if (serialWriteHandle->callback != NULL)\r
 412                 {\r
 413                     serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,\r
 414                                                 serialWriteHandle->transfer.status);\r
 415                 }\r
 416                 serialWriteHandle =\r
 417                     (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
 418             }\r
 419         }\r
 420 #if defined(OSA_USED)\r
 421 \r
 422 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 423 #else\r
 424                 if (ev & SERIAL_EVENT_DATA_RECEIVED)\r
 425 #endif\r
 426 \r
 427 #endif\r
 428         {\r
 429             serialReadHandle = handle->openedReadHandleHead;\r
 430             if (serialReadHandle != NULL)\r
 431             {\r
 432                 if (serialReadHandle->transfer.buffer != NULL)\r
 433                 {\r
 434                     if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
 435                     {\r
 436                         msg.buffer                        = serialReadHandle->transfer.buffer;\r
 437                         msg.length                        = serialReadHandle->transfer.soFar;\r
 438                         serialReadHandle->transfer.buffer = NULL;\r
 439                         if (serialReadHandle->callback != NULL)\r
 440                         {\r
 441                             serialReadHandle->callback(serialReadHandle->callbackParam, &msg,\r
 442                                                        serialReadHandle->transfer.status);\r
 443                         }\r
 444                     }\r
 445                 }\r
 446             }\r
 447         }\r
 448 #if defined(OSA_USED)\r
 449 \r
 450 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 451 #else\r
 452             }\r
 453         } while (gUseRtos_c);\r
 454 #endif\r
 455 \r
 456 #endif\r
 457     }\r
 458 }\r
 459 #endif\r
 460 \r
 461 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 462 static void SerialManager_TxCallback(void *callbackParam,\r
 463                                      serial_manager_callback_message_t *message,\r
 464                                      serial_manager_status_t status)\r
 465 {\r
 466     serial_manager_handle_t *handle;\r
 467     serial_manager_write_handle_t *writeHandle;\r
 468 \r
 469     assert(callbackParam);\r
 470     assert(message);\r
 471 \r
 472     handle = (serial_manager_handle_t *)callbackParam;\r
 473 \r
 474     writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
 475 \r
 476     if (NULL != writeHandle)\r
 477     {\r
 478         SerialManager_RemoveHead(&handle->runningWriteHandleHead);\r
 479         (void)SerialManager_StartWriting(handle);\r
 480         writeHandle->transfer.soFar  = message->length;\r
 481         writeHandle->transfer.status = status;\r
 482         if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)\r
 483         {\r
 484             SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);\r
 485 #if defined(OSA_USED)\r
 486 \r
 487 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 488             handle->commontaskMsg.callback      = SerialManager_Task;\r
 489             handle->commontaskMsg.callbackParam = handle;\r
 490             COMMON_TASK_post_message(&handle->commontaskMsg);\r
 491 #else\r
 492             (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_SENT);\r
 493 #endif\r
 494 \r
 495 #else\r
 496             SerialManager_Task(handle);\r
 497 #endif\r
 498         }\r
 499         else\r
 500         {\r
 501             writeHandle->transfer.buffer = NULL;\r
 502         }\r
 503     }\r
 504 }\r
 505 \r
 506 static void SerialManager_RxCallback(void *callbackParam,\r
 507                                      serial_manager_callback_message_t *message,\r
 508                                      serial_manager_status_t status)\r
 509 {\r
 510     serial_manager_handle_t *handle;\r
 511     uint32_t ringBufferLength;\r
 512 \r
 513     assert(callbackParam);\r
 514     assert(message);\r
 515 \r
 516     handle = (serial_manager_handle_t *)callbackParam;\r
 517 \r
 518     status = kStatus_SerialManager_Notify;\r
 519 \r
 520     for (uint32_t i = 0; i < message->length; i++)\r
 521     {\r
 522         handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];\r
 523         if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)\r
 524         {\r
 525             handle->ringBuffer.ringHead = 0U;\r
 526         }\r
 527         if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)\r
 528         {\r
 529             status = kStatus_SerialManager_RingBufferOverflow;\r
 530             handle->ringBuffer.ringTail++;\r
 531             if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 532             {\r
 533                 handle->ringBuffer.ringTail = 0U;\r
 534             }\r
 535         }\r
 536     }\r
 537 \r
 538     ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 539     ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;\r
 540 \r
 541     if ((handle->openedReadHandleHead != NULL) && (handle->openedReadHandleHead->transfer.buffer != NULL))\r
 542     {\r
 543         if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
 544         {\r
 545             uint32_t remainLength =\r
 546                 handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;\r
 547             for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)\r
 548             {\r
 549                 handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =\r
 550                     handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
 551                 handle->ringBuffer.ringTail++;\r
 552                 handle->openedReadHandleHead->transfer.soFar++;\r
 553                 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 554                 {\r
 555                     handle->ringBuffer.ringTail = 0U;\r
 556                 }\r
 557             }\r
 558             ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);\r
 559         }\r
 560 \r
 561         if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
 562         {\r
 563         }\r
 564         else\r
 565         {\r
 566             if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)\r
 567             {\r
 568                 handle->openedReadHandleHead->transfer.buffer = NULL;\r
 569             }\r
 570             else\r
 571             {\r
 572                 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;\r
 573 \r
 574 #if defined(OSA_USED)\r
 575 \r
 576 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 577                 handle->commontaskMsg.callback      = SerialManager_Task;\r
 578                 handle->commontaskMsg.callbackParam = handle;\r
 579                 COMMON_TASK_post_message(&handle->commontaskMsg);\r
 580 #else\r
 581                 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_RECEIVED);\r
 582 #endif\r
 583 \r
 584 #else\r
 585                 SerialManager_Task(handle);\r
 586 #endif\r
 587             }\r
 588         }\r
 589     }\r
 590 \r
 591     if (ringBufferLength != 0U)\r
 592     {\r
 593         message->buffer = NULL;\r
 594         message->length = ringBufferLength;\r
 595         if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))\r
 596         {\r
 597             handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);\r
 598         }\r
 599     }\r
 600 \r
 601     ringBufferLength = handle->ringBuffer.ringBufferSize - 1U - ringBufferLength;\r
 602 \r
 603     if (NULL != handle->openedReadHandleHead)\r
 604     {\r
 605         (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);\r
 606     }\r
 607 }\r
 608 \r
 609 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,\r
 610                                                    uint8_t *buffer,\r
 611                                                    uint32_t length,\r
 612                                                    serial_manager_transmission_mode_t mode)\r
 613 {\r
 614     serial_manager_write_handle_t *serialWriteHandle;\r
 615     serial_manager_handle_t *handle;\r
 616     serial_manager_status_t status = kStatus_SerialManager_Success;\r
 617     uint32_t primask;\r
 618     uint8_t isEmpty = 0U;\r
 619 \r
 620     assert(writeHandle);\r
 621     assert(buffer);\r
 622     assert(length);\r
 623 \r
 624     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 625     handle            = serialWriteHandle->serialManagerHandle;\r
 626 \r
 627     assert(handle);\r
 628     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
 629     assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));\r
 630 \r
 631     primask = DisableGlobalIRQ();\r
 632     if (serialWriteHandle->transfer.buffer != NULL)\r
 633     {\r
 634         EnableGlobalIRQ(primask);\r
 635         return kStatus_SerialManager_Busy;\r
 636     }\r
 637     serialWriteHandle->transfer.buffer = buffer;\r
 638     serialWriteHandle->transfer.length = length;\r
 639     serialWriteHandle->transfer.soFar  = 0U;\r
 640     serialWriteHandle->transfer.mode   = mode;\r
 641 \r
 642     if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))\r
 643     {\r
 644         isEmpty = 1U;\r
 645     }\r
 646     SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);\r
 647     EnableGlobalIRQ(primask);\r
 648 \r
 649     if (isEmpty != 0U)\r
 650     {\r
 651         status = SerialManager_StartWriting(handle);\r
 652         if ((serial_manager_status_t)kStatus_SerialManager_Success != status)\r
 653         {\r
 654             return status;\r
 655         }\r
 656     }\r
 657 \r
 658     if (kSerialManager_TransmissionBlocking == mode)\r
 659     {\r
 660         while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)\r
 661         {\r
 662 #if defined(__GIC_PRIO_BITS)\r
 663             if ((__get_CPSR() & CPSR_M_Msk) == 0x13)\r
 664 #else\r
 665             if (__get_IPSR() != 0U)\r
 666 #endif\r
 667             {\r
 668                 SerialManager_IsrFunction(handle);\r
 669             }\r
 670         }\r
 671     }\r
 672     return kStatus_SerialManager_Success;\r
 673 }\r
 674 \r
 675 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,\r
 676                                                   uint8_t *buffer,\r
 677                                                   uint32_t length,\r
 678                                                   serial_manager_transmission_mode_t mode,\r
 679                                                   uint32_t *receivedLength)\r
 680 {\r
 681     serial_manager_read_handle_t *serialReadHandle;\r
 682     serial_manager_handle_t *handle;\r
 683     uint32_t dataLength;\r
 684     uint32_t primask;\r
 685 \r
 686     assert(readHandle);\r
 687     assert(buffer);\r
 688     assert(length);\r
 689 \r
 690     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 691     handle           = serialReadHandle->serialManagerHandle;\r
 692 \r
 693     assert(handle);\r
 694     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
 695     assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));\r
 696 \r
 697     primask = DisableGlobalIRQ();\r
 698     if (serialReadHandle->transfer.buffer != NULL)\r
 699     {\r
 700         EnableGlobalIRQ(primask);\r
 701         return kStatus_SerialManager_Busy;\r
 702     }\r
 703     serialReadHandle->transfer.buffer = buffer;\r
 704     serialReadHandle->transfer.length = length;\r
 705     serialReadHandle->transfer.soFar  = 0U;\r
 706     serialReadHandle->transfer.mode   = mode;\r
 707 \r
 708     dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 709     dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
 710 \r
 711     for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);\r
 712          serialReadHandle->transfer.soFar++)\r
 713     {\r
 714         buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
 715         handle->ringBuffer.ringTail++;\r
 716         if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
 717         {\r
 718             handle->ringBuffer.ringTail = 0U;\r
 719         }\r
 720     }\r
 721 \r
 722     dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
 723     dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
 724     dataLength = handle->ringBuffer.ringBufferSize - 1U - dataLength;\r
 725 \r
 726     (void)SerialManager_StartReading(handle, readHandle, NULL, dataLength);\r
 727 \r
 728     if (receivedLength != NULL)\r
 729     {\r
 730         *receivedLength                   = serialReadHandle->transfer.soFar;\r
 731         serialReadHandle->transfer.buffer = NULL;\r
 732         EnableGlobalIRQ(primask);\r
 733     }\r
 734     else\r
 735     {\r
 736         if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
 737         {\r
 738             serialReadHandle->transfer.buffer = NULL;\r
 739             EnableGlobalIRQ(primask);\r
 740             if (kSerialManager_TransmissionNonBlocking == mode)\r
 741             {\r
 742                 if (serialReadHandle->callback != NULL)\r
 743                 {\r
 744                     serial_manager_callback_message_t msg;\r
 745                     msg.buffer = buffer;\r
 746                     msg.length = serialReadHandle->transfer.soFar;\r
 747                     serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);\r
 748                 }\r
 749             }\r
 750         }\r
 751         else\r
 752         {\r
 753             EnableGlobalIRQ(primask);\r
 754         }\r
 755 \r
 756         if (kSerialManager_TransmissionBlocking == mode)\r
 757         {\r
 758             while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)\r
 759             {\r
 760             }\r
 761         }\r
 762     }\r
 763 \r
 764     return kStatus_SerialManager_Success;\r
 765 }\r
 766 \r
 767 #else\r
 768 \r
 769 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
 770 {\r
 771     serial_manager_write_handle_t *serialWriteHandle;\r
 772     serial_manager_handle_t *handle;\r
 773 \r
 774     assert(writeHandle);\r
 775     assert(buffer);\r
 776     assert(length);\r
 777 \r
 778     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 779     handle            = serialWriteHandle->serialManagerHandle;\r
 780 \r
 781     assert(handle);\r
 782 \r
 783     return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);\r
 784 }\r
 785 \r
 786 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
 787 {\r
 788     serial_manager_read_handle_t *serialReadHandle;\r
 789     serial_manager_handle_t *handle;\r
 790 \r
 791     assert(readHandle);\r
 792     assert(buffer);\r
 793     assert(length);\r
 794 \r
 795     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
 796     handle           = serialReadHandle->serialManagerHandle;\r
 797 \r
 798     assert(handle);\r
 799 \r
 800     return SerialManager_StartReading(handle, serialReadHandle, buffer, length);\r
 801 }\r
 802 #endif\r
 803 \r
 804 serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config)\r
 805 {\r
 806     serial_manager_handle_t *handle;\r
 807     serial_manager_status_t status = kStatus_SerialManager_Error;\r
 808 \r
 809     assert(config);\r
 810 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 811     assert(config->ringBuffer);\r
 812     assert(config->ringBufferSize);\r
 813 #endif\r
 814     assert(serialHandle);\r
 815     assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));\r
 816 \r
 817     handle = (serial_manager_handle_t *)serialHandle;\r
 818 \r
 819     (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);\r
 820 \r
 821 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 822 \r
 823 #if defined(OSA_USED)\r
 824 \r
 825 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 826 \r
 827     COMMON_TASK_init();\r
 828 \r
 829 #else\r
 830     if (KOSA_StatusSuccess != OSA_EventCreate((osa_event_handle_t)handle->event, true))\r
 831     {\r
 832         return kStatus_SerialManager_Error;\r
 833     }\r
 834 \r
 835     if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))\r
 836     {\r
 837         return kStatus_SerialManager_Error;\r
 838     }\r
 839 #endif\r
 840 \r
 841 #endif\r
 842 \r
 843 #endif\r
 844 \r
 845     handle->type = config->type;\r
 846 \r
 847 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 848     handle->ringBuffer.ringBuffer     = config->ringBuffer;\r
 849     handle->ringBuffer.ringBufferSize = config->ringBufferSize;\r
 850 #endif\r
 851 \r
 852     switch (config->type)\r
 853     {\r
 854 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 855         case kSerialPort_Uart:\r
 856             status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 857 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 858             if ((serial_manager_status_t)kStatus_SerialManager_Success == status)\r
 859             {\r
 860                 status = Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 861                                                       SerialManager_TxCallback, handle);\r
 862                 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)\r
 863                 {\r
 864                     status = Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 865                                                           SerialManager_RxCallback, handle);\r
 866                 }\r
 867             }\r
 868 #endif\r
 869             break;\r
 870 #endif\r
 871 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 872         case kSerialPort_UsbCdc:\r
 873             status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 874 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 875             if (kStatus_SerialManager_Success == status)\r
 876             {\r
 877                 status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 878                                                         SerialManager_TxCallback, handle);\r
 879                 if (kStatus_SerialManager_Success == status)\r
 880                 {\r
 881                     status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 882                                                             SerialManager_RxCallback, handle);\r
 883                 }\r
 884             }\r
 885 #endif\r
 886             break;\r
 887 #endif\r
 888 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 889         case kSerialPort_Swo:\r
 890             status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 891 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 892             if (kStatus_SerialManager_Success == status)\r
 893             {\r
 894                 status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 895                                                      SerialManager_TxCallback, handle);\r
 896             }\r
 897 #endif\r
 898             break;\r
 899 #endif\r
 900 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 901         case kSerialPort_UsbCdcVirtual:\r
 902             status = Serial_UsbCdcVirtualInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
 903 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 904             if (kStatus_SerialManager_Success == status)\r
 905             {\r
 906                 status = Serial_UsbCdcVirtualInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 907                                                                SerialManager_TxCallback, handle);\r
 908                 if (kStatus_SerialManager_Success == status)\r
 909                 {\r
 910                     status = Serial_UsbCdcVirtualInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
 911                                                                    SerialManager_RxCallback, handle);\r
 912                 }\r
 913             }\r
 914 #endif\r
 915             break;\r
 916 #endif\r
 917         default:\r
 918             /*MISRA rule 16.4*/\r
 919             break;\r
 920     }\r
 921 \r
 922     return status;\r
 923 }\r
 924 \r
 925 serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)\r
 926 {\r
 927     serial_manager_handle_t *handle;\r
 928 \r
 929     assert(serialHandle);\r
 930 \r
 931     handle = (serial_manager_handle_t *)serialHandle;\r
 932 \r
 933     if ((handle->openedReadHandleHead != NULL) || (handle->openedWriteHandleCount != 0U))\r
 934     {\r
 935         return kStatus_SerialManager_Busy;\r
 936     }\r
 937 \r
 938     switch (handle->type)\r
 939     {\r
 940 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 941         case kSerialPort_Uart:\r
 942             (void)Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 943             break;\r
 944 #endif\r
 945 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 946         case kSerialPort_UsbCdc:\r
 947             (void)Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 948             break;\r
 949 #endif\r
 950 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 951         case kSerialPort_Swo:\r
 952             (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 953             break;\r
 954 #endif\r
 955 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 956         case kSerialPort_UsbCdcVirtual:\r
 957             Serial_UsbCdcVirtualDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 958             (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
 959             break;\r
 960 #endif\r
 961         default:\r
 962             /*MISRA rule 16.4*/\r
 963             break;\r
 964     }\r
 965 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
 966 \r
 967 #if defined(OSA_USED)\r
 968 \r
 969 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
 970 #else\r
 971     OSA_EventDestroy((osa_event_handle_t)handle->event);\r
 972     OSA_TaskDestroy((osa_task_handle_t)handle->taskId);\r
 973 #endif\r
 974 \r
 975 #endif\r
 976 \r
 977 #endif\r
 978 \r
 979     return kStatus_SerialManager_Success;\r
 980 }\r
 981 \r
 982 serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)\r
 983 {\r
 984     serial_manager_handle_t *handle;\r
 985     serial_manager_write_handle_t *serialWriteHandle;\r
 986 \r
 987     assert(serialHandle);\r
 988     assert(writeHandle);\r
 989     assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));\r
 990 \r
 991     handle            = (serial_manager_handle_t *)serialHandle;\r
 992     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
 993 \r
 994     (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
 995 \r
 996     handle->openedWriteHandleCount++;\r
 997 \r
 998     serialWriteHandle->serialManagerHandle = handle;\r
 999 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1000     serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;\r
1001 #endif\r
1002 \r
1003     return kStatus_SerialManager_Success;\r
1004 }\r
1005 \r
1006 serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)\r
1007 {\r
1008     serial_manager_handle_t *handle;\r
1009     serial_manager_write_handle_t *serialWriteHandle;\r
1010 \r
1011     assert(writeHandle);\r
1012 \r
1013     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1014     handle            = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;\r
1015 \r
1016     assert(handle);\r
1017 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1018     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1019 #endif\r
1020 \r
1021 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1022     (void)SerialManager_CancelWriting(writeHandle);\r
1023 #endif\r
1024 \r
1025     handle->openedWriteHandleCount--;\r
1026     (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
1027 \r
1028     return kStatus_SerialManager_Success;\r
1029 }\r
1030 \r
1031 serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)\r
1032 {\r
1033     serial_manager_handle_t *handle;\r
1034     serial_manager_read_handle_t *serialReadHandle;\r
1035 \r
1036     assert(serialHandle);\r
1037     assert(readHandle);\r
1038     assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));\r
1039 \r
1040     handle           = (serial_manager_handle_t *)serialHandle;\r
1041     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1042 \r
1043     if (handle->openedReadHandleHead != NULL)\r
1044     {\r
1045         return kStatus_SerialManager_Busy;\r
1046     }\r
1047     (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
1048 \r
1049     handle->openedReadHandleHead = serialReadHandle;\r
1050 \r
1051     serialReadHandle->serialManagerHandle = handle;\r
1052 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1053     serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;\r
1054 #endif\r
1055 \r
1056     return kStatus_SerialManager_Success;\r
1057 }\r
1058 \r
1059 serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)\r
1060 {\r
1061     serial_manager_handle_t *handle;\r
1062     serial_manager_read_handle_t *serialReadHandle;\r
1063 \r
1064     assert(readHandle);\r
1065 \r
1066     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1067     handle           = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;\r
1068 \r
1069     assert(handle);\r
1070 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1071     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1072 #endif\r
1073 \r
1074 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1075     (void)SerialManager_CancelReading(readHandle);\r
1076 #endif\r
1077 \r
1078     handle->openedReadHandleHead = NULL;\r
1079     (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
1080 \r
1081     return kStatus_SerialManager_Success;\r
1082 }\r
1083 \r
1084 serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
1085 {\r
1086 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1087     return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);\r
1088 #else\r
1089     return SerialManager_Write(writeHandle, buffer, length);\r
1090 #endif\r
1091 }\r
1092 \r
1093 serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
1094 {\r
1095 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1096     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);\r
1097 #else\r
1098     return SerialManager_Read(readHandle, buffer, length);\r
1099 #endif\r
1100 }\r
1101 \r
1102 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
1103 serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,\r
1104                                                        uint8_t *buffer,\r
1105                                                        uint32_t length)\r
1106 {\r
1107     return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);\r
1108 }\r
1109 \r
1110 serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
1111 {\r
1112     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);\r
1113 }\r
1114 \r
1115 serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)\r
1116 {\r
1117     serial_manager_write_handle_t *serialWriteHandle;\r
1118     uint32_t primask;\r
1119     uint8_t isNotUsed = 0;\r
1120 \r
1121     assert(writeHandle);\r
1122 \r
1123     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1124 \r
1125     assert(serialWriteHandle->serialManagerHandle);\r
1126     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1127 \r
1128     if ((serialWriteHandle->transfer.buffer != NULL) &&\r
1129         (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))\r
1130     {\r
1131         return kStatus_SerialManager_Error;\r
1132     }\r
1133 \r
1134     primask = DisableGlobalIRQ();\r
1135     if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(\r
1136                                  &serialWriteHandle->serialManagerHandle->runningWriteHandleHead))\r
1137     {\r
1138         (void)LIST_RemoveElement(&serialWriteHandle->link);\r
1139         isNotUsed = 1;\r
1140     }\r
1141     EnableGlobalIRQ(primask);\r
1142 \r
1143     if (isNotUsed != 0U)\r
1144     {\r
1145         serialWriteHandle->transfer.soFar  = 0;\r
1146         serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;\r
1147 \r
1148         SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);\r
1149 #if defined(OSA_USED)\r
1150 \r
1151 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
1152         serialWriteHandle->serialManagerHandle->commontaskMsg.callback      = SerialManager_Task;\r
1153         serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;\r
1154         COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);\r
1155 #else\r
1156         (void)OSA_EventSet((osa_event_handle_t)serialWriteHandle->serialManagerHandle->event, SERIAL_EVENT_DATA_SENT);\r
1157 #endif\r
1158 \r
1159 #else\r
1160         SerialManager_Task(serialWriteHandle->serialManagerHandle);\r
1161 #endif\r
1162     }\r
1163     else\r
1164     {\r
1165         switch (serialWriteHandle->serialManagerHandle->type)\r
1166         {\r
1167 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
1168             case kSerialPort_Uart:\r
1169                 (void)Serial_UartCancelWrite(\r
1170                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1171                 break;\r
1172 #endif\r
1173 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
1174             case kSerialPort_UsbCdc:\r
1175                 (void)Serial_UsbCdcCancelWrite(\r
1176                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1177                 break;\r
1178 #endif\r
1179 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
1180             case kSerialPort_Swo:\r
1181                 (void)Serial_SwoCancelWrite(\r
1182                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1183                 break;\r
1184 #endif\r
1185 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
1186             case kSerialPort_UsbCdcVirtual:\r
1187                 Serial_UsbCdcVirtualCancelWrite(\r
1188                 (void)Serial_SwoCancelWrite(\r
1189                     ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
1190                 break;\r
1191 #endif\r
1192             default:\r
1193                 /*MISRA rule 16.4*/\r
1194                 break;\r
1195         }\r
1196     }\r
1197 \r
1198     (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);\r
1199 \r
1200     return kStatus_SerialManager_Success;\r
1201 }\r
1202 \r
1203 serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)\r
1204 {\r
1205     serial_manager_read_handle_t *serialReadHandle;\r
1206     serial_manager_callback_message_t msg;\r
1207     uint8_t *buffer;\r
1208     uint32_t primask;\r
1209 \r
1210     assert(readHandle);\r
1211 \r
1212     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1213 \r
1214     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1215 \r
1216     if ((serialReadHandle->transfer.buffer != NULL) &&\r
1217         (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))\r
1218     {\r
1219         return kStatus_SerialManager_Error;\r
1220     }\r
1221 \r
1222     primask                           = DisableGlobalIRQ();\r
1223     buffer                            = serialReadHandle->transfer.buffer;\r
1224     serialReadHandle->transfer.buffer = NULL;\r
1225     serialReadHandle->transfer.length = 0;\r
1226     msg.buffer                        = buffer;\r
1227     msg.length                        = serialReadHandle->transfer.soFar;\r
1228     EnableGlobalIRQ(primask);\r
1229 \r
1230     if (buffer != NULL)\r
1231     {\r
1232         if (serialReadHandle->callback != NULL)\r
1233         {\r
1234             serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);\r
1235         }\r
1236     }\r
1237     return kStatus_SerialManager_Success;\r
1238 }\r
1239 \r
1240 serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,\r
1241                                               uint8_t *buffer,\r
1242                                               uint32_t length,\r
1243                                               uint32_t *receivedLength)\r
1244 {\r
1245     assert(receivedLength);\r
1246 \r
1247     return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);\r
1248 }\r
1249 \r
1250 serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,\r
1251                                                         serial_manager_callback_t callback,\r
1252                                                         void *callbackParam)\r
1253 {\r
1254     serial_manager_write_handle_t *serialWriteHandle;\r
1255 \r
1256     assert(writeHandle);\r
1257 \r
1258     serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
1259 \r
1260     assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
1261 \r
1262     serialWriteHandle->callbackParam = callbackParam;\r
1263     serialWriteHandle->callback      = callback;\r
1264 \r
1265     return kStatus_SerialManager_Success;\r
1266 }\r
1267 \r
1268 serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,\r
1269                                                         serial_manager_callback_t callback,\r
1270                                                         void *callbackParam)\r
1271 {\r
1272     serial_manager_read_handle_t *serialReadHandle;\r
1273 \r
1274     assert(readHandle);\r
1275 \r
1276     serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
1277 \r
1278     assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
1279 \r
1280     serialReadHandle->callbackParam = callbackParam;\r
1281     serialReadHandle->callback      = callback;\r
1282 \r
1283     return kStatus_SerialManager_Success;\r
1284 }\r
1285 #endif\r
1286 \r
1287 serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)\r
1288 {\r
1289     assert(serialHandle);\r
1290 \r
1291     return kStatus_SerialManager_Success;\r
1292 }\r
1293 \r
1294 serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)\r
1295 {\r
1296     assert(serialHandle);\r
1297 \r
1298     return kStatus_SerialManager_Success;\r
1299 }\r