/*\r
- * Copyright 2018 NXP\r
+ * Copyright 2018-2019 NXP\r
* All rights reserved.\r
*\r
*\r
#include <string.h>\r
\r
#include "serial_manager.h"\r
-\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
#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_TransmissionBlocking = 0x0U, /*!< Blocking transmission*/\r
kSerialManager_TransmissionNonBlocking = 0x1U, /*!< None blocking transmission*/\r
} serial_manager_transmission_mode_t;\r
\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
+ list_label_t runningWriteHandleHead; /*!< The queue of running write handle */\r
+ list_label_t completedWriteHandleHead; /*!< The queue of completed write handle */\r
#endif\r
- serial_manager_read_handle_t *openedReadHandleHead;\r
- uint32_t openedWriteHandleCount;\r
+ serial_manager_read_handle_t *volatile openedReadHandleHead;\r
+ volatile uint32_t openedWriteHandleCount;\r
union\r
{\r
uint8_t lowLevelhandleBuffer[1];\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
* Prototypes\r
******************************************************************************/\r
\r
-#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
-serial_manager_status_t Serial_UartInit(serial_handle_t serialHandle, void *config);\r
-serial_manager_status_t Serial_UartDeinit(serial_handle_t serialHandle);\r
-serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
-#if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
-serial_manager_status_t Serial_UartRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
-#endif\r
-serial_manager_status_t Serial_UartCancelWrite(serial_handle_t serialHandle);\r
-serial_manager_status_t Serial_UartInstallTxCallback(serial_handle_t serialHandle,\r
- serial_manager_callback_t callback,\r
- void *callbackParam);\r
-serial_manager_status_t Serial_UartInstallRxCallback(serial_handle_t serialHandle,\r
- serial_manager_callback_t callback,\r
- void *callbackParam);\r
-void Serial_UartIsrFunction(serial_handle_t serialHandle);\r
-#endif\r
-\r
-#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
-serial_manager_status_t Serial_UsbCdcInit(serial_handle_t serialHandle, void *config);\r
-serial_manager_status_t Serial_UsbCdcDeinit(serial_handle_t serialHandle);\r
-serial_manager_status_t Serial_UsbCdcWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
-serial_manager_status_t Serial_UsbCdcCancelWrite(serial_handle_t serialHandle);\r
-serial_manager_status_t Serial_UsbCdcInstallTxCallback(serial_handle_t serialHandle,\r
- serial_manager_callback_t callback,\r
- void *callbackParam);\r
-serial_manager_status_t Serial_UsbCdcInstallRxCallback(serial_handle_t serialHandle,\r
- serial_manager_callback_t callback,\r
- void *callbackParam);\r
-void Serial_UsbCdcIsrFunction(serial_handle_t serialHandle);\r
-#endif\r
-\r
-#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
-serial_manager_status_t Serial_SwoInit(serial_handle_t serialHandle, void *config);\r
-serial_manager_status_t Serial_SwoDeinit(serial_handle_t serialHandle);\r
-serial_manager_status_t Serial_SwoWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
-#if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
-serial_manager_status_t Serial_SwoRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length);\r
-#endif\r
-serial_manager_status_t Serial_SwoCancelWrite(serial_handle_t serialHandle);\r
-serial_manager_status_t Serial_SwoInstallTxCallback(serial_handle_t serialHandle,\r
- serial_manager_callback_t callback,\r
- void *callbackParam);\r
-serial_manager_status_t Serial_SwoInstallRxCallback(serial_handle_t serialHandle,\r
- serial_manager_callback_t callback,\r
- void *callbackParam);\r
-void Serial_SwoIsrFunction(serial_handle_t serialHandle);\r
-#endif\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
#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
+static void SerialManager_AddTail(list_label_t *queue, serial_manager_write_handle_t *node)\r
{\r
- LIST_AddTail(queue, &node->link);\r
+ (void)LIST_AddTail(queue, &node->link);\r
}\r
\r
-static void SerialManager_RemoveHead(list_t *queue)\r
+static void SerialManager_RemoveHead(list_label_t *queue)\r
{\r
- LIST_RemoveHead(queue);\r
+ (void)LIST_RemoveHead(queue);\r
}\r
#endif\r
\r
{\r
serial_manager_status_t status = kStatus_SerialManager_Error;\r
serial_manager_write_handle_t *writeHandle =\r
- (serial_manager_write_handle_t *)LIST_GetHead(&handle->runningWriteHandleHead);\r
+ (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
\r
- if (writeHandle)\r
+ if (writeHandle != NULL)\r
{\r
switch (handle->type)\r
{\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 (NULL != readHandle)\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
{\r
serial_manager_status_t status = kStatus_SerialManager_Error;\r
\r
- if (writeHandle)\r
+ if (NULL != writeHandle)\r
{\r
switch (handle->type)\r
{\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
{\r
serial_manager_status_t status = kStatus_SerialManager_Error;\r
\r
- if (readHandle)\r
+ if (NULL != readHandle)\r
{\r
switch (handle->type)\r
{\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
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
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
+ uint32_t primask;\r
serial_manager_callback_message_t msg;\r
+\r
if (NULL != handle)\r
{\r
#if defined(OSA_USED)\r
\r
#endif\r
{\r
- serialWriteHandle = (serial_manager_write_handle_t *)LIST_GetHead(&handle->completedWriteHandleHead);\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
+ msg.buffer = serialWriteHandle->transfer.buffer;\r
+ msg.length = serialWriteHandle->transfer.soFar;\r
serialWriteHandle->transfer.buffer = NULL;\r
- if (serialWriteHandle->callback)\r
+ if (NULL != serialWriteHandle->callback)\r
{\r
serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,\r
serialWriteHandle->transfer.status);\r
}\r
- serialWriteHandle = (serial_manager_write_handle_t *)LIST_GetHead(&handle->completedWriteHandleHead);\r
+ serialWriteHandle =\r
+ (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);\r
}\r
}\r
#if defined(OSA_USED)\r
\r
#endif\r
{\r
+ primask = DisableGlobalIRQ();\r
serialReadHandle = handle->openedReadHandleHead;\r
- if ((serialReadHandle) && (serialReadHandle->transfer.buffer) &&\r
- (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length))\r
+ EnableGlobalIRQ(primask);\r
+\r
+ if (NULL != serialReadHandle)\r
{\r
- msg.buffer = serialReadHandle->transfer.buffer;\r
- msg.length = serialReadHandle->transfer.soFar;\r
- serialReadHandle->transfer.buffer = NULL;\r
- if (serialReadHandle->callback)\r
+ if (NULL != serialReadHandle->transfer.buffer)\r
{\r
- serialReadHandle->callback(serialReadHandle->callbackParam, &msg,\r
- serialReadHandle->transfer.status);\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 (NULL != serialReadHandle->callback)\r
+ {\r
+ serialReadHandle->callback(serialReadHandle->callbackParam, &msg,\r
+ serialReadHandle->transfer.status);\r
+ }\r
+ }\r
}\r
}\r
}\r
\r
handle = (serial_manager_handle_t *)callbackParam;\r
\r
- writeHandle = (serial_manager_write_handle_t *)LIST_GetHead(&handle->runningWriteHandleHead);\r
+ writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);\r
\r
if (NULL != writeHandle)\r
{\r
SerialManager_RemoveHead(&handle->runningWriteHandleHead);\r
- SerialManager_StartWriting(handle);\r
- writeHandle->transfer.soFar = message->length;\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
#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.callback = SerialManager_Task;\r
handle->commontaskMsg.callbackParam = handle;\r
COMMON_TASK_post_message(&handle->commontaskMsg);\r
#else\r
{\r
serial_manager_handle_t *handle;\r
uint32_t ringBufferLength;\r
+ uint32_t primask;\r
\r
assert(callbackParam);\r
assert(message);\r
\r
status = kStatus_SerialManager_Notify;\r
\r
- for (int i = 0; i < message->length; i++)\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
ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;\r
ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;\r
\r
- if ((handle->openedReadHandleHead) && (handle->openedReadHandleHead->transfer.buffer))\r
+ primask = DisableGlobalIRQ();\r
+ if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->transfer.buffer))\r
{\r
if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)\r
{\r
- int remainLength =\r
+ uint32_t remainLength =\r
handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;\r
- for (int i = 0; i < MIN(ringBufferLength, remainLength); i++)\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
#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.callback = SerialManager_Task;\r
handle->commontaskMsg.callbackParam = handle;\r
COMMON_TASK_post_message(&handle->commontaskMsg);\r
#else\r
}\r
}\r
\r
- if (ringBufferLength)\r
+ if (0U != ringBufferLength)\r
{\r
message->buffer = NULL;\r
message->length = ringBufferLength;\r
- if ((NULL != handle->openedReadHandleHead->callback))\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
+ EnableGlobalIRQ(primask);\r
}\r
\r
static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,\r
assert(length);\r
\r
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
- handle = serialWriteHandle->serialManagerHandle;\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)\r
+ if (NULL != serialWriteHandle->transfer.buffer)\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
+ serialWriteHandle->transfer.soFar = 0U;\r
+ serialWriteHandle->transfer.mode = mode;\r
\r
if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))\r
{\r
SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);\r
EnableGlobalIRQ(primask);\r
\r
- if (isEmpty)\r
+ if (0U != isEmpty)\r
{\r
status = SerialManager_StartWriting(handle);\r
- if (kStatus_SerialManager_Success != status)\r
+ if ((serial_manager_status_t)kStatus_SerialManager_Success != status)\r
{\r
return status;\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
+ if (0x13 == (__get_CPSR() & CPSR_M_Msk))\r
#else\r
- if (__get_IPSR())\r
+ if (0U != __get_IPSR())\r
#endif\r
{\r
SerialManager_IsrFunction(handle);\r
assert(length);\r
\r
serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
- handle = serialReadHandle->serialManagerHandle;\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)\r
+ if (NULL != serialReadHandle->transfer.buffer)\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
+ 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 < MIN(dataLength, length); serialReadHandle->transfer.soFar++)\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
handle->ringBuffer.ringTail = 0U;\r
}\r
}\r
- EnableGlobalIRQ(primask);\r
\r
- if (receivedLength)\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 (NULL != receivedLength)\r
{\r
- *receivedLength = serialReadHandle->transfer.soFar;\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)\r
+ if (NULL != serialReadHandle->callback)\r
{\r
serial_manager_callback_message_t msg;\r
msg.buffer = buffer;\r
}\r
}\r
}\r
+ else\r
+ {\r
+ EnableGlobalIRQ(primask);\r
+ }\r
\r
if (kSerialManager_TransmissionBlocking == mode)\r
{\r
assert(length);\r
\r
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
- handle = serialWriteHandle->serialManagerHandle;\r
+ handle = serialWriteHandle->serialManagerHandle;\r
\r
assert(handle);\r
\r
assert(length);\r
\r
serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
- handle = serialReadHandle->serialManagerHandle;\r
+ handle = serialReadHandle->serialManagerHandle;\r
\r
assert(handle);\r
\r
assert(config->ringBufferSize);\r
#endif\r
assert(serialHandle);\r
- if (SERIAL_MANAGER_HANDLE_SIZE < sizeof(serial_manager_handle_t))\r
- {\r
- return kStatus_SerialManager_Error;\r
- }\r
+ assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));\r
\r
handle = (serial_manager_handle_t *)serialHandle;\r
\r
- memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);\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
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.ringBuffer = config->ringBuffer;\r
handle->ringBuffer.ringBufferSize = config->ringBufferSize;\r
#endif\r
\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 (kStatus_SerialManager_Success == status)\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 (kStatus_SerialManager_Success == status)\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
#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
serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)\r
{\r
serial_manager_handle_t *handle;\r
+ uint32_t primask;\r
\r
assert(serialHandle);\r
\r
handle = (serial_manager_handle_t *)serialHandle;\r
\r
- if ((handle->openedReadHandleHead) || (handle->openedWriteHandleCount))\r
+ primask = DisableGlobalIRQ();\r
+ if ((NULL != handle->openedReadHandleHead) || (0U != handle->openedWriteHandleCount))\r
{\r
+ EnableGlobalIRQ(primask);\r
return kStatus_SerialManager_Busy;\r
}\r
+ EnableGlobalIRQ(primask);\r
\r
switch (handle->type)\r
{\r
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
case kSerialPort_Uart:\r
- Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\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
- Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\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
- Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));\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
+ (void)Serial_UsbCdcVirtualDeinit(((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
serial_manager_handle_t *handle;\r
serial_manager_write_handle_t *serialWriteHandle;\r
+ uint32_t primask;\r
\r
assert(serialHandle);\r
assert(writeHandle);\r
- if (SERIAL_MANAGER_WRITE_HANDLE_SIZE < sizeof(serial_manager_write_handle_t))\r
- {\r
- return kStatus_SerialManager_Error;\r
- }\r
- handle = (serial_manager_handle_t *)serialHandle;\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
- memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
+ (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
\r
+ primask = DisableGlobalIRQ();\r
handle->openedWriteHandleCount++;\r
+ EnableGlobalIRQ(primask);\r
\r
serialWriteHandle->serialManagerHandle = handle;\r
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
{\r
serial_manager_handle_t *handle;\r
serial_manager_write_handle_t *serialWriteHandle;\r
+ uint32_t primask;\r
\r
assert(writeHandle);\r
\r
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;\r
- handle = (serial_manager_handle_t *)serialWriteHandle->serialManagerHandle;\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
#endif\r
\r
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
- SerialManager_CancelWriting(writeHandle);\r
+ (void)SerialManager_CancelWriting(writeHandle);\r
#endif\r
+ primask = DisableGlobalIRQ();\r
+ if (handle->openedWriteHandleCount > 0U)\r
+ {\r
+ handle->openedWriteHandleCount--;\r
+ }\r
+ EnableGlobalIRQ(primask);\r
\r
- handle->openedWriteHandleCount--;\r
- memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
+ (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);\r
\r
return kStatus_SerialManager_Success;\r
}\r
{\r
serial_manager_handle_t *handle;\r
serial_manager_read_handle_t *serialReadHandle;\r
+ uint32_t primask;\r
\r
assert(serialHandle);\r
assert(readHandle);\r
- if (SERIAL_MANAGER_READ_HANDLE_SIZE < sizeof(serial_manager_read_handle_t))\r
- {\r
- return kStatus_SerialManager_Error;\r
- }\r
- handle = (serial_manager_handle_t *)serialHandle;\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)\r
+ primask = DisableGlobalIRQ();\r
+ if (handle->openedReadHandleHead != NULL)\r
{\r
+ EnableGlobalIRQ(primask);\r
return kStatus_SerialManager_Busy;\r
}\r
- memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
-\r
handle->openedReadHandleHead = serialReadHandle;\r
+ EnableGlobalIRQ(primask);\r
+\r
+ (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
\r
serialReadHandle->serialManagerHandle = handle;\r
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
{\r
serial_manager_handle_t *handle;\r
serial_manager_read_handle_t *serialReadHandle;\r
+ uint32_t primask;\r
\r
assert(readHandle);\r
\r
serialReadHandle = (serial_manager_read_handle_t *)readHandle;\r
- handle = (serial_manager_handle_t *)serialReadHandle->serialManagerHandle;\r
+ handle = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;\r
\r
- assert(handle);\r
+ assert(handle && (handle->openedReadHandleHead == serialReadHandle));\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
- SerialManager_CancelReading(readHandle);\r
+ (void)SerialManager_CancelReading(readHandle);\r
#endif\r
\r
+ primask = DisableGlobalIRQ();\r
handle->openedReadHandleHead = NULL;\r
- memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
+ EnableGlobalIRQ(primask);\r
+\r
+ (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);\r
\r
return kStatus_SerialManager_Success;\r
}\r
assert(serialWriteHandle->serialManagerHandle);\r
assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
\r
- if ((serialWriteHandle->transfer.buffer) &&\r
+ if ((NULL != serialWriteHandle->transfer.buffer) &&\r
(kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))\r
{\r
return kStatus_SerialManager_Error;\r
}\r
\r
primask = DisableGlobalIRQ();\r
- if (serialWriteHandle !=\r
- (serial_manager_write_handle_t *)LIST_GetHead(&serialWriteHandle->serialManagerHandle->runningWriteHandleHead))\r
+ if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(\r
+ &serialWriteHandle->serialManagerHandle->runningWriteHandleHead))\r
{\r
- LIST_RemoveElement(&serialWriteHandle->link);\r
+ (void)LIST_RemoveElement(&serialWriteHandle->link);\r
isNotUsed = 1;\r
}\r
EnableGlobalIRQ(primask);\r
\r
- if (isNotUsed)\r
+ if (0U != isNotUsed)\r
{\r
- serialWriteHandle->transfer.soFar = 0;\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.callback = SerialManager_Task;\r
serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;\r
COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);\r
#else\r
{\r
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
case kSerialPort_Uart:\r
- Serial_UartCancelWrite(\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
- Serial_UsbCdcCancelWrite(\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
- Serial_SwoCancelWrite(\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
+ (void)Serial_UsbCdcVirtualCancelWrite(\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
- SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);\r
+ (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);\r
\r
return kStatus_SerialManager_Success;\r
}\r
\r
assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
\r
- if ((serialReadHandle->transfer.buffer) && (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))\r
+ if ((NULL != serialReadHandle->transfer.buffer) &&\r
+ (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))\r
{\r
return kStatus_SerialManager_Error;\r
}\r
\r
- primask = DisableGlobalIRQ();\r
- buffer = serialReadHandle->transfer.buffer;\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
+ msg.buffer = buffer;\r
+ msg.length = serialReadHandle->transfer.soFar;\r
EnableGlobalIRQ(primask);\r
\r
- if (buffer)\r
+ if (NULL != buffer)\r
{\r
- if (serialReadHandle->callback)\r
+ if (NULL != serialReadHandle->callback)\r
{\r
serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);\r
}\r
assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);\r
\r
serialWriteHandle->callbackParam = callbackParam;\r
- serialWriteHandle->callback = callback;\r
+ serialWriteHandle->callback = callback;\r
\r
return kStatus_SerialManager_Success;\r
}\r
assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);\r
\r
serialReadHandle->callbackParam = callbackParam;\r
- serialReadHandle->callback = callback;\r
+ serialReadHandle->callback = callback;\r
\r
return kStatus_SerialManager_Success;\r
}\r
\r
serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)\r
{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+\r
assert(serialHandle);\r
\r
- return kStatus_SerialManager_Success;\r
+ handle = (serial_manager_handle_t *)serialHandle;\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_UartEnterLowpower(((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
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ break;\r
+#endif\r
+ default:\r
+ /*MISRA rule 16.4*/\r
+ break;\r
+ }\r
+ return status;\r
}\r
\r
serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)\r
{\r
+ serial_manager_handle_t *handle;\r
+ serial_manager_status_t status = kStatus_SerialManager_Error;\r
+\r
assert(serialHandle);\r
\r
- return kStatus_SerialManager_Success;\r
+ handle = (serial_manager_handle_t *)serialHandle;\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_UartExitLowpower(((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
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
+ case kSerialPort_Swo:\r
+ break;\r
+#endif\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+ case kSerialPort_UsbCdcVirtual:\r
+ break;\r
+#endif\r
+ default:\r
+ /*MISRA rule 16.4*/\r
+ break;\r
+ }\r
+ return status;\r
}\r
projects / freertos / blobdiff