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) |
39 | typedef 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 | |
48 | typedef 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 | |
57 | typedef 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 | |
66 | typedef struct _serial_uart_block_state |
67 | { |
68 | UART_HANDLE_DEFINE(usartHandleBuffer); |
69 | } serial_uart_block_state_t; |
70 | #endif |
71 | |
72 | typedef 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)) |
83 | typedef 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)) |
104 | static 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 */ |
131 | static 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 | |
187 | serial_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 | |
237 | serial_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 | |
264 | serial_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 | |
309 | serial_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 | |
319 | serial_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 | |
333 | serial_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)) |
350 | serial_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 | |
383 | serial_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 | |
399 | serial_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 | |
415 | void 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 | |
427 | serial_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 | |
443 | serial_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)) |
472 | static 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 */ |
491 | static 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 | |
541 | serial_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 | |
597 | serial_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 | |
620 | serial_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)) |
655 | serial_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 | |
685 | serial_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 | |
701 | serial_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 | |
717 | void 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 | |
729 | serial_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 | |
745 | serial_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 | |