--- /dev/null
+/*\r
+ * Copyright 2018-2019 NXP\r
+ * All rights reserved.\r
+ *\r
+ *\r
+ * SPDX-License-Identifier: BSD-3-Clause\r
+ */\r
+\r
+#include "fsl_common.h"\r
+#include <string.h>\r
+\r
+#include "serial_manager.h"\r
+#include "serial_port_internal.h"\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+\r
+#include "generic_list.h"\r
+\r
+/*\r
+ * The OSA_USED macro can only be defined when the OSA component is used.\r
+ * If the source code of the OSA component does not exist, the OSA_USED cannot be defined.\r
+ * OR, If OSA component is not added into project event the OSA source code exists, the OSA_USED\r
+ * also cannot be defined.\r
+ * The source code path of the OSA component is <MCUXpresso_SDK>/components/osa.\r
+ *\r
+ */\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+#include "common_task.h"\r
+#else\r
+#include "fsl_os_abstraction.h"\r
+#endif\r
+\r
+#endif\r
+\r
+#endif\r
+\r
+/*******************************************************************************\r
+ * Definitions\r
+ ******************************************************************************/\r
+\r
+#ifndef NDEBUG\r
+#if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))\r
+#undef assert\r
+#define assert(n)\r
+#endif\r
+#endif\r
+\r
+#define SERIAL_EVENT_DATA_RECEIVED (1U << 0)\r
+#define SERIAL_EVENT_DATA_SENT (1U << 1)\r
+\r
+#define SERIAL_MANAGER_WRITE_TAG 0xAABB5754U\r
+#define SERIAL_MANAGER_READ_TAG 0xBBAA5244U\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+typedef enum _serial_manager_transmission_mode\r
+{\r
+ kSerialManager_TransmissionBlocking = 0x0U, /*!< Blocking transmission*/\r
+ kSerialManager_TransmissionNonBlocking = 0x1U, /*!< None blocking transmission*/\r
+} serial_manager_transmission_mode_t;\r
+\r
+/* TX transfer structure */\r
+typedef struct _serial_manager_transfer\r
+{\r
+ uint8_t *buffer;\r
+ volatile uint32_t length;\r
+ volatile uint32_t soFar;\r
+ serial_manager_transmission_mode_t mode;\r
+ serial_manager_status_t status;\r
+} serial_manager_transfer_t;\r
+#endif\r
+\r
+/* write handle structure */\r
+typedef struct _serial_manager_send_handle\r
+{\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ list_element_t link; /*!< list element of the link */\r
+ serial_manager_transfer_t transfer;\r
+#endif\r
+ struct _serial_manager_handle *serialManagerHandle;\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ serial_manager_callback_t callback;\r
+ void *callbackParam;\r
+ uint32_t tag;\r
+#endif\r
+} serial_manager_write_handle_t;\r
+\r
+typedef serial_manager_write_handle_t serial_manager_read_handle_t;\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+/* receive state structure */\r
+typedef struct _serial_manager_read_ring_buffer\r
+{\r
+ uint8_t *ringBuffer;\r
+ uint32_t ringBufferSize;\r
+ volatile uint32_t ringHead;\r
+ volatile uint32_t ringTail;\r
+} serial_manager_read_ring_buffer_t;\r
+#endif\r
+\r
+#if defined(__CC_ARM)\r
+#pragma anon_unions\r
+#endif\r
+/* The serial manager handle structure */\r
+typedef struct _serial_manager_handle\r
+{\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ list_t runningWriteHandleHead; /*!< The queue of running write handle */\r
+ list_t completedWriteHandleHead; /*!< The queue of completed write handle */\r
+#endif\r
+ serial_manager_read_handle_t *openedReadHandleHead;\r
+ uint32_t openedWriteHandleCount;\r
+ union\r
+ {\r
+ uint8_t lowLevelhandleBuffer[1];\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ uint8_t uartHandleBuffer[SERIAL_PORT_UART_HANDLE_SIZE];\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ uint8_t usbcdcHandleBuffer[SERIAL_PORT_USB_CDC_HANDLE_SIZE];\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ uint8_t swoHandleBuffer[SERIAL_PORT_SWO_HANDLE_SIZE];\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ uint8_t usbcdcVirtualHandleBuffer[SERIAL_PORT_USB_VIRTUAL_HANDLE_SIZE];\r
+#endif\r
+ };\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ serial_manager_read_ring_buffer_t ringBuffer;\r
+#endif\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+ common_task_message_t commontaskMsg;\r
+#else\r
+ uint8_t event[OSA_EVENT_HANDLE_SIZE]; /*!< Event instance */\r
+ uint8_t taskId[OSA_TASK_HANDLE_SIZE]; /*!< Task handle */\r
+#endif\r
+\r
+#endif\r
+\r
+#endif\r
+\r
+ serial_port_type_t type;\r
+} serial_manager_handle_t;\r
+\r
+/*******************************************************************************\r
+ * Prototypes\r
+ ******************************************************************************/\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+static void SerialManager_Task(void *param);\r
+#endif\r
+\r
+/*******************************************************************************\r
+ * Variables\r
+ ******************************************************************************/\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+\r
+#else\r
+ /*\r
+ * \brief Defines the serial manager task's stack\r
+ */\r
+OSA_TASK_DEFINE(SerialManager_Task, SERIAL_MANAGER_TASK_PRIORITY, 1, SERIAL_MANAGER_TASK_STACK_SIZE, false);\r
+#endif\r
+\r
+#endif\r
+\r
+#endif\r
+\r
+/*******************************************************************************\r
+ * Code\r
+ ******************************************************************************/\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+static void SerialManager_AddTail(list_t *queue, serial_manager_write_handle_t *node)\r
+{\r
+ (void)LIST_AddTail(queue, &node->link);\r
+}\r
+\r
+static void SerialManager_RemoveHead(list_t *queue)\r
+{\r
+ (void)LIST_RemoveHead(queue);\r
+}\r
+#endif\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+\r
+static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle)\r
+{\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+ serial_manager_write_handle_t *writeHandle =\r
+ (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
+\r
+ if (writeHandle != NULL)\r
+ {\r
+ switch (handle->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ writeHandle->transfer.buffer, writeHandle->transfer.length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ writeHandle->transfer.buffer, writeHandle->transfer.length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ writeHandle->transfer.buffer, writeHandle->transfer.length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ status = Serial_UsbCdcVirtualWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ writeHandle->transfer.buffer, writeHandle->transfer.length);\r
+ break;\r
+#endif\r
+ default:\r
+ status = kStatus_SerialManager_Error;\r
+ break;\r
+ }\r
+ }\r
+ return status;\r
+}\r
+\r
+static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,\r
+ serial_manager_read_handle_t *readHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length)\r
+{\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+\r
+ if (readHandle != NULL)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ if (handle->type == kSerialPort_UsbCdc)\r
+ {\r
+ status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ }\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ if (handle->type == kSerialPort_UsbCdcVirtual)\r
+ {\r
+ status = Serial_UsbCdcVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ }\r
+#endif\r
+ }\r
+ return status;\r
+}\r
+\r
+#else\r
+\r
+static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle,\r
+ serial_manager_write_handle_t *writeHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length)\r
+{\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+\r
+ if (writeHandle != NULL)\r
+ {\r
+ switch (handle->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ status = Serial_UsbCdcVirtualWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+ default:\r
+ status = kStatus_SerialManager_Error;\r
+ break;\r
+ }\r
+ }\r
+ return status;\r
+}\r
+\r
+static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,\r
+ serial_manager_read_handle_t *readHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length)\r
+{\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+\r
+ if (readHandle != NULL)\r
+ {\r
+ switch (handle->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ status = Serial_UartRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ status = Serial_SwoRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ status = Serial_UsbCdcVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);\r
+ break;\r
+#endif\r
+ default:\r
+ status = kStatus_SerialManager_Error;\r
+ break;\r
+ }\r
+ }\r
+ return status;\r
+}\r
+#endif\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+static void SerialManager_IsrFunction(serial_manager_handle_t *handle)\r
+{\r
+ uint32_t regPrimask = DisableGlobalIRQ();\r
+ switch (handle->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ Serial_UartIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ Serial_UsbCdcIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ Serial_SwoIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ Serial_UsbCdcVirtualIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+ default:\r
+ /*MISRA rule 16.4*/\r
+ break;\r
+ }\r
+ EnableGlobalIRQ(regPrimask);\r
+}\r
+\r
+static void SerialManager_Task(void *param)\r
+{\r
+ serial_manager_handle_t *handle = (serial_manager_handle_t *)param;\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+ serial_manager_callback_message_t msg;\r
+ if (NULL != handle)\r
+ {\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+#else\r
+ osa_event_flags_t ev = 0;\r
+\r
+ do\r
+ {\r
+ if (KOSA_StatusSuccess ==\r
+ OSA_EventWait((osa_event_handle_t)handle->event, osaEventFlagsAll_c, false, osaWaitForever_c, &ev))\r
+ {\r
+ if (ev & SERIAL_EVENT_DATA_SENT)\r
+#endif\r
+\r
+#endif\r
+ {\r
+ serialWriteHandle =\r
+ (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
+ while (NULL != serialWriteHandle)\r
+ {\r
+ SerialManager_RemoveHead(&handle->completedWriteHandleHead);\r
+ msg.buffer = serialWriteHandle->transfer.buffer;\r
+ msg.length = serialWriteHandle->transfer.soFar;\r
+ serialWriteHandle->transfer.buffer = NULL;\r
+ if (serialWriteHandle->callback != NULL)\r
+ {\r
+ serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,\r
+ serialWriteHandle->transfer.status);\r
+ }\r
+ serialWriteHandle =\r
+ (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
+ }\r
+ }\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+#else\r
+ if (ev & SERIAL_EVENT_DATA_RECEIVED)\r
+#endif\r
+\r
+#endif\r
+ {\r
+ serialReadHandle = handle->openedReadHandleHead;\r
+ if (serialReadHandle != NULL)\r
+ {\r
+ if (serialReadHandle->transfer.buffer != NULL)\r
+ {\r
+ if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
+ {\r
+ msg.buffer = serialReadHandle->transfer.buffer;\r
+ msg.length = serialReadHandle->transfer.soFar;\r
+ serialReadHandle->transfer.buffer = NULL;\r
+ if (serialReadHandle->callback != NULL)\r
+ {\r
+ serialReadHandle->callback(serialReadHandle->callbackParam, &msg,\r
+ serialReadHandle->transfer.status);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+#else\r
+ }\r
+ } while (gUseRtos_c);\r
+#endif\r
+\r
+#endif\r
+ }\r
+}\r
+#endif\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+static void SerialManager_TxCallback(void *callbackParam,\r
+ serial_manager_callback_message_t *message,\r
+ serial_manager_status_t status)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_write_handle_t *writeHandle;\r
+\r
+ assert(callbackParam);\r
+ assert(message);\r
+\r
+ handle = (serial_manager_handle_t *)callbackParam;\r
+\r
+ writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
+\r
+ if (NULL != writeHandle)\r
+ {\r
+ SerialManager_RemoveHead(&handle->runningWriteHandleHead);\r
+ (void)SerialManager_StartWriting(handle);\r
+ writeHandle->transfer.soFar = message->length;\r
+ writeHandle->transfer.status = status;\r
+ if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)\r
+ {\r
+ SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+ handle->commontaskMsg.callback = SerialManager_Task;\r
+ handle->commontaskMsg.callbackParam = handle;\r
+ COMMON_TASK_post_message(&handle->commontaskMsg);\r
+#else\r
+ (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_SENT);\r
+#endif\r
+\r
+#else\r
+ SerialManager_Task(handle);\r
+#endif\r
+ }\r
+ else\r
+ {\r
+ writeHandle->transfer.buffer = NULL;\r
+ }\r
+ }\r
+}\r
+\r
+static void SerialManager_RxCallback(void *callbackParam,\r
+ serial_manager_callback_message_t *message,\r
+ serial_manager_status_t status)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ uint32_t ringBufferLength;\r
+\r
+ assert(callbackParam);\r
+ assert(message);\r
+\r
+ handle = (serial_manager_handle_t *)callbackParam;\r
+\r
+ status = kStatus_SerialManager_Notify;\r
+\r
+ for (uint32_t i = 0; i < message->length; i++)\r
+ {\r
+ handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];\r
+ if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)\r
+ {\r
+ handle->ringBuffer.ringHead = 0U;\r
+ }\r
+ if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)\r
+ {\r
+ status = kStatus_SerialManager_RingBufferOverflow;\r
+ handle->ringBuffer.ringTail++;\r
+ if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
+ {\r
+ handle->ringBuffer.ringTail = 0U;\r
+ }\r
+ }\r
+ }\r
+\r
+ ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
+ ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;\r
+\r
+ if ((handle->openedReadHandleHead != NULL) && (handle->openedReadHandleHead->transfer.buffer != NULL))\r
+ {\r
+ if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
+ {\r
+ uint32_t remainLength =\r
+ handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;\r
+ for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)\r
+ {\r
+ handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =\r
+ handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
+ handle->ringBuffer.ringTail++;\r
+ handle->openedReadHandleHead->transfer.soFar++;\r
+ if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
+ {\r
+ handle->ringBuffer.ringTail = 0U;\r
+ }\r
+ }\r
+ ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);\r
+ }\r
+\r
+ if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
+ {\r
+ }\r
+ else\r
+ {\r
+ if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)\r
+ {\r
+ handle->openedReadHandleHead->transfer.buffer = NULL;\r
+ }\r
+ else\r
+ {\r
+ handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;\r
+\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+ handle->commontaskMsg.callback = SerialManager_Task;\r
+ handle->commontaskMsg.callbackParam = handle;\r
+ COMMON_TASK_post_message(&handle->commontaskMsg);\r
+#else\r
+ (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_RECEIVED);\r
+#endif\r
+\r
+#else\r
+ SerialManager_Task(handle);\r
+#endif\r
+ }\r
+ }\r
+ }\r
+\r
+ if (ringBufferLength != 0U)\r
+ {\r
+ message->buffer = NULL;\r
+ message->length = ringBufferLength;\r
+ if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))\r
+ {\r
+ handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);\r
+ }\r
+ }\r
+\r
+ ringBufferLength = handle->ringBuffer.ringBufferSize - 1U - ringBufferLength;\r
+\r
+ if (NULL != handle->openedReadHandleHead)\r
+ {\r
+ (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);\r
+ }\r
+}\r
+\r
+static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length,\r
+ serial_manager_transmission_mode_t mode)\r
+{\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_status_t status = kStatus_SerialManager_Success;\r
+ uint32_t primask;\r
+ uint8_t isEmpty = 0U;\r
+\r
+ assert(writeHandle);\r
+ assert(buffer);\r
+ assert(length);\r
+\r
+ serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
+ handle = serialWriteHandle->serialManagerHandle;\r
+\r
+ assert(handle);\r
+ assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
+ assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));\r
+\r
+ primask = DisableGlobalIRQ();\r
+ if (serialWriteHandle->transfer.buffer != NULL)\r
+ {\r
+ EnableGlobalIRQ(primask);\r
+ return kStatus_SerialManager_Busy;\r
+ }\r
+ serialWriteHandle->transfer.buffer = buffer;\r
+ serialWriteHandle->transfer.length = length;\r
+ serialWriteHandle->transfer.soFar = 0U;\r
+ serialWriteHandle->transfer.mode = mode;\r
+\r
+ if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))\r
+ {\r
+ isEmpty = 1U;\r
+ }\r
+ SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);\r
+ EnableGlobalIRQ(primask);\r
+\r
+ if (isEmpty != 0U)\r
+ {\r
+ status = SerialManager_StartWriting(handle);\r
+ if ((serial_manager_status_t)kStatus_SerialManager_Success != status)\r
+ {\r
+ return status;\r
+ }\r
+ }\r
+\r
+ if (kSerialManager_TransmissionBlocking == mode)\r
+ {\r
+ while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)\r
+ {\r
+#if defined(__GIC_PRIO_BITS)\r
+ if ((__get_CPSR() & CPSR_M_Msk) == 0x13)\r
+#else\r
+ if (__get_IPSR() != 0U)\r
+#endif\r
+ {\r
+ SerialManager_IsrFunction(handle);\r
+ }\r
+ }\r
+ }\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length,\r
+ serial_manager_transmission_mode_t mode,\r
+ uint32_t *receivedLength)\r
+{\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+ serial_manager_handle_t *handle;\r
+ uint32_t dataLength;\r
+ uint32_t primask;\r
+\r
+ assert(readHandle);\r
+ assert(buffer);\r
+ assert(length);\r
+\r
+ serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
+ handle = serialReadHandle->serialManagerHandle;\r
+\r
+ assert(handle);\r
+ assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
+ assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));\r
+\r
+ primask = DisableGlobalIRQ();\r
+ if (serialReadHandle->transfer.buffer != NULL)\r
+ {\r
+ EnableGlobalIRQ(primask);\r
+ return kStatus_SerialManager_Busy;\r
+ }\r
+ serialReadHandle->transfer.buffer = buffer;\r
+ serialReadHandle->transfer.length = length;\r
+ serialReadHandle->transfer.soFar = 0U;\r
+ serialReadHandle->transfer.mode = mode;\r
+\r
+ dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
+ dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
+\r
+ for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);\r
+ serialReadHandle->transfer.soFar++)\r
+ {\r
+ buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];\r
+ handle->ringBuffer.ringTail++;\r
+ if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)\r
+ {\r
+ handle->ringBuffer.ringTail = 0U;\r
+ }\r
+ }\r
+\r
+ dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
+ dataLength = dataLength % handle->ringBuffer.ringBufferSize;\r
+ dataLength = handle->ringBuffer.ringBufferSize - 1U - dataLength;\r
+\r
+ (void)SerialManager_StartReading(handle, readHandle, NULL, dataLength);\r
+\r
+ if (receivedLength != NULL)\r
+ {\r
+ *receivedLength = serialReadHandle->transfer.soFar;\r
+ serialReadHandle->transfer.buffer = NULL;\r
+ EnableGlobalIRQ(primask);\r
+ }\r
+ else\r
+ {\r
+ if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)\r
+ {\r
+ serialReadHandle->transfer.buffer = NULL;\r
+ EnableGlobalIRQ(primask);\r
+ if (kSerialManager_TransmissionNonBlocking == mode)\r
+ {\r
+ if (serialReadHandle->callback != NULL)\r
+ {\r
+ serial_manager_callback_message_t msg;\r
+ msg.buffer = buffer;\r
+ msg.length = serialReadHandle->transfer.soFar;\r
+ serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ EnableGlobalIRQ(primask);\r
+ }\r
+\r
+ if (kSerialManager_TransmissionBlocking == mode)\r
+ {\r
+ while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)\r
+ {\r
+ }\r
+ }\r
+ }\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+#else\r
+\r
+static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
+{\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+ serial_manager_handle_t *handle;\r
+\r
+ assert(writeHandle);\r
+ assert(buffer);\r
+ assert(length);\r
+\r
+ serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
+ handle = serialWriteHandle->serialManagerHandle;\r
+\r
+ assert(handle);\r
+\r
+ return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);\r
+}\r
+\r
+static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
+{\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+ serial_manager_handle_t *handle;\r
+\r
+ assert(readHandle);\r
+ assert(buffer);\r
+ assert(length);\r
+\r
+ serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
+ handle = serialReadHandle->serialManagerHandle;\r
+\r
+ assert(handle);\r
+\r
+ return SerialManager_StartReading(handle, serialReadHandle, buffer, length);\r
+}\r
+#endif\r
+\r
+serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+\r
+ assert(config);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ assert(config->ringBuffer);\r
+ assert(config->ringBufferSize);\r
+#endif\r
+ assert(serialHandle);\r
+ assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));\r
+\r
+ handle = (serial_manager_handle_t *)serialHandle;\r
+\r
+ (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+\r
+ COMMON_TASK_init();\r
+\r
+#else\r
+ if (KOSA_StatusSuccess != OSA_EventCreate((osa_event_handle_t)handle->event, true))\r
+ {\r
+ return kStatus_SerialManager_Error;\r
+ }\r
+\r
+ if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))\r
+ {\r
+ return kStatus_SerialManager_Error;\r
+ }\r
+#endif\r
+\r
+#endif\r
+\r
+#endif\r
+\r
+ handle->type = config->type;\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ handle->ringBuffer.ringBuffer = config->ringBuffer;\r
+ handle->ringBuffer.ringBufferSize = config->ringBufferSize;\r
+#endif\r
+\r
+ switch (config->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ if ((serial_manager_status_t)kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_TxCallback, handle);\r
+ if ((serial_manager_status_t)kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_RxCallback, handle);\r
+ }\r
+ }\r
+#endif\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ if (kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_TxCallback, handle);\r
+ if (kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_RxCallback, handle);\r
+ }\r
+ }\r
+#endif\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ if (kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_TxCallback, handle);\r
+ }\r
+#endif\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ status = Serial_UsbCdcVirtualInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ if (kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_UsbCdcVirtualInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_TxCallback, handle);\r
+ if (kStatus_SerialManager_Success == status)\r
+ {\r
+ status = Serial_UsbCdcVirtualInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),\r
+ SerialManager_RxCallback, handle);\r
+ }\r
+ }\r
+#endif\r
+ break;\r
+#endif\r
+ default:\r
+ /*MISRA rule 16.4*/\r
+ break;\r
+ }\r
+\r
+ return status;\r
+}\r
+\r
+serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)\r
+{\r
+ serial_manager_handle_t *handle;\r
+\r
+ assert(serialHandle);\r
+\r
+ handle = (serial_manager_handle_t *)serialHandle;\r
+\r
+ if ((handle->openedReadHandleHead != NULL) || (handle->openedWriteHandleCount != 0U))\r
+ {\r
+ return kStatus_SerialManager_Busy;\r
+ }\r
+\r
+ switch (handle->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ (void)Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ (void)Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ Serial_UsbCdcVirtualDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+ default:\r
+ /*MISRA rule 16.4*/\r
+ break;\r
+ }\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+#else\r
+ OSA_EventDestroy((osa_event_handle_t)handle->event);\r
+ OSA_TaskDestroy((osa_task_handle_t)handle->taskId);\r
+#endif\r
+\r
+#endif\r
+\r
+#endif\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+\r
+ assert(serialHandle);\r
+ assert(writeHandle);\r
+ assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));\r
+\r
+ handle = (serial_manager_handle_t *)serialHandle;\r
+ serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
+\r
+ (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
+\r
+ handle->openedWriteHandleCount++;\r
+\r
+ serialWriteHandle->serialManagerHandle = handle;\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;\r
+#endif\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+\r
+ assert(writeHandle);\r
+\r
+ serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
+ handle = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;\r
+\r
+ assert(handle);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
+#endif\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ (void)SerialManager_CancelWriting(writeHandle);\r
+#endif\r
+\r
+ handle->openedWriteHandleCount--;\r
+ (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+\r
+ assert(serialHandle);\r
+ assert(readHandle);\r
+ assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));\r
+\r
+ handle = (serial_manager_handle_t *)serialHandle;\r
+ serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
+\r
+ if (handle->openedReadHandleHead != NULL)\r
+ {\r
+ return kStatus_SerialManager_Busy;\r
+ }\r
+ (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
+\r
+ handle->openedReadHandleHead = serialReadHandle;\r
+\r
+ serialReadHandle->serialManagerHandle = handle;\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;\r
+#endif\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)\r
+{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+\r
+ assert(readHandle);\r
+\r
+ serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
+ handle = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;\r
+\r
+ assert(handle);\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
+#endif\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ (void)SerialManager_CancelReading(readHandle);\r
+#endif\r
+\r
+ handle->openedReadHandleHead = NULL;\r
+ (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)\r
+{\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);\r
+#else\r
+ return SerialManager_Write(writeHandle, buffer, length);\r
+#endif\r
+}\r
+\r
+serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
+{\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+ return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);\r
+#else\r
+ return SerialManager_Read(readHandle, buffer, length);\r
+#endif\r
+}\r
+\r
+#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length)\r
+{\r
+ return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);\r
+}\r
+\r
+serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)\r
+{\r
+ return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);\r
+}\r
+\r
+serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)\r
+{\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+ uint32_t primask;\r
+ uint8_t isNotUsed = 0;\r
+\r
+ assert(writeHandle);\r
+\r
+ serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
+\r
+ assert(serialWriteHandle->serialManagerHandle);\r
+ assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
+\r
+ if ((serialWriteHandle->transfer.buffer != NULL) &&\r
+ (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))\r
+ {\r
+ return kStatus_SerialManager_Error;\r
+ }\r
+\r
+ primask = DisableGlobalIRQ();\r
+ if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(\r
+ &serialWriteHandle->serialManagerHandle->runningWriteHandleHead))\r
+ {\r
+ (void)LIST_RemoveElement(&serialWriteHandle->link);\r
+ isNotUsed = 1;\r
+ }\r
+ EnableGlobalIRQ(primask);\r
+\r
+ if (isNotUsed != 0U)\r
+ {\r
+ serialWriteHandle->transfer.soFar = 0;\r
+ serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;\r
+\r
+ SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);\r
+#if defined(OSA_USED)\r
+\r
+#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))\r
+ serialWriteHandle->serialManagerHandle->commontaskMsg.callback = SerialManager_Task;\r
+ serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;\r
+ COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);\r
+#else\r
+ (void)OSA_EventSet((osa_event_handle_t)serialWriteHandle->serialManagerHandle->event, SERIAL_EVENT_DATA_SENT);\r
+#endif\r
+\r
+#else\r
+ SerialManager_Task(serialWriteHandle->serialManagerHandle);\r
+#endif\r
+ }\r
+ else\r
+ {\r
+ switch (serialWriteHandle->serialManagerHandle->type)\r
+ {\r
+#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
+ case kSerialPort_Uart:\r
+ (void)Serial_UartCancelWrite(\r
+ ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
+ case kSerialPort_UsbCdc:\r
+ (void)Serial_UsbCdcCancelWrite(\r
+ ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ (void)Serial_SwoCancelWrite(\r
+ ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ Serial_UsbCdcVirtualCancelWrite(\r
+ (void)Serial_SwoCancelWrite(\r
+ ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));\r
+ break;\r
+#endif\r
+ default:\r
+ /*MISRA rule 16.4*/\r
+ break;\r
+ }\r
+ }\r
+\r
+ (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)\r
+{\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+ serial_manager_callback_message_t msg;\r
+ uint8_t *buffer;\r
+ uint32_t primask;\r
+\r
+ assert(readHandle);\r
+\r
+ serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
+\r
+ assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
+\r
+ if ((serialReadHandle->transfer.buffer != NULL) &&\r
+ (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))\r
+ {\r
+ return kStatus_SerialManager_Error;\r
+ }\r
+\r
+ primask = DisableGlobalIRQ();\r
+ buffer = serialReadHandle->transfer.buffer;\r
+ serialReadHandle->transfer.buffer = NULL;\r
+ serialReadHandle->transfer.length = 0;\r
+ msg.buffer = buffer;\r
+ msg.length = serialReadHandle->transfer.soFar;\r
+ EnableGlobalIRQ(primask);\r
+\r
+ if (buffer != NULL)\r
+ {\r
+ if (serialReadHandle->callback != NULL)\r
+ {\r
+ serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);\r
+ }\r
+ }\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,\r
+ uint8_t *buffer,\r
+ uint32_t length,\r
+ uint32_t *receivedLength)\r
+{\r
+ assert(receivedLength);\r
+\r
+ return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);\r
+}\r
+\r
+serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,\r
+ serial_manager_callback_t callback,\r
+ void *callbackParam)\r
+{\r
+ serial_manager_write_handle_t *serialWriteHandle;\r
+\r
+ assert(writeHandle);\r
+\r
+ serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
+\r
+ assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
+\r
+ serialWriteHandle->callbackParam = callbackParam;\r
+ serialWriteHandle->callback = callback;\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,\r
+ serial_manager_callback_t callback,\r
+ void *callbackParam)\r
+{\r
+ serial_manager_read_handle_t *serialReadHandle;\r
+\r
+ assert(readHandle);\r
+\r
+ serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
+\r
+ assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
+\r
+ serialReadHandle->callbackParam = callbackParam;\r
+ serialReadHandle->callback = callback;\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+#endif\r
+\r
+serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)\r
+{\r
+ assert(serialHandle);\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
+\r
+serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)\r
+{\r
+ assert(serialHandle);\r
+\r
+ return kStatus_SerialManager_Success;\r
+}\r
projects / freertos / blobdiff