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)) |
77 | typedef 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 */ |
84 | typedef 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 */ |
95 | typedef 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; |
108 | typedef struct _serial_manager_send_block_handle |
109 | { |
110 | struct _serial_manager_handle *serialManagerHandle; |
111 | |
112 | } serial_manager_write_block_handle_t; |
113 | |
114 | typedef serial_manager_write_handle_t serial_manager_read_handle_t; |
115 | typedef 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 */ |
119 | typedef 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 |
130 | typedef 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 */ |
148 | typedef 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)) |
215 | static 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 | */ |
232 | static 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)) |
244 | static void SerialManager_AddTail(list_label_t *queue, serial_manager_write_handle_t *node) |
245 | { |
246 | (void)LIST_AddTail(queue, &node->link); |
247 | } |
248 | |
249 | static 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 | |
257 | static 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 | |
324 | static 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 | |
378 | static 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 | |
433 | static 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)) |
490 | static 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 | |
522 | static 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)) |
681 | static 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 | |
748 | void SerialManager_RxCallback(void *callbackParam, |
749 | serial_manager_callback_message_t *message, |
750 | serial_manager_status_t status); |
751 | void 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 | |
949 | static 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 | |
1045 | static 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 | |
1165 | static 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 | |
1182 | static 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 | |
1200 | serial_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 | |
1413 | serial_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 | |
1491 | serial_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 | |
1528 | serial_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 | |
1559 | serial_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 | |
1599 | serial_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 | |
1628 | serial_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 | |
1637 | serial_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)) |
1647 | serial_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 | |
1654 | serial_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 | |
1669 | serial_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 | |
1796 | serial_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 | |
1833 | serial_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 | |
1843 | serial_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 | |
1861 | serial_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 | |
1880 | serial_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 | |
1927 | serial_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 | |