1/*
2 * Copyright 2018-2020 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9#include <string.h>
10
11#include "fsl_component_serial_manager.h"
12#include "fsl_component_serial_port_internal.h"
13#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
14
15#include "fsl_component_generic_list.h"
16
17/*
18 * The OSA_USED macro can only be defined when the OSA component is used.
19 * If the source code of the OSA component does not exist, the OSA_USED cannot be defined.
20 * OR, If OSA component is not added into project event the OSA source code exists, the OSA_USED
21 * also cannot be defined.
22 * The source code path of the OSA component is <MCUXpresso_SDK>/components/osa.
23 *
24 */
25#if defined(OSA_USED)
26
27#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
28#include "fsl_component_common_task.h"
29#else
30#include "fsl_os_abstraction.h"
31#endif
32
33#endif
34
35#endif
36
37/*******************************************************************************
38 * Definitions
39 ******************************************************************************/
40
41#ifndef NDEBUG
42#if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
43#undef assert
44#define assert(n)
45#else
46/* MISRA C-2012 Rule 17.2 */
47#undef assert
48#define assert(n) \
49 while (!(n)) \
50 { \
51 ; \
52 }
53#endif
54#endif
55
56/* Weak function. */
57#if defined(__GNUC__)
58#define __WEAK_FUNC __attribute__((weak))
59#elif defined(__ICCARM__)
60#define __WEAK_FUNC __weak
61#elif defined(__CC_ARM) || defined(__ARMCC_VERSION)
62#define __WEAK_FUNC __attribute__((weak))
63#elif defined(__DSC__) || defined(__CW__)
64#define __WEAK_FUNC __attribute__((weak))
65#endif
66
67#define SERIAL_EVENT_DATA_RECEIVED (0U)
68#define SERIAL_EVENT_DATA_SENT (1U)
69#define SERIAL_EVENT_DATA_START_SEND (2U)
70#define SERIAL_EVENT_DATA_RX_NOTIFY (3U)
71#define SERIAL_EVENT_DATA_NUMBER (4U)
72
73#define SERIAL_MANAGER_WRITE_TAG 0xAABB5754U
74#define SERIAL_MANAGER_READ_TAG 0xBBAA5244U
75
76#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
77typedef enum _serial_manager_transmission_mode
78{
79 kSerialManager_TransmissionBlocking = 0x0U, /*!< Blocking transmission*/
80 kSerialManager_TransmissionNonBlocking = 0x1U, /*!< None blocking transmission*/
81} serial_manager_transmission_mode_t;
82
83/* TX transfer structure */
84typedef struct _serial_manager_transfer
85{
86 uint8_t *buffer;
87 volatile uint32_t length;
88 volatile uint32_t soFar;
89 serial_manager_transmission_mode_t mode;
90 serial_manager_status_t status;
91} serial_manager_transfer_t;
92#endif
93
94/* write handle structure */
95typedef struct _serial_manager_send_handle
96{
97#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
98 list_element_t link; /*!< list element of the link */
99 serial_manager_transfer_t transfer;
100#endif
101 struct _serial_manager_handle *serialManagerHandle;
102#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
103 serial_manager_callback_t callback;
104 void *callbackParam;
105 uint32_t tag;
106#endif
107} serial_manager_write_handle_t;
108typedef struct _serial_manager_send_block_handle
109{
110 struct _serial_manager_handle *serialManagerHandle;
111
112} serial_manager_write_block_handle_t;
113
114typedef serial_manager_write_handle_t serial_manager_read_handle_t;
115typedef serial_manager_write_block_handle_t serial_manager_read_block_handle_t;
116
117#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
118/* receive state structure */
119typedef struct _serial_manager_read_ring_buffer
120{
121 uint8_t *ringBuffer;
122 uint32_t ringBufferSize;
123 volatile uint32_t ringHead;
124 volatile uint32_t ringTail;
125} serial_manager_read_ring_buffer_t;
126
127#if defined(__CC_ARM)
128#pragma anon_unions
129#endif
130typedef struct _serial_manager_block_handle
131{
132 serial_manager_type_t handleType;
133 serial_port_type_t type;
134 serial_manager_read_handle_t *volatile openedReadHandleHead;
135 volatile uint32_t openedWriteHandleCount;
136 union
137 {
138 uint32_t lowLevelhandleBuffer[1];
139#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
140 uint8_t uartHandleBuffer[SERIAL_PORT_UART_BLOCK_HANDLE_SIZE];
141#endif
142 };
143
144} serial_manager_block_handle_t;
145#endif
146
147/* The serial manager handle structure */
148typedef struct _serial_manager_handle
149{
150#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
151 serial_manager_type_t handleType;
152#endif
153 serial_port_type_t type;
154 serial_manager_read_handle_t *volatile openedReadHandleHead;
155 volatile uint32_t openedWriteHandleCount;
156 union
157 {
158 uint32_t lowLevelhandleBuffer[1];
159#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
160 uint8_t uartHandleBuffer[SERIAL_PORT_UART_HANDLE_SIZE];
161#endif
162#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
163 uint8_t uartDmaHandleBuffer[SERIAL_PORT_UART_DMA_HANDLE_SIZE];
164#endif
165#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
166 uint8_t usbcdcHandleBuffer[SERIAL_PORT_USB_CDC_HANDLE_SIZE];
167#endif
168#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
169 uint8_t swoHandleBuffer[SERIAL_PORT_SWO_HANDLE_SIZE];
170#endif
171#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
172 uint8_t usbcdcVirtualHandleBuffer[SERIAL_PORT_VIRTUAL_HANDLE_SIZE];
173#endif
174#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
175 uint8_t rpmsgHandleBuffer[SERIAL_PORT_RPMSG_HANDLE_SIZE];
176#endif
177#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
178 uint8_t spiMasterHandleBuffer[SERIAL_PORT_SPI_MASTER_HANDLE_SIZE];
179#endif
180#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
181 uint8_t spiSlaveHandleBuffer[SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE];
182#endif
183 };
184#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
185 serial_manager_read_ring_buffer_t ringBuffer;
186#endif
187
188#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
189
190#if defined(OSA_USED)
191
192#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
193 common_task_message_t commontaskMsg;
194#else
195 OSA_SEMAPHORE_HANDLE_DEFINE(serSemaphore); /*!< Semaphore instance */
196 OSA_TASK_HANDLE_DEFINE(taskId); /*!< Task handle */
197#endif
198 uint8_t serialManagerState[SERIAL_EVENT_DATA_NUMBER]; /*!< Used to indicate the serial mnager state */
199
200#endif
201
202#endif
203#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
204 list_label_t runningWriteHandleHead; /*!< The queue of running write handle */
205 list_label_t completedWriteHandleHead; /*!< The queue of completed write handle */
206#endif
207
208} serial_manager_handle_t;
209
210/*******************************************************************************
211 * Prototypes
212 ******************************************************************************/
213
214#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
215static void SerialManager_Task(void *param);
216#endif
217
218/*******************************************************************************
219 * Variables
220 ******************************************************************************/
221
222#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
223
224#if defined(OSA_USED)
225
226#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
227
228#else
229 /*
230 * \brief Defines the serial manager task's stack
231 */
232static OSA_TASK_DEFINE(SerialManager_Task, SERIAL_MANAGER_TASK_PRIORITY, 1, SERIAL_MANAGER_TASK_STACK_SIZE, false);
233#endif
234
235#endif
236
237#endif
238
239/*******************************************************************************
240 * Code
241 ******************************************************************************/
242
243#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
244static void SerialManager_AddTail(list_label_t *queue, serial_manager_write_handle_t *node)
245{
246 (void)LIST_AddTail(queue, &node->link);
247}
248
249static void SerialManager_RemoveHead(list_label_t *queue)
250{
251 (void)LIST_RemoveHead(queue);
252}
253#endif
254
255#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
256
257static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle)
258{
259 serial_manager_status_t status = kStatus_SerialManager_Error;
260 serial_manager_write_handle_t *writeHandle =
261 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);
262
263 if (writeHandle != NULL)
264 {
265 switch (handle->type)
266 {
267#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
268 case kSerialPort_Uart:
269 status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
270 writeHandle->transfer.buffer, writeHandle->transfer.length);
271 break;
272#endif
273#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
274 case kSerialPort_UartDma:
275 status = Serial_UartDmaWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
276 writeHandle->transfer.buffer, writeHandle->transfer.length);
277 break;
278#endif
279#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
280 case kSerialPort_UsbCdc:
281 status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
282 writeHandle->transfer.buffer, writeHandle->transfer.length);
283 break;
284#endif
285#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
286 case kSerialPort_Swo:
287 status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
288 writeHandle->transfer.buffer, writeHandle->transfer.length);
289 break;
290#endif
291#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
292 case kSerialPort_Virtual:
293 status = Serial_PortVirtualWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
294 writeHandle->transfer.buffer, writeHandle->transfer.length);
295 break;
296#endif
297#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
298 case kSerialPort_Rpmsg:
299 status = Serial_RpmsgWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
300 writeHandle->transfer.buffer, writeHandle->transfer.length);
301 break;
302#endif
303#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
304 case kSerialPort_SpiMaster:
305 status = Serial_SpiMasterWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
306 writeHandle->transfer.buffer, writeHandle->transfer.length);
307 break;
308#endif
309#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
310 case kSerialPort_SpiSlave:
311 status = Serial_SpiSlaveWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
312 writeHandle->transfer.buffer, writeHandle->transfer.length);
313 break;
314#endif
315
316 default:
317 status = kStatus_SerialManager_Error;
318 break;
319 }
320 }
321 return status;
322}
323
324static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,
325 serial_manager_read_handle_t *readHandle,
326 uint8_t *buffer,
327 uint32_t length)
328{
329 serial_manager_status_t status = kStatus_SerialManager_Error;
330
331 if (NULL != readHandle)
332 {
333#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
334 if (kSerialPort_Uart == handle->type) /* Serial port UART */
335 {
336 status = Serial_UartRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
337 }
338#endif
339#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
340 if (handle->type == kSerialPort_UsbCdc)
341 {
342 status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
343 }
344#endif
345#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
346 if (handle->type == kSerialPort_Virtual)
347 {
348 status = Serial_PortVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
349 }
350#endif
351#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
352 if (handle->type == kSerialPort_SpiMaster)
353 {
354 status = Serial_SpiMasterRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
355 }
356#endif
357#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
358 if (handle->type == kSerialPort_SpiSlave)
359 {
360 status = Serial_SpiSlaveRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
361 }
362#endif
363
364#if 0
365#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
366 if (handle->type == kSerialPort_Rpmsg)
367 {
368 status = Serial_RpmsgRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
369 }
370#endif
371#endif
372 }
373 return status;
374}
375
376#else /*SERIAL_MANAGER_NON_BLOCKING_MODE > 0U*/
377
378static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *handle,
379 serial_manager_write_handle_t *writeHandle,
380 uint8_t *buffer,
381 uint32_t length)
382{
383 serial_manager_status_t status = kStatus_SerialManager_Error;
384
385#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
386 if (kSerialPort_Uart == handle->type) /* Serial port UART */
387 {
388 status = Serial_UartWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
389 }
390 else
391#endif
392#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
393 if (kSerialPort_UsbCdc == handle->type) /* Serial port UsbCdc */
394 {
395 status = Serial_UsbCdcWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
396 }
397 else
398#endif
399#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
400 if (kSerialPort_Swo == handle->type) /* Serial port SWO */
401 {
402 status = Serial_SwoWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
403 }
404 else
405#endif
406#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
407 if (kSerialPort_Virtual == handle->type) /* Serial port UsbCdcVirtual */
408 {
409 status = Serial_PortVirtualWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
410 }
411 else
412#endif
413#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
414 if (kSerialPort_Rpmsg == handle->type) /* Serial port Rpmsg */
415 {
416 status = Serial_RpmsgWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
417 }
418 else
419#endif
420#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
421 if (kSerialPort_SpiMaster == handle->type) /* Serial port Spi Master */
422 {
423 status = Serial_SpiMasterWrite(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
424 }
425 else
426#endif
427 {
428 /*MISRA rule*/
429 }
430 return status;
431}
432
433static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *handle,
434 serial_manager_read_handle_t *readHandle,
435 uint8_t *buffer,
436 uint32_t length)
437{
438 serial_manager_status_t status = kStatus_SerialManager_Error;
439
440#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
441 if (kSerialPort_Uart == handle->type) /* Serial port UART */
442 {
443 status = Serial_UartRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
444 }
445 else
446#endif
447#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
448 if (kSerialPort_UsbCdc == handle->type) /* Serial port UsbCdc */
449 {
450 status = Serial_UsbCdcRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
451 }
452 else
453#endif
454#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
455 if (kSerialPort_Swo == handle->type) /* Serial port SWO */
456 {
457 status = Serial_SwoRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
458 }
459 else
460#endif
461#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
462 if (kSerialPort_Virtual == handle->type) /* Serial port UsbCdcVirtual */
463 {
464 status = Serial_PortVirtualRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
465 }
466 else
467#endif
468#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
469 if (kSerialPort_Rpmsg == handle->type) /* Serial port UsbCdcVirtual */
470 {
471 status = Serial_RpmsgRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
472 }
473 else
474#endif
475#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
476 if (kSerialPort_SpiMaster == handle->type) /* Serial port Spi Master */
477 {
478 status = Serial_SpiMasterRead(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), buffer, length);
479 }
480 else
481#endif
482 {
483 /*MISRA rule*/
484 }
485 return status;
486}
487#endif /*SERIAL_MANAGER_NON_BLOCKING_MODE > 0U*/
488
489#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
490static void SerialManager_IsrFunction(serial_manager_handle_t *handle)
491{
492 uint32_t regPrimask = DisableGlobalIRQ();
493 switch (handle->type)
494 {
495#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
496 case kSerialPort_Uart:
497 Serial_UartIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
498 break;
499#endif
500#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
501 case kSerialPort_UsbCdc:
502 Serial_UsbCdcIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
503 break;
504#endif
505#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
506 case kSerialPort_Swo:
507 Serial_SwoIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
508 break;
509#endif
510#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
511 case kSerialPort_Virtual:
512 Serial_PortVirtualIsrFunction(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
513 break;
514#endif
515 default:
516 /*MISRA rule 16.4*/
517 break;
518 }
519 EnableGlobalIRQ(regPrimask);
520}
521
522static void SerialManager_Task(void *param)
523{
524 serial_manager_handle_t *handle = (serial_manager_handle_t *)param;
525 serial_manager_write_handle_t *serialWriteHandle;
526 serial_manager_read_handle_t *serialReadHandle;
527 uint32_t primask;
528 serial_manager_callback_message_t msg;
529#if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
530 uint32_t ringBufferLength;
531#endif /* SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
532
533 if (NULL != handle)
534 {
535#if defined(OSA_USED)
536
537#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
538#else
539
540 do
541 {
542 if (KOSA_StatusSuccess == OSA_SemaphoreWait((osa_semaphore_handle_t)handle->serSemaphore, osaWaitForever_c))
543 {
544#endif
545#endif
546#if defined(OSA_USED)
547
548#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
549#else
550 primask = DisableGlobalIRQ();
551 uint8_t *ev = handle->serialManagerState;
552 EnableGlobalIRQ(primask);
553 if (0U != (ev[SERIAL_EVENT_DATA_START_SEND]))
554#endif
555#endif
556 {
557 (void)SerialManager_StartWriting(handle);
558#if defined(OSA_USED)
559#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
560#else
561 primask = DisableGlobalIRQ();
562 handle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]--;
563 EnableGlobalIRQ(primask);
564#endif
565#endif
566 }
567#if defined(OSA_USED)
568
569#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
570#else
571 if (0U != (ev[SERIAL_EVENT_DATA_SENT]))
572#endif
573
574#endif
575 {
576 serialWriteHandle =
577 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);
578 while (NULL != serialWriteHandle)
579 {
580 SerialManager_RemoveHead(&handle->completedWriteHandleHead);
581 msg.buffer = serialWriteHandle->transfer.buffer;
582 msg.length = serialWriteHandle->transfer.soFar;
583 serialWriteHandle->transfer.buffer = NULL;
584 if (NULL != serialWriteHandle->callback)
585 {
586 serialWriteHandle->callback(serialWriteHandle->callbackParam, &msg,
587 serialWriteHandle->transfer.status);
588 }
589 serialWriteHandle =
590 (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->completedWriteHandleHead);
591 }
592#if defined(OSA_USED)
593#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
594#else
595 primask = DisableGlobalIRQ();
596 handle->serialManagerState[SERIAL_EVENT_DATA_SENT]--;
597 EnableGlobalIRQ(primask);
598#endif
599#endif
600 }
601#if defined(OSA_USED)
602
603#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
604#else
605 if (0U != (ev[SERIAL_EVENT_DATA_RECEIVED]))
606#endif
607
608#endif
609 {
610 primask = DisableGlobalIRQ();
611 serialReadHandle = handle->openedReadHandleHead;
612 EnableGlobalIRQ(primask);
613
614 if (NULL != serialReadHandle)
615 {
616 if (NULL != serialReadHandle->transfer.buffer)
617 {
618 if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
619 {
620 msg.buffer = serialReadHandle->transfer.buffer;
621 msg.length = serialReadHandle->transfer.soFar;
622 serialReadHandle->transfer.buffer = NULL;
623 if (NULL != serialReadHandle->callback)
624 {
625 serialReadHandle->callback(serialReadHandle->callbackParam, &msg,
626 serialReadHandle->transfer.status);
627 }
628 }
629 }
630 }
631#if defined(OSA_USED)
632#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
633#else
634 primask = DisableGlobalIRQ();
635 handle->serialManagerState[SERIAL_EVENT_DATA_RECEIVED]--;
636 EnableGlobalIRQ(primask);
637#endif
638#endif
639 }
640
641#if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
642#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
643#else
644 if (0U != (ev[SERIAL_EVENT_DATA_RX_NOTIFY]))
645#endif
646 {
647 ringBufferLength =
648 handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
649 ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;
650 /* Notify there are data in ringbuffer */
651 if (0U != ringBufferLength)
652 {
653 msg.buffer = NULL;
654 msg.length = ringBufferLength;
655 if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))
656 {
657 handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, &msg,
658 kStatus_SerialManager_Notify);
659 }
660 }
661 primask = DisableGlobalIRQ();
662 handle->serialManagerState[SERIAL_EVENT_DATA_RX_NOTIFY]--;
663 EnableGlobalIRQ(primask);
664 }
665#endif /* SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
666
667#if defined(OSA_USED)
668
669#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
670#else
671 }
672 } while (0U != gUseRtos_c);
673#endif
674
675#endif
676 }
677}
678#endif
679
680#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
681static void SerialManager_TxCallback(void *callbackParam,
682 serial_manager_callback_message_t *message,
683 serial_manager_status_t status)
684{
685 serial_manager_handle_t *handle;
686 serial_manager_write_handle_t *writeHandle;
687#if (defined(OSA_USED))
688#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
689 /* Need to support common_task. */
690#else /* SERIAL_MANAGER_USE_COMMON_TASK */
691 uint32_t primask;
692#endif
693#endif
694 assert(NULL != callbackParam);
695 assert(NULL != message);
696
697 handle = (serial_manager_handle_t *)callbackParam;
698
699 writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&handle->runningWriteHandleHead);
700
701 if (NULL != writeHandle)
702 {
703 SerialManager_RemoveHead(&handle->runningWriteHandleHead);
704
705#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
706#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
707 /* Need to support common_task. */
708#else /* SERIAL_MANAGER_USE_COMMON_TASK */
709 primask = DisableGlobalIRQ();
710 handle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]++;
711 EnableGlobalIRQ(primask);
712 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
713
714#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
715#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
716 (void)SerialManager_StartWriting(handle);
717#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
718
719 writeHandle->transfer.soFar = message->length;
720 writeHandle->transfer.status = status;
721 if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)
722 {
723 SerialManager_AddTail(&handle->completedWriteHandleHead, writeHandle);
724#if defined(OSA_USED)
725
726#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
727 handle->commontaskMsg.callback = SerialManager_Task;
728 handle->commontaskMsg.callbackParam = handle;
729 COMMON_TASK_post_message(&handle->commontaskMsg);
730#else
731 primask = DisableGlobalIRQ();
732 handle->serialManagerState[SERIAL_EVENT_DATA_SENT]++;
733 EnableGlobalIRQ(primask);
734 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
735#endif
736
737#else
738 SerialManager_Task(handle);
739#endif
740 }
741 else
742 {
743 writeHandle->transfer.buffer = NULL;
744 }
745 }
746}
747
748void SerialManager_RxCallback(void *callbackParam,
749 serial_manager_callback_message_t *message,
750 serial_manager_status_t status);
751void SerialManager_RxCallback(void *callbackParam,
752 serial_manager_callback_message_t *message,
753 serial_manager_status_t status)
754{
755 serial_manager_handle_t *handle;
756#if (!((defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))) && \
757 !((defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))))
758 uint32_t ringBufferLength = 0;
759 uint32_t primask;
760#endif
761 assert(NULL != callbackParam);
762 assert(NULL != message);
763
764 handle = (serial_manager_handle_t *)callbackParam;
765#if ((defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U)) || \
766 (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U)))
767 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;
768 handle->openedReadHandleHead->transfer.soFar = message->length;
769 handle->openedReadHandleHead->transfer.length = message->length;
770 handle->openedReadHandleHead->transfer.buffer = message->buffer;
771#if defined(OSA_USED)
772
773#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
774 handle->commontaskMsg.callback = SerialManager_Task;
775 handle->commontaskMsg.callbackParam = handle;
776 COMMON_TASK_post_message(&handle->commontaskMsg);
777#else
778 primask = DisableGlobalIRQ();
779 handle->serialManagerState[SERIAL_EVENT_DATA_RECEIVED]++;
780 EnableGlobalIRQ(primask);
781 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
782#endif
783
784#else
785 SerialManager_Task(handle);
786#endif
787#else
788 status = kStatus_SerialManager_Notify;
789
790 primask = DisableGlobalIRQ();
791
792 /* If wrap around is expected copy byte one after the other. Note that this could also be done with 2 memcopy for
793 * better efficiency. */
794 if (handle->ringBuffer.ringHead + message->length >= handle->ringBuffer.ringBufferSize)
795 {
796 for (uint32_t i = 0; i < message->length; i++)
797 {
798 handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead++] = message->buffer[i];
799#if (defined(SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL) && (SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL > 0U))
800 if ((handle->ringBuffer.ringHead - handle->ringBuffer.ringTail) >= handle->ringBuffer.ringBufferSize)
801 {
802 status = kStatus_SerialManager_RingBufferOverflow;
803 break;
804 }
805#else
806 if (handle->ringBuffer.ringHead >= handle->ringBuffer.ringBufferSize)
807 {
808 handle->ringBuffer.ringHead = 0U;
809 }
810 if (handle->ringBuffer.ringHead == handle->ringBuffer.ringTail)
811 {
812 status = kStatus_SerialManager_RingBufferOverflow;
813 handle->ringBuffer.ringTail++;
814 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
815 {
816 handle->ringBuffer.ringTail = 0U;
817 }
818 }
819#endif
820 }
821 }
822 else /*No wrap is expected so do a memcpy*/
823 {
824 (void)memcpy(&handle->ringBuffer.ringBuffer[handle->ringBuffer.ringHead], message->buffer, message->length);
825 handle->ringBuffer.ringHead += message->length;
826 }
827
828 ringBufferLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
829 ringBufferLength = ringBufferLength % handle->ringBuffer.ringBufferSize;
830
831 if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->transfer.buffer))
832 {
833 if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)
834 {
835 uint32_t remainLength =
836 handle->openedReadHandleHead->transfer.length - handle->openedReadHandleHead->transfer.soFar;
837 for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)
838 {
839 handle->openedReadHandleHead->transfer.buffer[handle->openedReadHandleHead->transfer.soFar] =
840 handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
841 handle->ringBuffer.ringTail++;
842 handle->openedReadHandleHead->transfer.soFar++;
843 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
844 {
845 handle->ringBuffer.ringTail = 0U;
846 }
847 }
848 ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);
849 }
850
851 if (handle->openedReadHandleHead->transfer.length > handle->openedReadHandleHead->transfer.soFar)
852 {
853 }
854 else
855 {
856 if (kSerialManager_TransmissionBlocking == handle->openedReadHandleHead->transfer.mode)
857 {
858 handle->openedReadHandleHead->transfer.buffer = NULL;
859 }
860 else
861 {
862 handle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;
863
864#if defined(OSA_USED)
865
866#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
867 handle->commontaskMsg.callback = SerialManager_Task;
868 handle->commontaskMsg.callbackParam = handle;
869 COMMON_TASK_post_message(&handle->commontaskMsg);
870#else
871 primask = DisableGlobalIRQ();
872 handle->serialManagerState[SERIAL_EVENT_DATA_RECEIVED]++;
873 EnableGlobalIRQ(primask);
874 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
875#endif
876
877#else
878 SerialManager_Task(handle);
879#endif
880 }
881 }
882 }
883#if (defined(SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL) && (SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL > 0U))
884 if (status != kStatus_SerialManager_RingBufferOverflow)
885 {
886 (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);
887 }
888#else
889 (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);
890#endif
891 if (0U != ringBufferLength)
892 {
893#if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
894 primask = DisableGlobalIRQ();
895 handle->serialManagerState[SERIAL_EVENT_DATA_RX_NOTIFY]++;
896 EnableGlobalIRQ(primask);
897 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
898
899 (void)status; /* Fix "set but never used" warning. */
900#else /* !SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
901 message->buffer = NULL;
902 message->length = ringBufferLength;
903 if ((NULL != handle->openedReadHandleHead) && (NULL != handle->openedReadHandleHead->callback))
904 {
905 handle->openedReadHandleHead->callback(handle->openedReadHandleHead->callbackParam, message, status);
906 }
907#endif /* SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
908 }
909
910#if (!((defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))) && \
911 !((defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))))
912 if (kSerialManager_Blocking ==
913 handle->handleType) /* No need to check for (NULL != handle->openedReadHandleHead) condition as it is already
914 done in SerialManager_StartReading() */
915#else
916 if (NULL != handle->openedReadHandleHead)
917#endif
918 {
919 ringBufferLength = handle->ringBuffer.ringBufferSize - 1U - ringBufferLength;
920 (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, ringBufferLength);
921 }
922 EnableGlobalIRQ(primask);
923#endif
924}
925
926/*
927 * This function is used for perdiodic check if the transfer is complete, and will be called in blocking transfer at
928 * non-blocking mode. The perdiodic unit is ms and default value is define by
929 * SERIAL_MANAGER_WRITE_TIME_DELAY_DEFAULT_VALUE/SERIAL_MANAGER_READ_TIME_DELAY_DEFAULT_VALUE. The function
930 * SerialManager_WriteTimeDelay()/SerialManager_ReadTimeDelay() is a weak function, so it could be re-implemented by
931 * upper layer.
932 */
933__WEAK_FUNC void SerialManager_WriteTimeDelay(uint32_t ms);
934__WEAK_FUNC void SerialManager_WriteTimeDelay(uint32_t ms)
935{
936#if defined(OSA_USED)
937 OSA_TimeDelay(ms);
938#endif
939}
940
941__WEAK_FUNC void SerialManager_ReadTimeDelay(uint32_t ms);
942__WEAK_FUNC void SerialManager_ReadTimeDelay(uint32_t ms)
943{
944#if defined(OSA_USED)
945 OSA_TimeDelay(ms);
946#endif
947}
948
949static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,
950 uint8_t *buffer,
951 uint32_t length,
952 serial_manager_transmission_mode_t mode)
953{
954 serial_manager_write_handle_t *serialWriteHandle;
955 serial_manager_handle_t *handle;
956
957#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
958#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
959 /* Need to support common_task. */
960#else /* SERIAL_MANAGER_USE_COMMON_TASK */
961 /* Do nothing. */
962#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
963#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
964 serial_manager_status_t status = kStatus_SerialManager_Success;
965#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
966
967 uint32_t primask;
968 uint8_t isEmpty = 0U;
969
970 assert(NULL != writeHandle);
971 assert(NULL != buffer);
972 assert(length > 0U);
973
974 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
975 handle = serialWriteHandle->serialManagerHandle;
976 assert(NULL != handle);
977
978 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
979 assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));
980
981 primask = DisableGlobalIRQ();
982 if (NULL != serialWriteHandle->transfer.buffer)
983 {
984 EnableGlobalIRQ(primask);
985 return kStatus_SerialManager_Busy;
986 }
987 serialWriteHandle->transfer.buffer = buffer;
988 serialWriteHandle->transfer.length = length;
989 serialWriteHandle->transfer.soFar = 0U;
990 serialWriteHandle->transfer.mode = mode;
991
992 if (NULL == LIST_GetHead(&handle->runningWriteHandleHead))
993 {
994 isEmpty = 1U;
995 }
996 SerialManager_AddTail(&handle->runningWriteHandleHead, serialWriteHandle);
997 EnableGlobalIRQ(primask);
998
999 if (0U != isEmpty)
1000 {
1001#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
1002#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
1003 /* Need to support common_task. */
1004#else /* SERIAL_MANAGER_USE_COMMON_TASK */
1005 primask = DisableGlobalIRQ();
1006 handle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]++;
1007 EnableGlobalIRQ(primask);
1008 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
1009
1010#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
1011#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
1012 status = SerialManager_StartWriting(handle);
1013 if ((serial_manager_status_t)kStatus_SerialManager_Success != status)
1014 {
1015#if (defined(USB_CDC_SERIAL_MANAGER_RUN_NO_HOST) && (USB_CDC_SERIAL_MANAGER_RUN_NO_HOST == 1))
1016 if (status == kStatus_SerialManager_NotConnected)
1017 {
1018 SerialManager_RemoveHead(&handle->runningWriteHandleHead);
1019 serialWriteHandle->transfer.buffer = 0U;
1020 serialWriteHandle->transfer.length = 0U;
1021 }
1022#endif /* USB_CDC_SERIAL_MANAGER_RUN_NO_HOST == 1 */
1023 return status;
1024 }
1025#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
1026 }
1027
1028 if (kSerialManager_TransmissionBlocking == mode)
1029 {
1030 while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)
1031 {
1032 if (SerialManager_needPollingIsr())
1033 {
1034 SerialManager_IsrFunction(handle);
1035 }
1036 else
1037 {
1038 SerialManager_WriteTimeDelay(SERIAL_MANAGER_WRITE_TIME_DELAY_DEFAULT_VALUE);
1039 }
1040 }
1041 }
1042 return kStatus_SerialManager_Success;
1043}
1044
1045static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,
1046 uint8_t *buffer,
1047 uint32_t length,
1048 serial_manager_transmission_mode_t mode,
1049 uint32_t *receivedLength)
1050{
1051 serial_manager_read_handle_t *serialReadHandle;
1052 serial_manager_handle_t *handle;
1053 uint32_t dataLength;
1054 uint32_t primask;
1055
1056 assert(NULL != readHandle);
1057 assert(NULL != buffer);
1058 assert(length > 0U);
1059
1060 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1061
1062 handle = serialReadHandle->serialManagerHandle;
1063 assert(NULL != handle);
1064
1065 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
1066 assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));
1067
1068 primask = DisableGlobalIRQ();
1069 if (NULL != serialReadHandle->transfer.buffer)
1070 {
1071 EnableGlobalIRQ(primask);
1072 return kStatus_SerialManager_Busy;
1073 }
1074 serialReadHandle->transfer.buffer = buffer;
1075 serialReadHandle->transfer.length = length;
1076 serialReadHandle->transfer.soFar = 0U;
1077 serialReadHandle->transfer.mode = mode;
1078
1079 /* This code is reached if (handle->handleType != kSerialManager_Blocking)*/
1080#if (!((defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))) && \
1081 !((defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))))
1082 if (length == 1U)
1083 {
1084 if (handle->ringBuffer.ringHead != handle->ringBuffer.ringTail)
1085 {
1086 buffer[serialReadHandle->transfer.soFar++] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
1087 handle->ringBuffer.ringTail++;
1088 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
1089 {
1090 handle->ringBuffer.ringTail = 0U;
1091 }
1092 }
1093 }
1094 else
1095#endif /*(!defined(SERIAL_PORT_TYPE_USBCDC) && !defined(SERIAL_PORT_TYPE_VIRTUAL))*/
1096 {
1097 dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
1098 dataLength = dataLength % handle->ringBuffer.ringBufferSize;
1099
1100 for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);
1101 serialReadHandle->transfer.soFar++)
1102 {
1103 buffer[serialReadHandle->transfer.soFar] = handle->ringBuffer.ringBuffer[handle->ringBuffer.ringTail];
1104 handle->ringBuffer.ringTail++;
1105 if (handle->ringBuffer.ringTail >= handle->ringBuffer.ringBufferSize)
1106 {
1107 handle->ringBuffer.ringTail = 0U;
1108 }
1109 }
1110
1111 dataLength = handle->ringBuffer.ringHead + handle->ringBuffer.ringBufferSize - handle->ringBuffer.ringTail;
1112 dataLength = dataLength % handle->ringBuffer.ringBufferSize;
1113 dataLength = handle->ringBuffer.ringBufferSize - 1U - dataLength;
1114
1115 (void)SerialManager_StartReading(handle, readHandle, NULL, dataLength);
1116 }
1117
1118 if (NULL != receivedLength)
1119 {
1120 *receivedLength = serialReadHandle->transfer.soFar;
1121 serialReadHandle->transfer.buffer = NULL;
1122 EnableGlobalIRQ(primask);
1123 }
1124 else
1125 {
1126 if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
1127 {
1128 serialReadHandle->transfer.buffer = NULL;
1129 EnableGlobalIRQ(primask);
1130 if (kSerialManager_TransmissionNonBlocking == mode)
1131 {
1132 if (NULL != serialReadHandle->callback)
1133 {
1134 serial_manager_callback_message_t msg;
1135 msg.buffer = buffer;
1136 msg.length = serialReadHandle->transfer.soFar;
1137 serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Success);
1138 }
1139 }
1140 }
1141 else
1142 {
1143 EnableGlobalIRQ(primask);
1144 }
1145
1146 if (kSerialManager_TransmissionBlocking == mode)
1147 {
1148 while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)
1149 {
1150 SerialManager_ReadTimeDelay(SERIAL_MANAGER_READ_TIME_DELAY_DEFAULT_VALUE);
1151 }
1152 }
1153 }
1154#if (defined(SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL) && (SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL > 0U))
1155 if ((handle->ringBuffer.ringHead - handle->ringBuffer.ringTail) < handle->ringBuffer.ringBufferSize)
1156 {
1157 (void)SerialManager_StartReading(handle, handle->openedReadHandleHead, NULL, serialReadHandle->transfer.length);
1158 }
1159#endif
1160 return kStatus_SerialManager_Success;
1161}
1162
1163#else
1164
1165static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
1166{
1167 serial_manager_write_handle_t *serialWriteHandle;
1168 serial_manager_handle_t *handle;
1169
1170 assert(writeHandle);
1171 assert(buffer);
1172 assert(length);
1173
1174 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
1175 handle = serialWriteHandle->serialManagerHandle;
1176
1177 assert(handle);
1178
1179 return SerialManager_StartWriting(handle, serialWriteHandle, buffer, length);
1180}
1181
1182static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
1183{
1184 serial_manager_read_handle_t *serialReadHandle;
1185 serial_manager_handle_t *handle;
1186
1187 assert(readHandle);
1188 assert(buffer);
1189 assert(length);
1190
1191 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1192 handle = serialReadHandle->serialManagerHandle;
1193
1194 assert(handle);
1195
1196 return SerialManager_StartReading(handle, serialReadHandle, buffer, length);
1197}
1198#endif
1199
1200serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, const serial_manager_config_t *config)
1201{
1202 serial_manager_handle_t *handle;
1203 serial_manager_status_t status = kStatus_SerialManager_Error;
1204
1205 assert(NULL != config);
1206
1207 assert(NULL != serialHandle);
1208 assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));
1209
1210 handle = (serial_manager_handle_t *)serialHandle;
1211#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1212
1213 assert(NULL != config->ringBuffer);
1214 assert(config->ringBufferSize > 0U);
1215 (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);
1216 handle->handleType = config->blockType;
1217#else
1218 (void)memset(handle, 0, SERIAL_MANAGER_HANDLE_SIZE);
1219#endif
1220 handle->type = config->type;
1221#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1222 handle->ringBuffer.ringBuffer = config->ringBuffer;
1223 handle->ringBuffer.ringBufferSize = config->ringBufferSize;
1224#endif
1225
1226 switch (config->type)
1227 {
1228#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
1229 case kSerialPort_Uart:
1230 status = Serial_UartInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1231#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1232 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
1233 {
1234 (void)Serial_UartInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1235 SerialManager_TxCallback, handle);
1236
1237 (void)Serial_UartInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1238 SerialManager_RxCallback, handle);
1239 }
1240#endif
1241 break;
1242#endif
1243#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
1244 case kSerialPort_UartDma:
1245 status = Serial_UartDmaInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1246#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1247#if (defined(SERIAL_MANAGER_NON_BLOCKING_DUAL_MODE) && (SERIAL_MANAGER_NON_BLOCKING_DUAL_MODE > 0U))
1248 if (config->blockType == kSerialManager_Blocking)
1249 {
1250 return status;
1251 }
1252#endif /* SERIAL_MANAGER_NON_BLOCKING_DUAL_MODE */
1253 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
1254 {
1255 (void)Serial_UartDmaInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1256 SerialManager_TxCallback, handle);
1257
1258 (void)Serial_UartDmaInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1259 SerialManager_RxCallback, handle);
1260 }
1261#endif
1262 break;
1263#endif
1264#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
1265 case kSerialPort_UartDma:
1266 status = Serial_UartDmaInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1267#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1268#if (defined(SERIAL_MANAGER_NON_BLOCKING_DUAL_MODE) && (SERIAL_MANAGER_NON_BLOCKING_DUAL_MODE > 0U))
1269 if (config->blockType == kSerialManager_Blocking)
1270 {
1271 return status;
1272 }
1273#endif /* SERIAL_MANAGER_NON_BLOCKING_DUAL_MODE */
1274 if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
1275 {
1276 (void)Serial_UartDmaInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1277 SerialManager_TxCallback, handle);
1278
1279 (void)Serial_UartDmaInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1280 SerialManager_RxCallback, handle);
1281 }
1282#endif
1283 break;
1284#endif
1285#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
1286 case kSerialPort_UsbCdc:
1287 status = Serial_UsbCdcInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1288#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1289
1290 if (kStatus_SerialManager_Success == status)
1291 {
1292 status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1293 SerialManager_TxCallback, handle);
1294 if (kStatus_SerialManager_Success == status)
1295 {
1296 status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1297 SerialManager_RxCallback, handle);
1298 }
1299 }
1300#endif
1301 break;
1302#endif
1303#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
1304 case kSerialPort_Swo:
1305 status = Serial_SwoInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1306#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1307 if (kStatus_SerialManager_Success == status)
1308 {
1309 status = Serial_SwoInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1310 SerialManager_TxCallback, handle);
1311 }
1312#endif
1313 break;
1314#endif
1315#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1316 case kSerialPort_Virtual:
1317 status = Serial_PortVirtualInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1318#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1319 if (kStatus_SerialManager_Success == status)
1320 {
1321 status = Serial_PortVirtualInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1322 SerialManager_TxCallback, handle);
1323 if (kStatus_SerialManager_Success == status)
1324 {
1325 status = Serial_PortVirtualInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1326 SerialManager_RxCallback, handle);
1327 }
1328 }
1329#endif
1330 break;
1331#endif
1332#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
1333 case kSerialPort_Rpmsg:
1334 status = Serial_RpmsgInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), (void *)config);
1335#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1336 if (kStatus_SerialManager_Success == status)
1337 {
1338 status = Serial_RpmsgInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1339 SerialManager_TxCallback, handle);
1340 if (kStatus_SerialManager_Success == status)
1341 {
1342 status = Serial_RpmsgInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1343 SerialManager_RxCallback, handle);
1344 }
1345 }
1346#endif
1347 break;
1348#endif
1349#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
1350 case kSerialPort_SpiMaster:
1351 status = Serial_SpiMasterInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1352#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1353 if (kStatus_SerialManager_Success == status)
1354 {
1355 status = Serial_SpiMasterInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1356 SerialManager_TxCallback, handle);
1357 if (kStatus_SerialManager_Success == status)
1358 {
1359 status = Serial_SpiMasterInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1360 SerialManager_RxCallback, handle);
1361 }
1362 }
1363#endif
1364 break;
1365#endif
1366#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
1367 case kSerialPort_SpiSlave:
1368 status = Serial_SpiSlaveInit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]), config->portConfig);
1369#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1370 if (kStatus_SerialManager_Success == status)
1371 {
1372 status = Serial_SpiSlaveInstallTxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1373 SerialManager_TxCallback, handle);
1374 if (kStatus_SerialManager_Success == status)
1375 {
1376 status = Serial_SpiSlaveInstallRxCallback(((serial_handle_t)&handle->lowLevelhandleBuffer[0]),
1377 SerialManager_RxCallback, handle);
1378 }
1379 }
1380#endif
1381 break;
1382#endif
1383
1384 default:
1385 /*MISRA rule 16.4*/
1386 break;
1387 }
1388#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1389#if defined(OSA_USED)
1390
1391#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
1392
1393 COMMON_TASK_init();
1394
1395#else
1396 if (KOSA_StatusSuccess != OSA_SemaphoreCreate((osa_semaphore_handle_t)handle->serSemaphore, 1U))
1397 {
1398 return kStatus_SerialManager_Error;
1399 }
1400
1401 if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)handle->taskId, OSA_TASK(SerialManager_Task), handle))
1402 {
1403 return kStatus_SerialManager_Error;
1404 }
1405#endif
1406
1407#endif
1408
1409#endif
1410 return status;
1411}
1412
1413serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)
1414{
1415 serial_manager_handle_t *handle;
1416 uint32_t primask;
1417 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
1418
1419 assert(NULL != serialHandle);
1420
1421 handle = (serial_manager_handle_t *)serialHandle;
1422
1423 primask = DisableGlobalIRQ();
1424 if ((NULL != handle->openedReadHandleHead) || (0U != handle->openedWriteHandleCount))
1425 {
1426 serialManagerStatus = kStatus_SerialManager_Busy; /*Serial Manager Busy*/
1427 }
1428 else
1429 {
1430 switch (handle->type) /*serial port type*/
1431 {
1432#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
1433 case kSerialPort_Uart:
1434 (void)Serial_UartDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1435 break;
1436#endif
1437#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
1438 case kSerialPort_UsbCdc:
1439 (void)Serial_UsbCdcDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1440 break;
1441#endif
1442#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
1443 case kSerialPort_Swo:
1444 (void)Serial_SwoDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1445 break;
1446#endif
1447#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1448 case kSerialPort_Virtual:
1449 (void)Serial_PortVirtualDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1450 break;
1451#endif
1452#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
1453 case kSerialPort_Rpmsg:
1454 (void)Serial_RpmsgDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1455 break;
1456#endif
1457#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
1458 case kSerialPort_SpiSlave:
1459 (void)Serial_SpiSlaveDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1460 break;
1461#endif
1462#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
1463 case kSerialPort_SpiMaster:
1464 (void)Serial_SpiMasterDeinit(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1465 break;
1466#endif
1467
1468 default:
1469 /*MISRA rule 16.4*/
1470 break;
1471 }
1472#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1473
1474#if defined(OSA_USED)
1475
1476#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
1477#else
1478 (void)OSA_SemaphoreDestroy((osa_event_handle_t)handle->serSemaphore);
1479 (void)OSA_TaskDestroy((osa_task_handle_t)handle->taskId);
1480#endif
1481
1482#endif
1483
1484#endif
1485 }
1486
1487 EnableGlobalIRQ(primask);
1488 return serialManagerStatus;
1489}
1490
1491serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)
1492{
1493 serial_manager_handle_t *handle;
1494 serial_manager_write_handle_t *serialWriteHandle;
1495 uint32_t primask;
1496
1497 assert(NULL != serialHandle);
1498 assert(NULL != writeHandle);
1499 assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));
1500
1501 handle = (serial_manager_handle_t *)serialHandle;
1502 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
1503
1504 primask = DisableGlobalIRQ();
1505 handle->openedWriteHandleCount++;
1506 EnableGlobalIRQ(primask);
1507#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1508 if (handle->handleType == kSerialManager_Blocking)
1509 {
1510 serialWriteHandle->serialManagerHandle = handle;
1511 return kStatus_SerialManager_Success;
1512 }
1513 else
1514#endif
1515 {
1516 (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
1517 }
1518
1519 serialWriteHandle->serialManagerHandle = handle;
1520
1521#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1522 serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;
1523#endif
1524
1525 return kStatus_SerialManager_Success;
1526}
1527
1528serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)
1529{
1530 serial_manager_handle_t *handle;
1531 serial_manager_write_handle_t *serialWriteHandle;
1532 uint32_t primask;
1533
1534 assert(NULL != writeHandle);
1535
1536 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
1537 handle = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;
1538
1539 assert(NULL != handle);
1540#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1541 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
1542#endif
1543
1544#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1545 (void)SerialManager_CancelWriting(writeHandle);
1546#endif
1547 primask = DisableGlobalIRQ();
1548 if (handle->openedWriteHandleCount > 0U)
1549 {
1550 handle->openedWriteHandleCount--;
1551 }
1552 EnableGlobalIRQ(primask);
1553
1554 (void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
1555
1556 return kStatus_SerialManager_Success;
1557}
1558
1559serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)
1560{
1561 serial_manager_handle_t *handle;
1562 serial_manager_read_handle_t *serialReadHandle; /* read handle structure */
1563 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
1564 uint32_t primask;
1565
1566 assert(NULL != serialHandle);
1567 assert(NULL != readHandle);
1568 assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));
1569
1570 handle = (serial_manager_handle_t *)serialHandle;
1571 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1572#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1573 if (handle->handleType == kSerialManager_Blocking)
1574 {
1575 serialReadHandle->serialManagerHandle = handle;
1576 return kStatus_SerialManager_Success;
1577 }
1578#endif
1579 primask = DisableGlobalIRQ();
1580 if (handle->openedReadHandleHead != NULL)
1581 {
1582 serialManagerStatus = kStatus_SerialManager_Busy;
1583 }
1584 else
1585 {
1586 handle->openedReadHandleHead = serialReadHandle;
1587
1588 (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
1589
1590 serialReadHandle->serialManagerHandle = handle;
1591#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1592 serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;
1593#endif
1594 }
1595 EnableGlobalIRQ(primask);
1596 return serialManagerStatus;
1597}
1598
1599serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)
1600{
1601 serial_manager_handle_t *handle;
1602 serial_manager_read_handle_t *serialReadHandle;
1603 uint32_t primask;
1604
1605 assert(NULL != readHandle);
1606
1607 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1608 handle = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;
1609
1610 assert((NULL != handle) && (handle->openedReadHandleHead == serialReadHandle));
1611#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1612 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
1613#endif
1614
1615#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1616 (void)SerialManager_CancelReading(readHandle);
1617#endif
1618
1619 primask = DisableGlobalIRQ();
1620 handle->openedReadHandleHead = NULL;
1621 EnableGlobalIRQ(primask);
1622
1623 (void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
1624
1625 return kStatus_SerialManager_Success;
1626}
1627
1628serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
1629{
1630#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1631 return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);
1632#else
1633 return SerialManager_Write(writeHandle, buffer, length);
1634#endif
1635}
1636
1637serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
1638{
1639#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1640 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);
1641#else
1642 return SerialManager_Read(readHandle, buffer, length);
1643#endif
1644}
1645
1646#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
1647serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,
1648 uint8_t *buffer,
1649 uint32_t length)
1650{
1651 return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);
1652}
1653
1654serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
1655{
1656#if ((defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U)) || \
1657 (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U)))
1658
1659 serial_manager_read_handle_t *serialReadHandle;
1660 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1661
1662 return (serial_manager_status_t)SerialManager_StartReading(serialReadHandle->serialManagerHandle, readHandle,
1663 buffer, length);
1664#else
1665 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);
1666#endif
1667}
1668
1669serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)
1670{
1671 serial_manager_write_handle_t *serialWriteHandle;
1672 uint32_t primask;
1673 uint8_t isNotUsed = 0U;
1674 uint8_t isNotNeed2Cancel = 0U;
1675
1676 assert(NULL != writeHandle);
1677
1678 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
1679
1680 assert(NULL != serialWriteHandle->serialManagerHandle);
1681 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
1682
1683 if ((NULL != serialWriteHandle->transfer.buffer) &&
1684 (kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))
1685 {
1686 return kStatus_SerialManager_Error;
1687 }
1688
1689 primask = DisableGlobalIRQ();
1690 if (serialWriteHandle !=
1691 (serial_manager_write_handle_t *)((uint32_t)LIST_GetHead(
1692 &serialWriteHandle->serialManagerHandle->runningWriteHandleHead) -
1693 4U))
1694 {
1695 if (kLIST_Ok == LIST_RemoveElement(&serialWriteHandle->link))
1696 {
1697 isNotUsed = 1U;
1698 }
1699 else
1700 {
1701 isNotNeed2Cancel = 1U;
1702 }
1703 }
1704 EnableGlobalIRQ(primask);
1705
1706 if (0U == isNotNeed2Cancel)
1707 {
1708 if (0U != isNotUsed)
1709 {
1710 serialWriteHandle->transfer.soFar = 0;
1711 serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;
1712
1713 SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);
1714#if defined(OSA_USED)
1715
1716#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
1717 serialWriteHandle->serialManagerHandle->commontaskMsg.callback = SerialManager_Task;
1718 serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam =
1719 serialWriteHandle->serialManagerHandle;
1720 COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);
1721#else
1722 primask = DisableGlobalIRQ();
1723 serialWriteHandle->serialManagerHandle->serialManagerState[SERIAL_EVENT_DATA_SENT]++;
1724 EnableGlobalIRQ(primask);
1725 (void)OSA_SemaphorePost((osa_semaphore_handle_t)serialWriteHandle->serialManagerHandle->serSemaphore);
1726#endif
1727
1728#else
1729 SerialManager_Task(serialWriteHandle->serialManagerHandle);
1730#endif
1731 }
1732 else
1733 {
1734 switch (serialWriteHandle->serialManagerHandle->type)
1735 {
1736#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
1737 case kSerialPort_Uart:
1738 (void)Serial_UartCancelWrite(
1739 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
1740 break;
1741#endif
1742#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
1743 case kSerialPort_UsbCdc:
1744 (void)Serial_UsbCdcCancelWrite(
1745 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
1746 break;
1747#endif
1748#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
1749 case kSerialPort_Swo:
1750 (void)Serial_SwoCancelWrite(
1751 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
1752 break;
1753#endif
1754#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1755 case kSerialPort_Virtual:
1756 (void)Serial_PortVirtualCancelWrite(
1757 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
1758 break;
1759#endif
1760#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
1761 case kSerialPort_SpiMaster:
1762 (void)Serial_SpiMasterCancelWrite(
1763 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
1764 break;
1765#endif
1766#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
1767 case kSerialPort_SpiSlave:
1768 (void)Serial_SpiSlaveCancelWrite(
1769 ((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
1770 break;
1771#endif
1772 default:
1773 /*MISRA rule 16.4*/
1774 break;
1775 }
1776 }
1777
1778#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
1779#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
1780 /* Need to support common_task. */
1781#else /* SERIAL_MANAGER_USE_COMMON_TASK */
1782 primask = DisableGlobalIRQ();
1783 handle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]++;
1784 EnableGlobalIRQ(primask);
1785 (void)OSA_SemaphorePost((osa_semaphore_handle_t)handle->serSemaphore);
1786
1787#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
1788#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
1789 (void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);
1790#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
1791 }
1792
1793 return kStatus_SerialManager_Success;
1794}
1795
1796serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)
1797{
1798 serial_manager_read_handle_t *serialReadHandle;
1799 serial_manager_callback_message_t msg;
1800 uint8_t *buffer;
1801 uint32_t primask;
1802
1803 assert(NULL != readHandle);
1804
1805 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1806
1807 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
1808
1809 if ((NULL != serialReadHandle->transfer.buffer) &&
1810 (kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))
1811 {
1812 return kStatus_SerialManager_Error;
1813 }
1814
1815 primask = DisableGlobalIRQ();
1816 buffer = serialReadHandle->transfer.buffer;
1817 serialReadHandle->transfer.buffer = NULL;
1818 serialReadHandle->transfer.length = 0;
1819 msg.buffer = buffer;
1820 msg.length = serialReadHandle->transfer.soFar;
1821 EnableGlobalIRQ(primask);
1822
1823 if (NULL != buffer)
1824 {
1825 if (NULL != serialReadHandle->callback)
1826 {
1827 serialReadHandle->callback(serialReadHandle->callbackParam, &msg, kStatus_SerialManager_Canceled);
1828 }
1829 }
1830 return kStatus_SerialManager_Success;
1831}
1832
1833serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,
1834 uint8_t *buffer,
1835 uint32_t length,
1836 uint32_t *receivedLength)
1837{
1838 assert(NULL != receivedLength);
1839
1840 return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);
1841}
1842
1843serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,
1844 serial_manager_callback_t callback,
1845 void *callbackParam)
1846{
1847 serial_manager_write_handle_t *serialWriteHandle;
1848
1849 assert(NULL != writeHandle);
1850
1851 serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
1852
1853 assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
1854
1855 serialWriteHandle->callbackParam = callbackParam;
1856 serialWriteHandle->callback = callback;
1857
1858 return kStatus_SerialManager_Success;
1859}
1860
1861serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,
1862 serial_manager_callback_t callback,
1863 void *callbackParam)
1864{
1865 serial_manager_read_handle_t *serialReadHandle;
1866
1867 assert(NULL != readHandle);
1868
1869 serialReadHandle = (serial_manager_read_handle_t *)readHandle;
1870
1871 assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
1872
1873 serialReadHandle->callbackParam = callbackParam;
1874 serialReadHandle->callback = callback;
1875
1876 return kStatus_SerialManager_Success;
1877}
1878#endif
1879
1880serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)
1881{
1882 serial_manager_handle_t *handle;
1883 serial_manager_status_t status = kStatus_SerialManager_Error;
1884
1885 assert(NULL != serialHandle);
1886
1887 handle = (serial_manager_handle_t *)serialHandle;
1888
1889 switch (handle->type)
1890 {
1891#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
1892 case kSerialPort_Uart:
1893 status = Serial_UartEnterLowpower(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1894 break;
1895#endif
1896#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
1897 case kSerialPort_UsbCdc:
1898 break;
1899#endif
1900#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
1901 case kSerialPort_Swo:
1902 break;
1903#endif
1904#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1905 case kSerialPort_Virtual:
1906 break;
1907#endif
1908#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1909 case kSerialPort_Rpmsg:
1910 break;
1911#endif
1912#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
1913 case kSerialPort_SpiMaster:
1914 break;
1915#endif
1916#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
1917 case kSerialPort_SpiSlave:
1918 break;
1919#endif
1920 default:
1921 /*MISRA rule 16.4*/
1922 break;
1923 }
1924 return status;
1925}
1926
1927serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)
1928{
1929 serial_manager_handle_t *handle;
1930 serial_manager_status_t status = kStatus_SerialManager_Error;
1931
1932 assert(NULL != serialHandle);
1933
1934 handle = (serial_manager_handle_t *)serialHandle;
1935
1936 switch (handle->type)
1937 {
1938#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
1939 case kSerialPort_Uart:
1940 status = Serial_UartExitLowpower(((serial_handle_t)&handle->lowLevelhandleBuffer[0]));
1941 break;
1942#endif
1943#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
1944 case kSerialPort_UsbCdc:
1945 break;
1946#endif
1947#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
1948 case kSerialPort_Swo:
1949 break;
1950#endif
1951#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1952 case kSerialPort_Virtual:
1953 break;
1954#endif
1955#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
1956 case kSerialPort_Rpmsg:
1957 break;
1958#endif
1959#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
1960 case kSerialPort_SpiMaster:
1961 break;
1962#endif
1963#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
1964 case kSerialPort_SpiSlave:
1965 break;
1966#endif
1967 default:
1968 /*MISRA rule 16.4*/
1969 break;
1970 }
1971 return status;
1972}
1973