2 * Copyright 2018-2019 NXP
\r
3 * All rights reserved.
\r
6 * SPDX-License-Identifier: BSD-3-Clause
\r
9 #include "fsl_common.h"
\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
16 #include "generic_list.h"
\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
26 #if defined(OSA_USED)
\r
28 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
29 #include "common_task.h"
\r
31 #include "fsl_os_abstraction.h"
\r
38 /*******************************************************************************
\r
40 ******************************************************************************/
\r
43 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
\r
49 #define SERIAL_EVENT_DATA_RECEIVED (1U << 0)
\r
50 #define SERIAL_EVENT_DATA_SENT (1U << 1)
\r
52 #define SERIAL_MANAGER_WRITE_TAG 0xAABB5754U
\r
53 #define SERIAL_MANAGER_READ_TAG 0xBBAA5244U
\r
55 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
56 typedef enum _serial_manager_transmission_mode
\r
58 kSerialManager_TransmissionBlocking = 0x0U, /*!< Blocking transmission*/
\r
59 kSerialManager_TransmissionNonBlocking = 0x1U, /*!< None blocking transmission*/
\r
60 } serial_manager_transmission_mode_t;
\r
62 /* TX transfer structure */
\r
63 typedef struct _serial_manager_transfer
\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
73 /* write handle structure */
\r
74 typedef struct _serial_manager_send_handle
\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
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
86 } serial_manager_write_handle_t;
\r
88 typedef serial_manager_write_handle_t serial_manager_read_handle_t;
\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
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
101 #if defined(__CC_ARM)
\r
102 #pragma anon_unions
\r
104 /* The serial manager handle structure */
\r
105 typedef struct _serial_manager_handle
\r
107 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
108 list_label_t runningWriteHandleHead; /*!< The queue of running write handle */
\r
109 list_label_t completedWriteHandleHead; /*!< The queue of completed write handle */
\r
111 serial_manager_read_handle_t *volatile openedReadHandleHead;
\r
112 volatile uint32_t openedWriteHandleCount;
\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
119 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
120 uint8_t usbcdcHandleBuffer[SERIAL_PORT_USB_CDC_HANDLE_SIZE];
\r
122 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
123 uint8_t swoHandleBuffer[SERIAL_PORT_SWO_HANDLE_SIZE];
\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
129 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
130 serial_manager_read_ring_buffer_t ringBuffer;
\r
133 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
135 #if defined(OSA_USED)
\r
137 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
138 common_task_message_t commontaskMsg;
\r
140 uint8_t event[OSA_EVENT_HANDLE_SIZE]; /*!< Event instance */
\r
141 uint8_t taskId[OSA_TASK_HANDLE_SIZE]; /*!< Task handle */
\r
148 serial_port_type_t type;
\r
149 } serial_manager_handle_t;
\r
151 /*******************************************************************************
\r
153 ******************************************************************************/
\r
155 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
156 static void SerialManager_Task(void *param);
\r
159 /*******************************************************************************
\r
161 ******************************************************************************/
\r
163 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
165 #if defined(OSA_USED)
\r
167 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
171 * \brief Defines the serial manager task's stack
\r
173 OSA_TASK_DEFINE(SerialManager_Task, SERIAL_MANAGER_TASK_PRIORITY, 1, SERIAL_MANAGER_TASK_STACK_SIZE, false);
\r
180 /*******************************************************************************
\r
182 ******************************************************************************/
\r
184 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
185 static void SerialManager_AddTail(list_label_t *queue, serial_manager_write_handle_t *node)
\r
187 (void)LIST_AddTail(queue, &node->link);
\r
190 static void SerialManager_RemoveHead(list_label_t *queue)
\r
192 (void)LIST_RemoveHead(queue);
\r
196 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
198 static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle)
\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
204 if (writeHandle != NULL)
\r
206 switch (handle->type)
\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
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
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
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
233 status = kStatus_SerialManager_Error;
\r
240 static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,
\r
241 serial_manager_read_handle_t *readHandle,
\r
245 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
247 if (NULL != readHandle)
\r
249 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
250 if (handle->type == kSerialPort_UsbCdc)
\r
252 status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
\r
255 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
256 if (handle->type == kSerialPort_UsbCdcVirtual)
\r
258 status = Serial_UsbCdcVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
\r
267 static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle,
\r
268 serial_manager_write_handle_t *writeHandle,
\r
272 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
274 if (NULL != writeHandle)
\r
276 switch (handle->type)
\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
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
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
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
299 status = kStatus_SerialManager_Error;
\r
306 static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,
\r
307 serial_manager_read_handle_t *readHandle,
\r
311 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
313 if (NULL != readHandle)
\r
315 switch (handle->type)
\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
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
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
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
338 status = kStatus_SerialManager_Error;
\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
349 uint32_t regPrimask = DisableGlobalIRQ();
\r
350 switch (handle->type)
\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
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
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
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
373 /*MISRA rule 16.4*/
\r
376 EnableGlobalIRQ(regPrimask);
\r
379 static void SerialManager_Task(void *param)
\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
385 serial_manager_callback_message_t msg;
\r
387 if (NULL != handle)
\r
389 #if defined(OSA_USED)
\r
391 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
393 osa_event_flags_t ev = 0;
\r
397 if (KOSA_StatusSuccess ==
\r
398 OSA_EventWait((osa_event_handle_t)handle->event, osaEventFlagsAll_c, false, osaWaitForever_c, &ev))
\r
400 if (ev & SERIAL_EVENT_DATA_SENT)
\r
405 serialWriteHandle =
\r
406 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);
\r
407 while (NULL != serialWriteHandle)
\r
409 SerialManager_RemoveHead(&handle->completedWriteHandleHead);
\r
410 msg.buffer = serialWriteHandle->transfer.buffer;
\r
411 msg.length = serialWriteHandle->transfer.soFar;
\r
412 serialWriteHandle->transfer.buffer = NULL;
\r
413 if (NULL != serialWriteHandle->callback)
\r
415 serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,
\r
416 serialWriteHandle->transfer.status);
\r
418 serialWriteHandle =
\r
419 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);
\r
422 #if defined(OSA_USED)
\r
424 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
426 if (ev & SERIAL_EVENT_DATA_RECEIVED)
\r
431 primask = DisableGlobalIRQ();
\r
432 serialReadHandle = handle->openedReadHandleHead;
\r
433 EnableGlobalIRQ(primask);
\r
435 if (NULL != serialReadHandle)
\r
437 if (NULL != serialReadHandle->transfer.buffer)
\r
439 if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
\r
441 msg.buffer = serialReadHandle->transfer.buffer;
\r
442 msg.length = serialReadHandle->transfer.soFar;
\r
443 serialReadHandle->transfer.buffer = NULL;
\r
444 if (NULL != serialReadHandle->callback)
\r
446 serialReadHandle->callback(serialReadHandle->callbackParam, &msg,
\r
447 serialReadHandle->transfer.status);
\r
453 #if defined(OSA_USED)
\r
455 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
458 } while (gUseRtos_c);
\r
466 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
467 static void SerialManager_TxCallback(void *callbackParam,
\r
468 serial_manager_callback_message_t *message,
\r
469 serial_manager_status_t status)
\r
471 serial_manager_handle_t *handle;
\r
472 serial_manager_write_handle_t *writeHandle;
\r
474 assert(callbackParam);
\r
477 handle = (serial_manager_handle_t *)callbackParam;
\r
479 writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);
\r
481 if (NULL != writeHandle)
\r
483 SerialManager_RemoveHead(&handle->runningWriteHandleHead);
\r
484 (void)SerialManager_StartWriting(handle);
\r
485 writeHandle->transfer.soFar = message->length;
\r
486 writeHandle->transfer.status = status;
\r
487 if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)
\r
489 SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);
\r
490 #if defined(OSA_USED)
\r
492 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
493 handle->commontaskMsg.callback = SerialManager_Task;
\r
494 handle->commontaskMsg.callbackParam = handle;
\r
495 COMMON_TASK_post_message(&handle->commontaskMsg);
\r
497 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_SENT);
\r
501 SerialManager_Task(handle);
\r
506 writeHandle->transfer.buffer = NULL;
\r
511 static void SerialManager_RxCallback(void *callbackParam,
\r
512 serial_manager_callback_message_t *message,
\r
513 serial_manager_status_t status)
\r
515 serial_manager_handle_t *handle;
\r
516 uint32_t ringBufferLength;
\r
519 assert(callbackParam);
\r
522 handle = (serial_manager_handle_t *)callbackParam;
\r
524 status = kStatus_SerialManager_Notify;
\r
526 for (uint32_t i = 0; i < message->length; i++)
\r
528 handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];
\r
529 if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)
\r
531 handle->ringBuffer.ringHead = 0U;
\r
533 if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)
\r
535 status = kStatus_SerialManager_RingBufferOverflow;
\r
536 handle->ringBuffer.ringTail++;
\r
537 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
\r
539 handle->ringBuffer.ringTail = 0U;
\r
544 ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
\r
545 ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;
\r
547 primask = DisableGlobalIRQ();
\r
548 if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->transfer.buffer))
\r
550 if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)
\r
552 uint32_t remainLength =
\r
553 handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;
\r
554 for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)
\r
556 handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =
\r
557 handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
\r
558 handle->ringBuffer.ringTail++;
\r
559 handle->openedReadHandleHead->transfer.soFar++;
\r
560 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
\r
562 handle->ringBuffer.ringTail = 0U;
\r
565 ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);
\r
568 if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)
\r
573 if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)
\r
575 handle->openedReadHandleHead->transfer.buffer = NULL;
\r
579 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;
\r
581 #if defined(OSA_USED)
\r
583 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
584 handle->commontaskMsg.callback = SerialManager_Task;
\r
585 handle->commontaskMsg.callbackParam = handle;
\r
586 COMMON_TASK_post_message(&handle->commontaskMsg);
\r
588 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_RECEIVED);
\r
592 SerialManager_Task(handle);
\r
598 if (0U != ringBufferLength)
\r
600 message->buffer = NULL;
\r
601 message->length = ringBufferLength;
\r
602 if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))
\r
604 handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);
\r
608 ringBufferLength = handle->ringBuffer.ringBufferSize - 1U - ringBufferLength;
\r
610 if (NULL != handle->openedReadHandleHead)
\r
612 (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);
\r
614 EnableGlobalIRQ(primask);
\r
617 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,
\r
620 serial_manager_transmission_mode_t mode)
\r
622 serial_manager_write_handle_t *serialWriteHandle;
\r
623 serial_manager_handle_t *handle;
\r
624 serial_manager_status_t status = kStatus_SerialManager_Success;
\r
626 uint8_t isEmpty = 0U;
\r
628 assert(writeHandle);
\r
632 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
633 handle = serialWriteHandle->serialManagerHandle;
\r
636 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
637 assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));
\r
639 primask = DisableGlobalIRQ();
\r
640 if (NULL != serialWriteHandle->transfer.buffer)
\r
642 EnableGlobalIRQ(primask);
\r
643 return kStatus_SerialManager_Busy;
\r
645 serialWriteHandle->transfer.buffer = buffer;
\r
646 serialWriteHandle->transfer.length = length;
\r
647 serialWriteHandle->transfer.soFar = 0U;
\r
648 serialWriteHandle->transfer.mode = mode;
\r
650 if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))
\r
654 SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);
\r
655 EnableGlobalIRQ(primask);
\r
659 status = SerialManager_StartWriting(handle);
\r
660 if ((serial_manager_status_t)kStatus_SerialManager_Success != status)
\r
666 if (kSerialManager_TransmissionBlocking == mode)
\r
668 while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)
\r
670 #if defined(__GIC_PRIO_BITS)
\r
671 if (0x13 == (__get_CPSR() & CPSR_M_Msk))
\r
673 if (0U != __get_IPSR())
\r
676 SerialManager_IsrFunction(handle);
\r
680 return kStatus_SerialManager_Success;
\r
683 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,
\r
686 serial_manager_transmission_mode_t mode,
\r
687 uint32_t *receivedLength)
\r
689 serial_manager_read_handle_t *serialReadHandle;
\r
690 serial_manager_handle_t *handle;
\r
691 uint32_t dataLength;
\r
694 assert(readHandle);
\r
698 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
699 handle = serialReadHandle->serialManagerHandle;
\r
702 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
703 assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));
\r
705 primask = DisableGlobalIRQ();
\r
706 if (NULL != serialReadHandle->transfer.buffer)
\r
708 EnableGlobalIRQ(primask);
\r
709 return kStatus_SerialManager_Busy;
\r
711 serialReadHandle->transfer.buffer = buffer;
\r
712 serialReadHandle->transfer.length = length;
\r
713 serialReadHandle->transfer.soFar = 0U;
\r
714 serialReadHandle->transfer.mode = mode;
\r
716 dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
\r
717 dataLength = dataLength % handle->ringBuffer.ringBufferSize;
\r
719 for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);
\r
720 serialReadHandle->transfer.soFar++)
\r
722 buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
\r
723 handle->ringBuffer.ringTail++;
\r
724 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
\r
726 handle->ringBuffer.ringTail = 0U;
\r
730 dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
\r
731 dataLength = dataLength % handle->ringBuffer.ringBufferSize;
\r
732 dataLength = handle->ringBuffer.ringBufferSize - 1U - dataLength;
\r
734 (void)SerialManager_StartReading(handle, readHandle, NULL, dataLength);
\r
736 if (NULL != receivedLength)
\r
738 *receivedLength = serialReadHandle->transfer.soFar;
\r
739 serialReadHandle->transfer.buffer = NULL;
\r
740 EnableGlobalIRQ(primask);
\r
744 if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
\r
746 serialReadHandle->transfer.buffer = NULL;
\r
747 EnableGlobalIRQ(primask);
\r
748 if (kSerialManager_TransmissionNonBlocking == mode)
\r
750 if (NULL != serialReadHandle->callback)
\r
752 serial_manager_callback_message_t msg;
\r
753 msg.buffer = buffer;
\r
754 msg.length = serialReadHandle->transfer.soFar;
\r
755 serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);
\r
761 EnableGlobalIRQ(primask);
\r
764 if (kSerialManager_TransmissionBlocking == mode)
\r
766 while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)
\r
772 return kStatus_SerialManager_Success;
\r
777 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
\r
779 serial_manager_write_handle_t *serialWriteHandle;
\r
780 serial_manager_handle_t *handle;
\r
782 assert(writeHandle);
\r
786 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
787 handle = serialWriteHandle->serialManagerHandle;
\r
791 return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);
\r
794 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
\r
796 serial_manager_read_handle_t *serialReadHandle;
\r
797 serial_manager_handle_t *handle;
\r
799 assert(readHandle);
\r
803 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
804 handle = serialReadHandle->serialManagerHandle;
\r
808 return SerialManager_StartReading(handle, serialReadHandle, buffer, length);
\r
812 serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config)
\r
814 serial_manager_handle_t *handle;
\r
815 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
818 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
819 assert(config->ringBuffer);
\r
820 assert(config->ringBufferSize);
\r
822 assert(serialHandle);
\r
823 assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));
\r
825 handle = (serial_manager_handle_t *)serialHandle;
\r
827 (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);
\r
829 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
831 #if defined(OSA_USED)
\r
833 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
835 COMMON_TASK_init();
\r
838 if (KOSA_StatusSuccess != OSA_EventCreate((osa_event_handle_t)handle->event, true))
\r
840 return kStatus_SerialManager_Error;
\r
843 if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))
\r
845 return kStatus_SerialManager_Error;
\r
853 handle->type = config->type;
\r
855 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
856 handle->ringBuffer.ringBuffer = config->ringBuffer;
\r
857 handle->ringBuffer.ringBufferSize = config->ringBufferSize;
\r
860 switch (config->type)
\r
862 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
863 case kSerialPort_Uart:
\r
864 status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
865 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
866 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
\r
868 status = Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
869 SerialManager_TxCallback, handle);
\r
870 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
\r
872 status = Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
873 SerialManager_RxCallback, handle);
\r
879 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
880 case kSerialPort_UsbCdc:
\r
881 status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
882 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
883 if (kStatus_SerialManager_Success == status)
\r
885 status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
886 SerialManager_TxCallback, handle);
\r
887 if (kStatus_SerialManager_Success == status)
\r
889 status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
890 SerialManager_RxCallback, handle);
\r
896 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
897 case kSerialPort_Swo:
\r
898 status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
899 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
900 if (kStatus_SerialManager_Success == status)
\r
902 status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
903 SerialManager_TxCallback, handle);
\r
908 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
909 case kSerialPort_UsbCdcVirtual:
\r
910 status = Serial_UsbCdcVirtualInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
911 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
912 if (kStatus_SerialManager_Success == status)
\r
914 status = Serial_UsbCdcVirtualInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
915 SerialManager_TxCallback, handle);
\r
916 if (kStatus_SerialManager_Success == status)
\r
918 status = Serial_UsbCdcVirtualInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
919 SerialManager_RxCallback, handle);
\r
926 /*MISRA rule 16.4*/
\r
933 serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)
\r
935 serial_manager_handle_t *handle;
\r
938 assert(serialHandle);
\r
940 handle = (serial_manager_handle_t *)serialHandle;
\r
942 primask = DisableGlobalIRQ();
\r
943 if ((NULL != handle->openedReadHandleHead) || (0U != handle->openedWriteHandleCount))
\r
945 EnableGlobalIRQ(primask);
\r
946 return kStatus_SerialManager_Busy;
\r
948 EnableGlobalIRQ(primask);
\r
950 switch (handle->type)
\r
952 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
953 case kSerialPort_Uart:
\r
954 (void)Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
957 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
958 case kSerialPort_UsbCdc:
\r
959 (void)Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
962 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
963 case kSerialPort_Swo:
\r
964 (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
967 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
968 case kSerialPort_UsbCdcVirtual:
\r
969 (void)Serial_UsbCdcVirtualDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
973 /*MISRA rule 16.4*/
\r
976 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
978 #if defined(OSA_USED)
\r
980 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
982 OSA_EventDestroy((osa_event_handle_t)handle->event);
\r
983 OSA_TaskDestroy((osa_task_handle_t)handle->taskId);
\r
990 return kStatus_SerialManager_Success;
\r
993 serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)
\r
995 serial_manager_handle_t *handle;
\r
996 serial_manager_write_handle_t *serialWriteHandle;
\r
999 assert(serialHandle);
\r
1000 assert(writeHandle);
\r
1001 assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));
\r
1003 handle = (serial_manager_handle_t *)serialHandle;
\r
1004 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1006 (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
\r
1008 primask = DisableGlobalIRQ();
\r
1009 handle->openedWriteHandleCount++;
\r
1010 EnableGlobalIRQ(primask);
\r
1012 serialWriteHandle->serialManagerHandle = handle;
\r
1013 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1014 serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;
\r
1017 return kStatus_SerialManager_Success;
\r
1020 serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)
\r
1022 serial_manager_handle_t *handle;
\r
1023 serial_manager_write_handle_t *serialWriteHandle;
\r
1026 assert(writeHandle);
\r
1028 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1029 handle = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;
\r
1032 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1033 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
1036 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1037 (void)SerialManager_CancelWriting(writeHandle);
\r
1039 primask = DisableGlobalIRQ();
\r
1040 if (handle->openedWriteHandleCount > 0U)
\r
1042 handle->openedWriteHandleCount--;
\r
1044 EnableGlobalIRQ(primask);
\r
1046 (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
\r
1048 return kStatus_SerialManager_Success;
\r
1051 serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)
\r
1053 serial_manager_handle_t *handle;
\r
1054 serial_manager_read_handle_t *serialReadHandle;
\r
1057 assert(serialHandle);
\r
1058 assert(readHandle);
\r
1059 assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));
\r
1061 handle = (serial_manager_handle_t *)serialHandle;
\r
1062 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1064 primask = DisableGlobalIRQ();
\r
1065 if (handle->openedReadHandleHead != NULL)
\r
1067 EnableGlobalIRQ(primask);
\r
1068 return kStatus_SerialManager_Busy;
\r
1070 handle->openedReadHandleHead = serialReadHandle;
\r
1071 EnableGlobalIRQ(primask);
\r
1073 (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
\r
1075 serialReadHandle->serialManagerHandle = handle;
\r
1076 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1077 serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;
\r
1080 return kStatus_SerialManager_Success;
\r
1083 serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)
\r
1085 serial_manager_handle_t *handle;
\r
1086 serial_manager_read_handle_t *serialReadHandle;
\r
1089 assert(readHandle);
\r
1091 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1092 handle = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;
\r
1094 assert(handle && (handle->openedReadHandleHead == serialReadHandle));
\r
1095 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1096 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
1099 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1100 (void)SerialManager_CancelReading(readHandle);
\r
1103 primask = DisableGlobalIRQ();
\r
1104 handle->openedReadHandleHead = NULL;
\r
1105 EnableGlobalIRQ(primask);
\r
1107 (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
\r
1109 return kStatus_SerialManager_Success;
\r
1112 serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
\r
1114 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1115 return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);
\r
1117 return SerialManager_Write(writeHandle, buffer, length);
\r
1121 serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
\r
1123 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1124 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);
\r
1126 return SerialManager_Read(readHandle, buffer, length);
\r
1130 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1131 serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,
\r
1135 return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);
\r
1138 serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
\r
1140 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);
\r
1143 serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)
\r
1145 serial_manager_write_handle_t *serialWriteHandle;
\r
1147 uint8_t isNotUsed = 0;
\r
1149 assert(writeHandle);
\r
1151 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1153 assert(serialWriteHandle->serialManagerHandle);
\r
1154 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
1156 if ((NULL != serialWriteHandle->transfer.buffer) &&
\r
1157 (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))
\r
1159 return kStatus_SerialManager_Error;
\r
1162 primask = DisableGlobalIRQ();
\r
1163 if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(
\r
1164 &serialWriteHandle->serialManagerHandle->runningWriteHandleHead))
\r
1166 (void)LIST_RemoveElement(&serialWriteHandle->link);
\r
1169 EnableGlobalIRQ(primask);
\r
1171 if (0U != isNotUsed)
\r
1173 serialWriteHandle->transfer.soFar = 0;
\r
1174 serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;
\r
1176 SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);
\r
1177 #if defined(OSA_USED)
\r
1179 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
1180 serialWriteHandle->serialManagerHandle->commontaskMsg.callback = SerialManager_Task;
\r
1181 serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;
\r
1182 COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);
\r
1184 (void)OSA_EventSet((osa_event_handle_t)serialWriteHandle->serialManagerHandle->event, SERIAL_EVENT_DATA_SENT);
\r
1188 SerialManager_Task(serialWriteHandle->serialManagerHandle);
\r
1193 switch (serialWriteHandle->serialManagerHandle->type)
\r
1195 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
1196 case kSerialPort_Uart:
\r
1197 (void)Serial_UartCancelWrite(
\r
1198 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1201 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
1202 case kSerialPort_UsbCdc:
\r
1203 (void)Serial_UsbCdcCancelWrite(
\r
1204 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1207 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
1208 case kSerialPort_Swo:
\r
1209 (void)Serial_SwoCancelWrite(
\r
1210 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1213 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
1214 case kSerialPort_UsbCdcVirtual:
\r
1215 (void)Serial_UsbCdcVirtualCancelWrite(
\r
1216 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1220 /*MISRA rule 16.4*/
\r
1225 (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);
\r
1227 return kStatus_SerialManager_Success;
\r
1230 serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)
\r
1232 serial_manager_read_handle_t *serialReadHandle;
\r
1233 serial_manager_callback_message_t msg;
\r
1237 assert(readHandle);
\r
1239 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1241 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
1243 if ((NULL != serialReadHandle->transfer.buffer) &&
\r
1244 (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))
\r
1246 return kStatus_SerialManager_Error;
\r
1249 primask = DisableGlobalIRQ();
\r
1250 buffer = serialReadHandle->transfer.buffer;
\r
1251 serialReadHandle->transfer.buffer = NULL;
\r
1252 serialReadHandle->transfer.length = 0;
\r
1253 msg.buffer = buffer;
\r
1254 msg.length = serialReadHandle->transfer.soFar;
\r
1255 EnableGlobalIRQ(primask);
\r
1257 if (NULL != buffer)
\r
1259 if (NULL != serialReadHandle->callback)
\r
1261 serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);
\r
1264 return kStatus_SerialManager_Success;
\r
1267 serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,
\r
1270 uint32_t *receivedLength)
\r
1272 assert(receivedLength);
\r
1274 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);
\r
1277 serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,
\r
1278 serial_manager_callback_t callback,
\r
1279 void *callbackParam)
\r
1281 serial_manager_write_handle_t *serialWriteHandle;
\r
1283 assert(writeHandle);
\r
1285 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1287 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
1289 serialWriteHandle->callbackParam = callbackParam;
\r
1290 serialWriteHandle->callback = callback;
\r
1292 return kStatus_SerialManager_Success;
\r
1295 serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,
\r
1296 serial_manager_callback_t callback,
\r
1297 void *callbackParam)
\r
1299 serial_manager_read_handle_t *serialReadHandle;
\r
1301 assert(readHandle);
\r
1303 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1305 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
1307 serialReadHandle->callbackParam = callbackParam;
\r
1308 serialReadHandle->callback = callback;
\r
1310 return kStatus_SerialManager_Success;
\r
1314 serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)
\r
1316 serial_manager_handle_t *handle;
\r
1317 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
1319 assert(serialHandle);
\r
1321 handle = (serial_manager_handle_t *)serialHandle;
\r
1323 switch (handle->type)
\r
1325 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
1326 case kSerialPort_Uart:
\r
1327 status = Serial_UartEnterLowpower(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
1330 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
1331 case kSerialPort_UsbCdc:
\r
1334 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
1335 case kSerialPort_Swo:
\r
1338 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
1339 case kSerialPort_UsbCdcVirtual:
\r
1343 /*MISRA rule 16.4*/
\r
1349 serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)
\r
1351 serial_manager_handle_t *handle;
\r
1352 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
1354 assert(serialHandle);
\r
1356 handle = (serial_manager_handle_t *)serialHandle;
\r
1358 switch (handle->type)
\r
1360 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
1361 case kSerialPort_Uart:
\r
1362 status = Serial_UartExitLowpower(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
1365 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
1366 case kSerialPort_UsbCdc:
\r
1369 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
1370 case kSerialPort_Swo:
\r
1373 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
1374 case kSerialPort_UsbCdcVirtual:
\r
1378 /*MISRA rule 16.4*/
\r