1 /*
2 * Copyright 2018 -2021 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9 #include "fsl_component_serial_manager.h"
10 #include "fsl_component_serial_port_internal.h"
11
12 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U)) || \
13 (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
14 #include "fsl_adapter_uart.h"
15
16 #include "fsl_component_serial_port_uart.h"
17
18 /*******************************************************************************
19 * Definitions
20 ******************************************************************************/
21 #ifndef NDEBUG
22 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
23 #undef assert
24 #define assert(n)
25 #else
26 /* MISRA C-2012 Rule 17.2 */
27 #undef assert
28 #define assert(n) \
29 while (!(n)) \
30 { \
31 ; \
32 }
33 #endif
34 #endif
35
36 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
37 #define SERIAL_PORT_UART_RECEIVE_DATA_LENGTH 1U
38 typedef struct _serial_uart_send_state
39 {
40 uint8_t *buffer;
41 uint32_t length;
42 serial_manager_callback_t callback;
43 void *callbackParam;
44 volatile uint8_t busy;
45 } serial_uart_send_state_t;
46
47 typedef struct _serial_uart_recv_state
48 {
49 serial_manager_callback_t callback;
50 void *callbackParam;
51 volatile uint8_t busy;
52 volatile uint8_t rxEnable;
53 uint8_t readBuffer[SERIAL_PORT_UART_RECEIVE_DATA_LENGTH];
54 } serial_uart_recv_state_t;
55
56 typedef struct _serial_uart_dma_recv_state
57 {
58 serial_manager_callback_t callback;
59 void *callbackParam;
60 volatile uint8_t busy;
61 volatile uint8_t rxEnable;
62 uint8_t readBuffer[SERIAL_PORT_UART_DMA_RECEIVE_DATA_LENGTH];
63 } serial_uart_dma_recv_state_t;
64
65 typedef struct _serial_uart_block_state
66 {
67 UART_HANDLE_DEFINE(usartHandleBuffer);
68 } serial_uart_block_state_t;
69 #endif
70
71 typedef struct _serial_uart_state
72 {
73 UART_HANDLE_DEFINE(usartHandleBuffer);
74 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
75 serial_uart_send_state_t tx;
76 serial_uart_recv_state_t rx;
77 #endif
78 } serial_uart_state_t;
79 #endif
80 #if (defined(HAL_UART_DMA_ENABLE) && (HAL_UART_DMA_ENABLE > 0U))
81 #if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
82 typedef struct _serial_uart_dma_state
83 {
84 UART_HANDLE_DEFINE(usartHandleBuffer);
85 UART_DMA_HANDLE_DEFINE(uartDmaHandle);
86 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
87 serial_uart_send_state_t tx;
88 serial_uart_dma_recv_state_t rx;
89 #endif
90 } serial_uart_dma_state_t;
91 #endif
92 #endif
93
94 /*******************************************************************************
95 * Prototypes
96 ******************************************************************************/
97
98 /*******************************************************************************
99 * Code
100 ******************************************************************************/
101
102 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
Serial_UartEnableReceiving(serial_uart_state_t * serialUartHandle)103 static serial_manager_status_t Serial_UartEnableReceiving(serial_uart_state_t *serialUartHandle)
104 {
105 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
106 hal_uart_transfer_t transfer;
107 #endif
108 if (1U == serialUartHandle->rx.rxEnable)
109 {
110 serialUartHandle->rx.busy = 1U;
111 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
112 transfer.data = &serialUartHandle->rx.readBuffer[0];
113 transfer.dataSize = sizeof(serialUartHandle->rx.readBuffer);
114 if (kStatus_HAL_UartSuccess !=
115 HAL_UartTransferReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))
116 #else
117 if (kStatus_HAL_UartSuccess !=
118 HAL_UartReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
119 &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer)))
120 #endif
121 {
122 serialUartHandle->rx.busy = 0U;
123 return kStatus_SerialManager_Error;
124 }
125 }
126 return kStatus_SerialManager_Success;
127 }
128
129 /* UART user callback */
Serial_UartCallback(hal_uart_handle_t handle,hal_uart_status_t status,void * userData)130 static void Serial_UartCallback(hal_uart_handle_t handle, hal_uart_status_t status, void *userData)
131 {
132 serial_uart_state_t *serialUartHandle;
133 serial_manager_callback_message_t serialMsg;
134
135 assert(userData);
136 serialUartHandle = (serial_uart_state_t *)userData;
137
138 if ((hal_uart_status_t)kStatus_HAL_UartRxIdle == status)
139 {
140 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
141 (void)HAL_UartTransferAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
142 #else
143 (void)HAL_UartAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
144 #endif
145 if ((NULL != serialUartHandle->rx.callback))
146 {
147 serialMsg.buffer = &serialUartHandle->rx.readBuffer[0];
148 serialMsg.length = sizeof(serialUartHandle->rx.readBuffer);
149 serialUartHandle->rx.callback(serialUartHandle->rx.callbackParam, &serialMsg,
150 kStatus_SerialManager_Success);
151 }
152 }
153 else if ((hal_uart_status_t)kStatus_HAL_UartTxIdle == status)
154 {
155 if (0U != serialUartHandle->tx.busy)
156 {
157 serialUartHandle->tx.busy = 0U;
158 if ((NULL != serialUartHandle->tx.callback))
159 {
160 serialMsg.buffer = serialUartHandle->tx.buffer;
161 serialMsg.length = serialUartHandle->tx.length;
162 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &serialMsg,
163 kStatus_SerialManager_Success);
164 }
165 }
166 }
167 else
168 {
169 }
170 }
171 #endif
172
Serial_UartInit(serial_handle_t serialHandle,void * serialConfig)173 serial_manager_status_t Serial_UartInit(serial_handle_t serialHandle, void *serialConfig)
174 {
175 serial_uart_state_t *serialUartHandle;
176 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
177 serial_port_uart_config_t *uartConfig = (serial_port_uart_config_t *)serialConfig;
178 #endif
179 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
180 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
181 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
182 #if 0 /* Not used below! */
183 hal_uart_transfer_t transfer;
184 #endif
185 #endif
186 #endif
187
188 assert(serialConfig);
189 assert(serialHandle);
190 assert(SERIAL_PORT_UART_HANDLE_SIZE >= sizeof(serial_uart_state_t));
191
192 serialUartHandle = (serial_uart_state_t *)serialHandle;
193 serialManagerStatus = (serial_manager_status_t)HAL_UartInit(
194 ((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), (const hal_uart_config_t *)serialConfig);
195 assert(kStatus_SerialManager_Success == serialManagerStatus);
196 (void)serialManagerStatus;
197
198 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
199 serialUartHandle->rx.rxEnable = uartConfig->enableRx;
200 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
201
202 (void)HAL_UartTransferInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
203 Serial_UartCallback, serialUartHandle);
204 #else
205 (void)HAL_UartInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), Serial_UartCallback,
206 serialUartHandle);
207 #endif
208 #endif
209
210 return serialManagerStatus;
211 }
212
Serial_UartDeinit(serial_handle_t serialHandle)213 serial_manager_status_t Serial_UartDeinit(serial_handle_t serialHandle)
214 {
215 serial_uart_state_t *serialUartHandle;
216
217 assert(serialHandle);
218
219 serialUartHandle = (serial_uart_state_t *)serialHandle;
220
221 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
222 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
223 (void)HAL_UartTransferAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
224 #else
225 (void)HAL_UartAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
226 #endif
227 #endif
228 (void)HAL_UartDeinit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
229
230 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
231 serialUartHandle->tx.busy = 0U;
232 serialUartHandle->rx.busy = 0U;
233 #endif
234
235 return kStatus_SerialManager_Success;
236 }
237
238 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
239
Serial_UartWrite(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)240 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
241 {
242 serial_uart_state_t *serialUartHandle;
243 hal_uart_status_t uartstatus;
244 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
245 hal_uart_transfer_t transfer;
246 #endif
247
248 assert(serialHandle);
249 assert(buffer);
250 assert(length);
251
252 serialUartHandle = (serial_uart_state_t *)serialHandle;
253 if (0U != serialUartHandle->tx.busy)
254 {
255 return kStatus_SerialManager_Busy;
256 }
257 serialUartHandle->tx.busy = 1U;
258
259 serialUartHandle->tx.buffer = buffer;
260 serialUartHandle->tx.length = length;
261
262 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
263 transfer.data = buffer;
264 transfer.dataSize = length;
265 uartstatus =
266 HAL_UartTransferSendNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer);
267 #else
268
269 uartstatus = HAL_UartSendNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length);
270 #endif
271 assert(kStatus_HAL_UartSuccess == uartstatus);
272 (void)uartstatus;
273
274 return kStatus_SerialManager_Success;
275 }
276
Serial_UartRead(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)277 serial_manager_status_t Serial_UartRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
278 {
279 assert(serialHandle);
280 (void)buffer;
281 (void)length;
282 return (serial_manager_status_t)Serial_UartEnableReceiving(serialHandle);
283 }
284
285 #else
286
Serial_UartWrite(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)287 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
288 {
289 serial_uart_state_t *serialUartHandle;
290
291 assert(serialHandle);
292 assert(buffer);
293 assert(length);
294
295 serialUartHandle = (serial_uart_state_t *)serialHandle;
296
297 return (serial_manager_status_t)HAL_UartSendBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
298 buffer, length);
299 }
300
Serial_UartRead(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)301 serial_manager_status_t Serial_UartRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
302 {
303 serial_uart_state_t *serialUartHandle;
304
305 assert(serialHandle);
306 assert(buffer);
307 assert(length);
308
309 serialUartHandle = (serial_uart_state_t *)serialHandle;
310
311 return (serial_manager_status_t)HAL_UartReceiveBlocking(
312 ((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length);
313 }
314
315 #endif
316
317 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
Serial_UartCancelWrite(serial_handle_t serialHandle)318 serial_manager_status_t Serial_UartCancelWrite(serial_handle_t serialHandle)
319 {
320 serial_uart_state_t *serialUartHandle;
321 serial_manager_callback_message_t serialMsg;
322 uint32_t primask;
323 uint8_t isBusy = 0U;
324
325 assert(serialHandle);
326
327 serialUartHandle = (serial_uart_state_t *)serialHandle;
328
329 primask = DisableGlobalIRQ();
330 isBusy = serialUartHandle->tx.busy;
331 serialUartHandle->tx.busy = 0U;
332 EnableGlobalIRQ(primask);
333
334 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
335 (void)HAL_UartTransferAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
336 #else
337 (void)HAL_UartAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
338 #endif
339 if (0U != isBusy)
340 {
341 if ((NULL != serialUartHandle->tx.callback))
342 {
343 serialMsg.buffer = serialUartHandle->tx.buffer;
344 serialMsg.length = serialUartHandle->tx.length;
345 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &serialMsg,
346 kStatus_SerialManager_Canceled);
347 }
348 }
349 return kStatus_SerialManager_Success;
350 }
351
Serial_UartInstallTxCallback(serial_handle_t serialHandle,serial_manager_callback_t callback,void * callbackParam)352 serial_manager_status_t Serial_UartInstallTxCallback(serial_handle_t serialHandle,
353 serial_manager_callback_t callback,
354 void *callbackParam)
355 {
356 serial_uart_state_t *serialUartHandle;
357
358 assert(serialHandle);
359
360 serialUartHandle = (serial_uart_state_t *)serialHandle;
361
362 serialUartHandle->tx.callback = callback;
363 serialUartHandle->tx.callbackParam = callbackParam;
364
365 return kStatus_SerialManager_Success;
366 }
367
Serial_UartInstallRxCallback(serial_handle_t serialHandle,serial_manager_callback_t callback,void * callbackParam)368 serial_manager_status_t Serial_UartInstallRxCallback(serial_handle_t serialHandle,
369 serial_manager_callback_t callback,
370 void *callbackParam)
371 {
372 serial_uart_state_t *serialUartHandle;
373
374 assert(serialHandle);
375
376 serialUartHandle = (serial_uart_state_t *)serialHandle;
377
378 serialUartHandle->rx.callback = callback;
379 serialUartHandle->rx.callbackParam = callbackParam;
380
381 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
382 (void)Serial_UartEnableReceiving(serialUartHandle);
383 #endif
384 return kStatus_SerialManager_Success;
385 }
386
Serial_UartIsrFunction(serial_handle_t serialHandle)387 void Serial_UartIsrFunction(serial_handle_t serialHandle)
388 {
389 serial_uart_state_t *serialUartHandle;
390
391 assert(serialHandle);
392
393 serialUartHandle = (serial_uart_state_t *)serialHandle;
394
395 HAL_UartIsrFunction(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
396 }
397 #endif
398
Serial_UartEnterLowpower(serial_handle_t serialHandle)399 serial_manager_status_t Serial_UartEnterLowpower(serial_handle_t serialHandle)
400 {
401 serial_uart_state_t *serialUartHandle;
402 hal_uart_status_t uartstatus;
403
404 assert(serialHandle);
405
406 serialUartHandle = (serial_uart_state_t *)serialHandle;
407
408 uartstatus = HAL_UartEnterLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
409 assert(kStatus_HAL_UartSuccess == uartstatus);
410 (void)uartstatus;
411
412 return kStatus_SerialManager_Success;
413 }
414
Serial_UartExitLowpower(serial_handle_t serialHandle)415 serial_manager_status_t Serial_UartExitLowpower(serial_handle_t serialHandle)
416 {
417 serial_uart_state_t *serialUartHandle;
418 serial_manager_status_t status = kStatus_SerialManager_Success;
419 hal_uart_status_t uartstatus;
420
421 assert(serialHandle);
422
423 serialUartHandle = (serial_uart_state_t *)serialHandle;
424
425 uartstatus = HAL_UartExitLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
426 assert(kStatus_HAL_UartSuccess == uartstatus);
427 (void)uartstatus;
428
429 return status;
430 }
431
432 #if (defined(HAL_UART_DMA_ENABLE) && (HAL_UART_DMA_ENABLE > 0U))
433 #if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
434 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
Serial_UartDmaEnableReceiving(serial_uart_dma_state_t * serialUartHandle)435 static serial_manager_status_t Serial_UartDmaEnableReceiving(serial_uart_dma_state_t *serialUartHandle)
436 {
437 if (1U == serialUartHandle->rx.rxEnable)
438 {
439 serialUartHandle->rx.busy = 1U;
440 if (kStatus_HAL_UartDmaSuccess !=
441 HAL_UartDMATransferReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
442 &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer),
443 false))
444
445 {
446 serialUartHandle->rx.busy = 0U;
447 return kStatus_SerialManager_Error;
448 }
449 }
450 return kStatus_SerialManager_Success;
451 }
452
453 /* UART user callback */
Serial_UartDmaCallback(hal_uart_dma_handle_t handle,hal_dma_callback_msg_t * dmaMsg,void * callbackParam)454 static void Serial_UartDmaCallback(hal_uart_dma_handle_t handle, hal_dma_callback_msg_t *dmaMsg, void *callbackParam)
455 {
456 serial_uart_dma_state_t *serialUartHandle;
457 serial_manager_callback_message_t cb_msg;
458
459 assert(callbackParam);
460 serialUartHandle = (serial_uart_dma_state_t *)callbackParam;
461
462 if (((hal_uart_dma_status_t)kStatus_HAL_UartDmaRxIdle == dmaMsg->status) ||
463 (kStatus_HAL_UartDmaIdleline == dmaMsg->status))
464 {
465 if ((NULL != serialUartHandle->rx.callback))
466 {
467 cb_msg.buffer = dmaMsg->data;
468 cb_msg.length = dmaMsg->dataSize;
469 serialUartHandle->rx.callback(serialUartHandle->rx.callbackParam, &cb_msg, kStatus_SerialManager_Success);
470 }
471
472 if (kStatus_HAL_UartDmaSuccess ==
473 HAL_UartDMATransferReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
474 &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer),
475 false))
476 {
477 serialUartHandle->rx.busy = 1U;
478 }
479 }
480 else if (kStatus_HAL_UartDmaTxIdle == dmaMsg->status)
481 {
482 if (0U != serialUartHandle->tx.busy)
483 {
484 serialUartHandle->tx.busy = 0U;
485 if ((NULL != serialUartHandle->tx.callback))
486 {
487 cb_msg.buffer = dmaMsg->data;
488 cb_msg.length = dmaMsg->dataSize;
489 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &cb_msg,
490 kStatus_SerialManager_Success);
491 }
492 }
493 }
494 else
495 {
496 }
497 }
498
499 #endif
500
Serial_UartDmaInit(serial_handle_t serialHandle,void * serialConfig)501 serial_manager_status_t Serial_UartDmaInit(serial_handle_t serialHandle, void *serialConfig)
502 {
503 serial_uart_dma_state_t *serialUartHandle;
504 #if (defined(HAL_UART_DMA_ENABLE) && (HAL_UART_DMA_ENABLE > 0U))
505 serial_port_uart_dma_config_t *uartConfig = (serial_port_uart_dma_config_t *)serialConfig;
506 #endif
507 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
508
509 assert(serialConfig);
510 assert(serialHandle);
511
512 assert(SERIAL_PORT_UART_DMA_HANDLE_SIZE >= sizeof(serial_uart_dma_state_t));
513
514 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
515 serialManagerStatus = (serial_manager_status_t)HAL_UartInit(
516 ((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), (const hal_uart_config_t *)serialConfig);
517 assert(kStatus_SerialManager_Success == serialManagerStatus);
518 (void)serialManagerStatus;
519
520 #if (defined(HAL_UART_DMA_ENABLE) && (HAL_UART_DMA_ENABLE > 0U))
521
522 hal_uart_dma_config_t dmaConfig;
523
524 dmaConfig.uart_instance = uartConfig->instance;
525 dmaConfig.dma_instance = uartConfig->dma_instance;
526 dmaConfig.rx_channel = uartConfig->rx_channel;
527 dmaConfig.tx_channel = uartConfig->tx_channel;
528 dmaConfig.dma_mux_configure = uartConfig->dma_mux_configure;
529 dmaConfig.dma_channel_mux_configure = uartConfig->dma_channel_mux_configure;
530
531 // Init uart dma
532 (void)HAL_UartDMAInit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
533 (hal_uart_dma_handle_t *)serialUartHandle->uartDmaHandle, &dmaConfig);
534
535 #endif
536 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
537
538 serialUartHandle->rx.rxEnable = uartConfig->enableRx;
539 (void)HAL_UartDMATransferInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
540 Serial_UartDmaCallback, serialUartHandle);
541
542 #endif
543 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
544 serialManagerStatus = Serial_UartDmaEnableReceiving(serialUartHandle);
545 #endif
546
547 return serialManagerStatus;
548 }
549
Serial_UartDmaDeinit(serial_handle_t serialHandle)550 serial_manager_status_t Serial_UartDmaDeinit(serial_handle_t serialHandle)
551 {
552 serial_uart_dma_state_t *serialUartHandle;
553
554 assert(serialHandle);
555
556 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
557
558 (void)HAL_UartDMAAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
559
560 (void)HAL_UartDeinit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
561 (void)HAL_UartDMADeinit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
562
563 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
564 serialUartHandle->tx.busy = 0U;
565 serialUartHandle->rx.busy = 0U;
566 #endif
567
568 return kStatus_SerialManager_Success;
569 }
570
571 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
572
Serial_UartDmaWrite(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)573 serial_manager_status_t Serial_UartDmaWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
574 {
575 serial_uart_dma_state_t *serialUartHandle;
576 hal_uart_status_t uartstatus;
577
578 assert(serialHandle);
579 assert(buffer);
580 assert(length);
581
582 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
583
584 if (0U != serialUartHandle->tx.busy)
585 {
586 return kStatus_SerialManager_Busy;
587 }
588 serialUartHandle->tx.busy = 1U;
589
590 serialUartHandle->tx.buffer = buffer;
591 serialUartHandle->tx.length = length;
592
593 uartstatus = (hal_uart_status_t)HAL_UartDMATransferSend(
594 ((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length);
595
596 assert(kStatus_HAL_UartSuccess == uartstatus);
597 (void)uartstatus;
598
599 return kStatus_SerialManager_Success;
600 }
601
602 #endif
603
604 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
Serial_UartDmaCancelWrite(serial_handle_t serialHandle)605 serial_manager_status_t Serial_UartDmaCancelWrite(serial_handle_t serialHandle)
606 {
607 serial_uart_dma_state_t *serialUartHandle;
608 serial_manager_callback_message_t serialMsg;
609 uint32_t primask;
610 uint8_t isBusy = 0U;
611
612 assert(serialHandle);
613
614 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
615
616 primask = DisableGlobalIRQ();
617 isBusy = serialUartHandle->tx.busy;
618 serialUartHandle->tx.busy = 0U;
619 EnableGlobalIRQ(primask);
620
621 (void)HAL_UartDMAAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
622
623 if (0U != isBusy)
624 {
625 if ((NULL != serialUartHandle->tx.callback))
626 {
627 serialMsg.buffer = serialUartHandle->tx.buffer;
628 serialMsg.length = serialUartHandle->tx.length;
629 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &serialMsg,
630 kStatus_SerialManager_Canceled);
631 }
632 }
633 return kStatus_SerialManager_Success;
634 }
635
Serial_UartDmaInstallTxCallback(serial_handle_t serialHandle,serial_manager_callback_t callback,void * callbackParam)636 serial_manager_status_t Serial_UartDmaInstallTxCallback(serial_handle_t serialHandle,
637 serial_manager_callback_t callback,
638 void *callbackParam)
639 {
640 serial_uart_dma_state_t *serialUartHandle;
641
642 assert(serialHandle);
643
644 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
645
646 serialUartHandle->tx.callback = callback;
647 serialUartHandle->tx.callbackParam = callbackParam;
648
649 return kStatus_SerialManager_Success;
650 }
651
Serial_UartDmaInstallRxCallback(serial_handle_t serialHandle,serial_manager_callback_t callback,void * callbackParam)652 serial_manager_status_t Serial_UartDmaInstallRxCallback(serial_handle_t serialHandle,
653 serial_manager_callback_t callback,
654 void *callbackParam)
655 {
656 serial_uart_dma_state_t *serialUartHandle;
657
658 assert(serialHandle);
659
660 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
661
662 serialUartHandle->rx.callback = callback;
663 serialUartHandle->rx.callbackParam = callbackParam;
664
665 return kStatus_SerialManager_Success;
666 }
667
Serial_UartDmaIsrFunction(serial_handle_t serialHandle)668 void Serial_UartDmaIsrFunction(serial_handle_t serialHandle)
669 {
670 serial_uart_dma_state_t *serialUartHandle;
671
672 assert(serialHandle);
673
674 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
675
676 HAL_UartIsrFunction(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
677 }
678 #endif
679
Serial_UartDmaEnterLowpower(serial_handle_t serialHandle)680 serial_manager_status_t Serial_UartDmaEnterLowpower(serial_handle_t serialHandle)
681 {
682 serial_uart_dma_state_t *serialUartHandle;
683 hal_uart_status_t uartstatus;
684
685 assert(serialHandle);
686
687 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
688
689 uartstatus = HAL_UartEnterLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
690 assert(kStatus_HAL_UartSuccess == uartstatus);
691 (void)uartstatus;
692
693 return kStatus_SerialManager_Success;
694 }
695
Serial_UartDmaExitLowpower(serial_handle_t serialHandle)696 serial_manager_status_t Serial_UartDmaExitLowpower(serial_handle_t serialHandle)
697 {
698 serial_uart_dma_state_t *serialUartHandle;
699 serial_manager_status_t status = kStatus_SerialManager_Success;
700 hal_uart_status_t uartstatus;
701
702 assert(serialHandle);
703
704 serialUartHandle = (serial_uart_dma_state_t *)serialHandle;
705
706 uartstatus = HAL_UartExitLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
707 assert(kStatus_HAL_UartSuccess == uartstatus);
708 (void)uartstatus;
709
710 return status;
711 }
712 #endif
713 #endif
714
