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_t runningWriteHandleHead; /*!< The queue of running write handle */
\r
109 list_t completedWriteHandleHead; /*!< The queue of completed write handle */
\r
111 serial_manager_read_handle_t *openedReadHandleHead;
\r
112 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_t *queue, serial_manager_write_handle_t *node)
\r
187 (void)LIST_AddTail(queue, &node->link);
\r
190 static void SerialManager_RemoveHead(list_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 (readHandle != NULL)
\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 (writeHandle != NULL)
\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 (readHandle != NULL)
\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
384 serial_manager_callback_message_t msg;
\r
385 if (NULL != handle)
\r
387 #if defined(OSA_USED)
\r
389 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
391 osa_event_flags_t ev = 0;
\r
395 if (KOSA_StatusSuccess ==
\r
396 OSA_EventWait((osa_event_handle_t)handle->event, osaEventFlagsAll_c, false, osaWaitForever_c, &ev))
\r
398 if (ev & SERIAL_EVENT_DATA_SENT)
\r
403 serialWriteHandle =
\r
404 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);
\r
405 while (NULL != serialWriteHandle)
\r
407 SerialManager_RemoveHead(&handle->completedWriteHandleHead);
\r
408 msg.buffer = serialWriteHandle->transfer.buffer;
\r
409 msg.length = serialWriteHandle->transfer.soFar;
\r
410 serialWriteHandle->transfer.buffer = NULL;
\r
411 if (serialWriteHandle->callback != NULL)
\r
413 serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,
\r
414 serialWriteHandle->transfer.status);
\r
416 serialWriteHandle =
\r
417 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);
\r
420 #if defined(OSA_USED)
\r
422 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
424 if (ev & SERIAL_EVENT_DATA_RECEIVED)
\r
429 serialReadHandle = handle->openedReadHandleHead;
\r
430 if (serialReadHandle != NULL)
\r
432 if (serialReadHandle->transfer.buffer != NULL)
\r
434 if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
\r
436 msg.buffer = serialReadHandle->transfer.buffer;
\r
437 msg.length = serialReadHandle->transfer.soFar;
\r
438 serialReadHandle->transfer.buffer = NULL;
\r
439 if (serialReadHandle->callback != NULL)
\r
441 serialReadHandle->callback(serialReadHandle->callbackParam, &msg,
\r
442 serialReadHandle->transfer.status);
\r
448 #if defined(OSA_USED)
\r
450 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
453 } while (gUseRtos_c);
\r
461 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
462 static void SerialManager_TxCallback(void *callbackParam,
\r
463 serial_manager_callback_message_t *message,
\r
464 serial_manager_status_t status)
\r
466 serial_manager_handle_t *handle;
\r
467 serial_manager_write_handle_t *writeHandle;
\r
469 assert(callbackParam);
\r
472 handle = (serial_manager_handle_t *)callbackParam;
\r
474 writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);
\r
476 if (NULL != writeHandle)
\r
478 SerialManager_RemoveHead(&handle->runningWriteHandleHead);
\r
479 (void)SerialManager_StartWriting(handle);
\r
480 writeHandle->transfer.soFar = message->length;
\r
481 writeHandle->transfer.status = status;
\r
482 if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)
\r
484 SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);
\r
485 #if defined(OSA_USED)
\r
487 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
488 handle->commontaskMsg.callback = SerialManager_Task;
\r
489 handle->commontaskMsg.callbackParam = handle;
\r
490 COMMON_TASK_post_message(&handle->commontaskMsg);
\r
492 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_SENT);
\r
496 SerialManager_Task(handle);
\r
501 writeHandle->transfer.buffer = NULL;
\r
506 static void SerialManager_RxCallback(void *callbackParam,
\r
507 serial_manager_callback_message_t *message,
\r
508 serial_manager_status_t status)
\r
510 serial_manager_handle_t *handle;
\r
511 uint32_t ringBufferLength;
\r
513 assert(callbackParam);
\r
516 handle = (serial_manager_handle_t *)callbackParam;
\r
518 status = kStatus_SerialManager_Notify;
\r
520 for (uint32_t i = 0; i < message->length; i++)
\r
522 handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];
\r
523 if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)
\r
525 handle->ringBuffer.ringHead = 0U;
\r
527 if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)
\r
529 status = kStatus_SerialManager_RingBufferOverflow;
\r
530 handle->ringBuffer.ringTail++;
\r
531 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
\r
533 handle->ringBuffer.ringTail = 0U;
\r
538 ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
\r
539 ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;
\r
541 if ((handle->openedReadHandleHead != NULL) && (handle->openedReadHandleHead->transfer.buffer != NULL))
\r
543 if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)
\r
545 uint32_t remainLength =
\r
546 handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;
\r
547 for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)
\r
549 handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =
\r
550 handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
\r
551 handle->ringBuffer.ringTail++;
\r
552 handle->openedReadHandleHead->transfer.soFar++;
\r
553 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
\r
555 handle->ringBuffer.ringTail = 0U;
\r
558 ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);
\r
561 if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)
\r
566 if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)
\r
568 handle->openedReadHandleHead->transfer.buffer = NULL;
\r
572 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;
\r
574 #if defined(OSA_USED)
\r
576 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
577 handle->commontaskMsg.callback = SerialManager_Task;
\r
578 handle->commontaskMsg.callbackParam = handle;
\r
579 COMMON_TASK_post_message(&handle->commontaskMsg);
\r
581 (void)OSA_EventSet((osa_event_handle_t)handle->event, SERIAL_EVENT_DATA_RECEIVED);
\r
585 SerialManager_Task(handle);
\r
591 if (ringBufferLength != 0U)
\r
593 message->buffer = NULL;
\r
594 message->length = ringBufferLength;
\r
595 if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))
\r
597 handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);
\r
601 ringBufferLength = handle->ringBuffer.ringBufferSize - 1U - ringBufferLength;
\r
603 if (NULL != handle->openedReadHandleHead)
\r
605 (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);
\r
609 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,
\r
612 serial_manager_transmission_mode_t mode)
\r
614 serial_manager_write_handle_t *serialWriteHandle;
\r
615 serial_manager_handle_t *handle;
\r
616 serial_manager_status_t status = kStatus_SerialManager_Success;
\r
618 uint8_t isEmpty = 0U;
\r
620 assert(writeHandle);
\r
624 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
625 handle = serialWriteHandle->serialManagerHandle;
\r
628 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
629 assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));
\r
631 primask = DisableGlobalIRQ();
\r
632 if (serialWriteHandle->transfer.buffer != NULL)
\r
634 EnableGlobalIRQ(primask);
\r
635 return kStatus_SerialManager_Busy;
\r
637 serialWriteHandle->transfer.buffer = buffer;
\r
638 serialWriteHandle->transfer.length = length;
\r
639 serialWriteHandle->transfer.soFar = 0U;
\r
640 serialWriteHandle->transfer.mode = mode;
\r
642 if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))
\r
646 SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);
\r
647 EnableGlobalIRQ(primask);
\r
651 status = SerialManager_StartWriting(handle);
\r
652 if ((serial_manager_status_t)kStatus_SerialManager_Success != status)
\r
658 if (kSerialManager_TransmissionBlocking == mode)
\r
660 while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)
\r
662 #if defined(__GIC_PRIO_BITS)
\r
663 if ((__get_CPSR() & CPSR_M_Msk) == 0x13)
\r
665 if (__get_IPSR() != 0U)
\r
668 SerialManager_IsrFunction(handle);
\r
672 return kStatus_SerialManager_Success;
\r
675 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,
\r
678 serial_manager_transmission_mode_t mode,
\r
679 uint32_t *receivedLength)
\r
681 serial_manager_read_handle_t *serialReadHandle;
\r
682 serial_manager_handle_t *handle;
\r
683 uint32_t dataLength;
\r
686 assert(readHandle);
\r
690 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
691 handle = serialReadHandle->serialManagerHandle;
\r
694 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
695 assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));
\r
697 primask = DisableGlobalIRQ();
\r
698 if (serialReadHandle->transfer.buffer != NULL)
\r
700 EnableGlobalIRQ(primask);
\r
701 return kStatus_SerialManager_Busy;
\r
703 serialReadHandle->transfer.buffer = buffer;
\r
704 serialReadHandle->transfer.length = length;
\r
705 serialReadHandle->transfer.soFar = 0U;
\r
706 serialReadHandle->transfer.mode = mode;
\r
708 dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
\r
709 dataLength = dataLength % handle->ringBuffer.ringBufferSize;
\r
711 for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);
\r
712 serialReadHandle->transfer.soFar++)
\r
714 buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
\r
715 handle->ringBuffer.ringTail++;
\r
716 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
\r
718 handle->ringBuffer.ringTail = 0U;
\r
722 dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
\r
723 dataLength = dataLength % handle->ringBuffer.ringBufferSize;
\r
724 dataLength = handle->ringBuffer.ringBufferSize - 1U - dataLength;
\r
726 (void)SerialManager_StartReading(handle, readHandle, NULL, dataLength);
\r
728 if (receivedLength != NULL)
\r
730 *receivedLength = serialReadHandle->transfer.soFar;
\r
731 serialReadHandle->transfer.buffer = NULL;
\r
732 EnableGlobalIRQ(primask);
\r
736 if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
\r
738 serialReadHandle->transfer.buffer = NULL;
\r
739 EnableGlobalIRQ(primask);
\r
740 if (kSerialManager_TransmissionNonBlocking == mode)
\r
742 if (serialReadHandle->callback != NULL)
\r
744 serial_manager_callback_message_t msg;
\r
745 msg.buffer = buffer;
\r
746 msg.length = serialReadHandle->transfer.soFar;
\r
747 serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);
\r
753 EnableGlobalIRQ(primask);
\r
756 if (kSerialManager_TransmissionBlocking == mode)
\r
758 while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)
\r
764 return kStatus_SerialManager_Success;
\r
769 static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
\r
771 serial_manager_write_handle_t *serialWriteHandle;
\r
772 serial_manager_handle_t *handle;
\r
774 assert(writeHandle);
\r
778 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
779 handle = serialWriteHandle->serialManagerHandle;
\r
783 return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);
\r
786 static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
\r
788 serial_manager_read_handle_t *serialReadHandle;
\r
789 serial_manager_handle_t *handle;
\r
791 assert(readHandle);
\r
795 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
796 handle = serialReadHandle->serialManagerHandle;
\r
800 return SerialManager_StartReading(handle, serialReadHandle, buffer, length);
\r
804 serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config)
\r
806 serial_manager_handle_t *handle;
\r
807 serial_manager_status_t status = kStatus_SerialManager_Error;
\r
810 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
811 assert(config->ringBuffer);
\r
812 assert(config->ringBufferSize);
\r
814 assert(serialHandle);
\r
815 assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));
\r
817 handle = (serial_manager_handle_t *)serialHandle;
\r
819 (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);
\r
821 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
823 #if defined(OSA_USED)
\r
825 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
827 COMMON_TASK_init();
\r
830 if (KOSA_StatusSuccess != OSA_EventCreate((osa_event_handle_t)handle->event, true))
\r
832 return kStatus_SerialManager_Error;
\r
835 if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))
\r
837 return kStatus_SerialManager_Error;
\r
845 handle->type = config->type;
\r
847 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
848 handle->ringBuffer.ringBuffer = config->ringBuffer;
\r
849 handle->ringBuffer.ringBufferSize = config->ringBufferSize;
\r
852 switch (config->type)
\r
854 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
855 case kSerialPort_Uart:
\r
856 status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
857 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
858 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
\r
860 status = Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
861 SerialManager_TxCallback, handle);
\r
862 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
\r
864 status = Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
865 SerialManager_RxCallback, handle);
\r
871 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
872 case kSerialPort_UsbCdc:
\r
873 status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
874 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
875 if (kStatus_SerialManager_Success == status)
\r
877 status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
878 SerialManager_TxCallback, handle);
\r
879 if (kStatus_SerialManager_Success == status)
\r
881 status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
882 SerialManager_RxCallback, handle);
\r
888 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
889 case kSerialPort_Swo:
\r
890 status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
891 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
892 if (kStatus_SerialManager_Success == status)
\r
894 status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
895 SerialManager_TxCallback, handle);
\r
900 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
901 case kSerialPort_UsbCdcVirtual:
\r
902 status = Serial_UsbCdcVirtualInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
\r
903 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
904 if (kStatus_SerialManager_Success == status)
\r
906 status = Serial_UsbCdcVirtualInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
907 SerialManager_TxCallback, handle);
\r
908 if (kStatus_SerialManager_Success == status)
\r
910 status = Serial_UsbCdcVirtualInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
\r
911 SerialManager_RxCallback, handle);
\r
918 /*MISRA rule 16.4*/
\r
925 serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)
\r
927 serial_manager_handle_t *handle;
\r
929 assert(serialHandle);
\r
931 handle = (serial_manager_handle_t *)serialHandle;
\r
933 if ((handle->openedReadHandleHead != NULL) || (handle->openedWriteHandleCount != 0U))
\r
935 return kStatus_SerialManager_Busy;
\r
938 switch (handle->type)
\r
940 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
941 case kSerialPort_Uart:
\r
942 (void)Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
945 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
946 case kSerialPort_UsbCdc:
\r
947 (void)Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
950 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
951 case kSerialPort_Swo:
\r
952 (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
955 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
956 case kSerialPort_UsbCdcVirtual:
\r
957 Serial_UsbCdcVirtualDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
958 (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
\r
962 /*MISRA rule 16.4*/
\r
965 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
967 #if defined(OSA_USED)
\r
969 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
971 OSA_EventDestroy((osa_event_handle_t)handle->event);
\r
972 OSA_TaskDestroy((osa_task_handle_t)handle->taskId);
\r
979 return kStatus_SerialManager_Success;
\r
982 serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)
\r
984 serial_manager_handle_t *handle;
\r
985 serial_manager_write_handle_t *serialWriteHandle;
\r
987 assert(serialHandle);
\r
988 assert(writeHandle);
\r
989 assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));
\r
991 handle = (serial_manager_handle_t *)serialHandle;
\r
992 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
994 (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
\r
996 handle->openedWriteHandleCount++;
\r
998 serialWriteHandle->serialManagerHandle = handle;
\r
999 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1000 serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;
\r
1003 return kStatus_SerialManager_Success;
\r
1006 serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)
\r
1008 serial_manager_handle_t *handle;
\r
1009 serial_manager_write_handle_t *serialWriteHandle;
\r
1011 assert(writeHandle);
\r
1013 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1014 handle = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;
\r
1017 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1018 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
1021 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1022 (void)SerialManager_CancelWriting(writeHandle);
\r
1025 handle->openedWriteHandleCount--;
\r
1026 (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
\r
1028 return kStatus_SerialManager_Success;
\r
1031 serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)
\r
1033 serial_manager_handle_t *handle;
\r
1034 serial_manager_read_handle_t *serialReadHandle;
\r
1036 assert(serialHandle);
\r
1037 assert(readHandle);
\r
1038 assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));
\r
1040 handle = (serial_manager_handle_t *)serialHandle;
\r
1041 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1043 if (handle->openedReadHandleHead != NULL)
\r
1045 return kStatus_SerialManager_Busy;
\r
1047 (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
\r
1049 handle->openedReadHandleHead = serialReadHandle;
\r
1051 serialReadHandle->serialManagerHandle = handle;
\r
1052 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1053 serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;
\r
1056 return kStatus_SerialManager_Success;
\r
1059 serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)
\r
1061 serial_manager_handle_t *handle;
\r
1062 serial_manager_read_handle_t *serialReadHandle;
\r
1064 assert(readHandle);
\r
1066 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1067 handle = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;
\r
1070 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1071 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
1074 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1075 (void)SerialManager_CancelReading(readHandle);
\r
1078 handle->openedReadHandleHead = NULL;
\r
1079 (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
\r
1081 return kStatus_SerialManager_Success;
\r
1084 serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
\r
1086 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1087 return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);
\r
1089 return SerialManager_Write(writeHandle, buffer, length);
\r
1093 serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
\r
1095 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1096 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);
\r
1098 return SerialManager_Read(readHandle, buffer, length);
\r
1102 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
1103 serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,
\r
1107 return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);
\r
1110 serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
\r
1112 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);
\r
1115 serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)
\r
1117 serial_manager_write_handle_t *serialWriteHandle;
\r
1119 uint8_t isNotUsed = 0;
\r
1121 assert(writeHandle);
\r
1123 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1125 assert(serialWriteHandle->serialManagerHandle);
\r
1126 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
1128 if ((serialWriteHandle->transfer.buffer != NULL) &&
\r
1129 (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))
\r
1131 return kStatus_SerialManager_Error;
\r
1134 primask = DisableGlobalIRQ();
\r
1135 if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(
\r
1136 &serialWriteHandle->serialManagerHandle->runningWriteHandleHead))
\r
1138 (void)LIST_RemoveElement(&serialWriteHandle->link);
\r
1141 EnableGlobalIRQ(primask);
\r
1143 if (isNotUsed != 0U)
\r
1145 serialWriteHandle->transfer.soFar = 0;
\r
1146 serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;
\r
1148 SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);
\r
1149 #if defined(OSA_USED)
\r
1151 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
\r
1152 serialWriteHandle->serialManagerHandle->commontaskMsg.callback = SerialManager_Task;
\r
1153 serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam = serialWriteHandle->serialManagerHandle;
\r
1154 COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);
\r
1156 (void)OSA_EventSet((osa_event_handle_t)serialWriteHandle->serialManagerHandle->event, SERIAL_EVENT_DATA_SENT);
\r
1160 SerialManager_Task(serialWriteHandle->serialManagerHandle);
\r
1165 switch (serialWriteHandle->serialManagerHandle->type)
\r
1167 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
1168 case kSerialPort_Uart:
\r
1169 (void)Serial_UartCancelWrite(
\r
1170 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1173 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
1174 case kSerialPort_UsbCdc:
\r
1175 (void)Serial_UsbCdcCancelWrite(
\r
1176 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1179 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
1180 case kSerialPort_Swo:
\r
1181 (void)Serial_SwoCancelWrite(
\r
1182 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1185 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
1186 case kSerialPort_UsbCdcVirtual:
\r
1187 Serial_UsbCdcVirtualCancelWrite(
\r
1188 (void)Serial_SwoCancelWrite(
\r
1189 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
\r
1193 /*MISRA rule 16.4*/
\r
1198 (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);
\r
1200 return kStatus_SerialManager_Success;
\r
1203 serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)
\r
1205 serial_manager_read_handle_t *serialReadHandle;
\r
1206 serial_manager_callback_message_t msg;
\r
1210 assert(readHandle);
\r
1212 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1214 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
1216 if ((serialReadHandle->transfer.buffer != NULL) &&
\r
1217 (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))
\r
1219 return kStatus_SerialManager_Error;
\r
1222 primask = DisableGlobalIRQ();
\r
1223 buffer = serialReadHandle->transfer.buffer;
\r
1224 serialReadHandle->transfer.buffer = NULL;
\r
1225 serialReadHandle->transfer.length = 0;
\r
1226 msg.buffer = buffer;
\r
1227 msg.length = serialReadHandle->transfer.soFar;
\r
1228 EnableGlobalIRQ(primask);
\r
1230 if (buffer != NULL)
\r
1232 if (serialReadHandle->callback != NULL)
\r
1234 serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);
\r
1237 return kStatus_SerialManager_Success;
\r
1240 serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,
\r
1243 uint32_t *receivedLength)
\r
1245 assert(receivedLength);
\r
1247 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);
\r
1250 serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,
\r
1251 serial_manager_callback_t callback,
\r
1252 void *callbackParam)
\r
1254 serial_manager_write_handle_t *serialWriteHandle;
\r
1256 assert(writeHandle);
\r
1258 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
\r
1260 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
\r
1262 serialWriteHandle->callbackParam = callbackParam;
\r
1263 serialWriteHandle->callback = callback;
\r
1265 return kStatus_SerialManager_Success;
\r
1268 serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,
\r
1269 serial_manager_callback_t callback,
\r
1270 void *callbackParam)
\r
1272 serial_manager_read_handle_t *serialReadHandle;
\r
1274 assert(readHandle);
\r
1276 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
\r
1278 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
\r
1280 serialReadHandle->callbackParam = callbackParam;
\r
1281 serialReadHandle->callback = callback;
\r
1283 return kStatus_SerialManager_Success;
\r
1287 serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)
\r
1289 assert(serialHandle);
\r
1291 return kStatus_SerialManager_Success;
\r
1294 serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)
\r
1296 assert(serialHandle);
\r
1298 return kStatus_SerialManager_Success;
\r