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