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