1 /**
2 ****************************************************************************************
3 * @file app_uart.c
4 * @author BLE Driver Team
5 * @brief HAL APP module driver.
6 ****************************************************************************************
7 * @attention
8 #####Copyright (c) 2019 GOODIX
9 All rights reserved.
10
11 Redistribution and use in source and binary forms, with or without
12 modification, are permitted provided that the following conditions are met:
13 * Redistributions of source code must retain the above copyright
14 notice, this list of conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright
16 notice, this list of conditions and the following disclaimer in the
17 documentation and/or other materials provided with the distribution.
18 * Neither the name of GOODIX nor the names of its contributors may be used
19 to endorse or promote products derived from this software without
20 specific prior written permission.
21
22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
26 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 POSSIBILITY OF SUCH DAMAGE.
33 ****************************************************************************************
34 */
35
36 /*
37 * INCLUDE FILES
38 *****************************************************************************************
39 */
40 #include <string.h>
41 #include "platform_sdk.h"
42 #include "app_dma.h"
43 #include "app_pwr_mgmt.h"
44 #include "app_systick.h"
45 #include "app_uart.h"
46
47
48 /*
49 * DEFINES
50 *****************************************************************************************
51 */
52 #define TX_ONCE_MAX_SIZE 128
53
54 #define MS_5000 5000
55
56 /*
57 * STRUCT DEFINE
58 *****************************************************************************************
59 */
60
61 /**@brief App uart state types. */
62 typedef enum {
63 APP_UART_INVALID = 0,
64 APP_UART_ACTIVITY,
65 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
66 APP_UART_SLEEP,
67 #endif
68 } app_uart_state_t;
69
70 struct uart_env_t {
71 app_uart_evt_handler_t evt_handler;
72 uart_handle_t handle;
73 app_uart_mode_t use_mode;
74 app_uart_pin_cfg_t pin_cfg;
75 int16_t dma_id[2];
76 app_uart_state_t uart_state;
77 ring_buffer_t tx_ring_buffer;
78 uint8_t tx_send_buf[TX_ONCE_MAX_SIZE];
79 bool start_tx_flag;
80 bool start_flush_flag;
81 #ifdef ENV_RTOS_USE_SEMP
82 APP_DRV_SEM_DECL(sem_tx);
83 APP_DRV_SEM_DECL(sem_rx);
84 #endif
85
86 #ifdef ENV_RTOS_USE_MUTEX
87 APP_DRV_MUTEX_DECL(mutex_sync);
88 APP_DRV_MUTEX_DECL(mutex_async);
89 #endif
90 };
91
92 /*
93 * LOCAL FUNCTION DECLARATION
94 *****************************************************************************************
95 */
96 static bool uart_prepare_for_sleep(void);
97 static void uart_sleep_canceled(void);
98 static void uart_wake_up_ind(void);
99 static uint16_t uart_gpio_config(uint32_t hw_flow_ctrl, app_uart_pin_cfg_t pin_cfg);
100
101 /*
102 * LOCAL VARIABLE DEFINITIONS
103 *****************************************************************************************
104 */
105 static const IRQn_Type s_uart_irq[APP_UART_ID_MAX] = {UART0_IRQn, UART1_IRQn};
106 static const uint32_t s_uart_instance[APP_UART_ID_MAX] = {UART0_BASE, UART1_BASE};
107
108 struct uart_env_t s_uart_env[APP_UART_ID_MAX] = {
109 {
110 .evt_handler = NULL,
111 #ifdef ENV_RTOS_USE_SEMP
112 .sem_tx = NULL,
113 .sem_rx = NULL,
114 #endif
115 #ifdef ENV_RTOS_USE_MUTEX
116 .mutex_sync = NULL,
117 .mutex_async = NULL,
118 #endif
119 },
120 {
121 .evt_handler = NULL,
122 #ifdef ENV_RTOS_USE_SEMP
123 .sem_tx = NULL,
124 .sem_rx = NULL,
125 #endif
126 #ifdef ENV_RTOS_USE_MUTEX
127 .mutex_sync = NULL,
128 .mutex_async = NULL,
129 #endif
130 }
131 };
132 static bool s_sleep_cb_registered_flag = false;
133 static int16_t s_uart_pwr_id;
134
135 static const app_sleep_callbacks_t uart_sleep_cb = {
136 .app_prepare_for_sleep = uart_prepare_for_sleep,
137 .app_sleep_canceled = uart_sleep_canceled,
138 .app_wake_up_ind = uart_wake_up_ind,
139 };
140
141
142 #ifdef ENV_RTOS_USE_MUTEX
143 static inline void APP_UART_DRV_SYNC_MUTEX_LOCK(uint8_t id);
144 static inline void APP_UART_DRV_SYNC_MUTEX_UNLOCK(uint8_t id);
145 static inline void APP_UART_DRV_ASYNC_MUTEX_LOCK(uint8_t id);
146 static inline void APP_UART_DRV_ASYNC_MUTEX_UNLOCK(uint8_t id);
147
APP_UART_DRV_SYNC_MUTEX_LOCK(uint8_t id)148 static inline void APP_UART_DRV_SYNC_MUTEX_LOCK(uint8_t id)
149 {
150 app_driver_mutex_pend(s_uart_env[id].mutex_sync, MUTEX_WAIT_FOREVER);
151 }
152
APP_UART_DRV_SYNC_MUTEX_UNLOCK(uint8_t id)153 static inline void APP_UART_DRV_SYNC_MUTEX_UNLOCK(uint8_t id)
154 {
155 app_driver_mutex_post(s_uart_env[id].mutex_sync);
156 }
157
APP_UART_DRV_ASYNC_MUTEX_LOCK(uint8_t id)158 static inline void APP_UART_DRV_ASYNC_MUTEX_LOCK(uint8_t id)
159 {
160 app_driver_mutex_pend(s_uart_env[id].mutex_async, MUTEX_WAIT_FOREVER);
161 }
162
APP_UART_DRV_ASYNC_MUTEX_UNLOCK(uint8_t id)163 static inline void APP_UART_DRV_ASYNC_MUTEX_UNLOCK(uint8_t id)
164 {
165 app_driver_mutex_post(s_uart_env[id].mutex_async);
166 }
167 #endif
168 /*
169 * LOCAL FUNCTION DEFINITIONS
170 *****************************************************************************************
171 */
172
uart_prepare_for_sleep(void)173 static bool uart_prepare_for_sleep(void)
174 {
175 hal_uart_state_t state;
176
177 for (uint8_t i = 0; i < APP_UART_ID_MAX; i++) {
178 if (s_uart_env[i].uart_state == APP_UART_ACTIVITY) {
179 state = hal_uart_get_state(&s_uart_env[i].handle);
180 if ((state != HAL_UART_STATE_RESET) && (state != HAL_UART_STATE_READY)) {
181 return false;
182 }
183
184 GLOBAL_EXCEPTION_DISABLE();
185 hal_uart_suspend_reg(&s_uart_env[i].handle);
186 GLOBAL_EXCEPTION_ENABLE();
187 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
188 s_uart_env[i].uart_state = APP_UART_SLEEP;
189 #endif
190 }
191 }
192 return true;
193 }
194
195
uart_sleep_canceled(void)196 static void uart_sleep_canceled(void)
197 {
198 }
199
uart_wake_up_ind(void)200 SECTION_RAM_CODE static void uart_wake_up_ind(void)
201 {
202 #ifndef APP_DRIVER_WAKEUP_CALL_FUN
203 uint8_t i;
204
205 for (i = 0; i < APP_UART_ID_MAX; i++) {
206 if (s_uart_env[i].uart_state == APP_UART_ACTIVITY) {
207 GLOBAL_EXCEPTION_DISABLE();
208 hal_uart_resume_reg(&s_uart_env[i].handle);
209 GLOBAL_EXCEPTION_ENABLE();
210
211 if (s_uart_env[i].use_mode.type == APP_UART_TYPE_INTERRUPT ||
212 s_uart_env[i].use_mode.type == APP_UART_TYPE_DMA) {
213 hal_nvic_clear_pending_irq(s_uart_irq[i]);
214 hal_nvic_enable_irq(s_uart_irq[i]);
215 }
216 }
217 }
218 #endif
219 }
220
221 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
uart_wake_up(app_uart_id_t id)222 static void uart_wake_up(app_uart_id_t id)
223 {
224 if (s_uart_env[id].uart_state == APP_UART_SLEEP) {
225 GLOBAL_EXCEPTION_DISABLE();
226 hal_uart_resume_reg(&s_uart_env[id].handle);
227 GLOBAL_EXCEPTION_ENABLE();
228
229 if (s_uart_env[id].use_mode.type == APP_UART_TYPE_INTERRUPT ||
230 s_uart_env[id].use_mode.type == APP_UART_TYPE_DMA) {
231 hal_nvic_clear_pending_irq(s_uart_irq[id]);
232 hal_nvic_enable_irq(s_uart_irq[id]);
233 }
234 s_uart_env[id].uart_state = APP_UART_ACTIVITY;
235 }
236
237 if (s_uart_env[id].use_mode.type == APP_UART_TYPE_DMA) {
238 dma_wake_up(s_uart_env[id].dma_id[0]);
239 dma_wake_up(s_uart_env[id].dma_id[1]);
240 }
241 }
242 #endif
243
uart_gpio_config(uint32_t hw_flow_ctrl,app_uart_pin_cfg_t pin_cfg)244 static uint16_t uart_gpio_config(uint32_t hw_flow_ctrl, app_uart_pin_cfg_t pin_cfg)
245 {
246 app_io_init_t io_init = APP_IO_DEFAULT_CONFIG;
247 app_drv_err_t err_code = APP_DRV_SUCCESS;
248
249 io_init.pull = pin_cfg.tx.pull;
250 io_init.mode = APP_IO_MODE_MUX;
251 io_init.pin = pin_cfg.tx.pin;
252 io_init.mux = pin_cfg.tx.mux;
253 err_code = app_io_init(pin_cfg.tx.type, &io_init);
254 APP_DRV_ERR_CODE_CHECK(err_code);
255
256 io_init.pull = pin_cfg.rx.pull;
257 io_init.pin = pin_cfg.rx.pin;
258 io_init.mux = pin_cfg.rx.mux;
259 err_code = app_io_init(pin_cfg.rx.type, &io_init);
260 APP_DRV_ERR_CODE_CHECK(err_code);
261
262 if (UART_HWCONTROL_RTS_CTS == hw_flow_ctrl) {
263 io_init.pull = pin_cfg.cts.pull;
264 io_init.pin = pin_cfg.cts.pin;
265 io_init.mux = pin_cfg.cts.mux;
266 err_code = app_io_init(pin_cfg.cts.type, &io_init);
267 APP_DRV_ERR_CODE_CHECK(err_code);
268
269 io_init.pull = pin_cfg.rts.pull;
270 io_init.pin = pin_cfg.rts.pin;
271 io_init.mux = pin_cfg.rts.mux;
272 err_code = app_io_init(pin_cfg.rts.type, &io_init);
273 APP_DRV_ERR_CODE_CHECK(err_code);
274 }
275
276 return err_code;
277 }
278
app_uart_config_dma(app_uart_params_t * p_params)279 static uint16_t app_uart_config_dma(app_uart_params_t *p_params)
280 {
281 app_dma_params_t tx_dma_params;
282 app_dma_params_t rx_dma_params;
283
284 tx_dma_params.channel_number = p_params->use_mode.tx_dma_channel;
285 tx_dma_params.init.src_request = DMA_REQUEST_MEM;
286 tx_dma_params.init.dst_request = DMA_REQUEST_UART0_TX;
287 tx_dma_params.init.direction = DMA_MEMORY_TO_PERIPH;
288 tx_dma_params.init.src_increment = DMA_SRC_INCREMENT;
289 tx_dma_params.init.dst_increment = DMA_DST_NO_CHANGE;
290 tx_dma_params.init.src_data_alignment = DMA_SDATAALIGN_BYTE;
291 tx_dma_params.init.dst_data_alignment = DMA_DDATAALIGN_BYTE;
292 tx_dma_params.init.mode = DMA_NORMAL;
293 tx_dma_params.init.priority = DMA_PRIORITY_LOW;
294 s_uart_env[p_params->id].dma_id[0] = app_dma_init(&tx_dma_params, NULL);
295
296 if (s_uart_env[p_params->id].dma_id[0] < 0) {
297 return APP_DRV_ERR_INVALID_PARAM;
298 }
299
300 /* Associate the initialized DMA handle to the UART handle */
301 s_uart_env[p_params->id].handle.p_dmatx = app_dma_get_handle(s_uart_env[p_params->id].dma_id[0]);
302 s_uart_env[p_params->id].handle.p_dmatx->p_parent = (void*)&s_uart_env[p_params->id].handle;
303
304 rx_dma_params.channel_number = p_params->use_mode.rx_dma_channel;
305 rx_dma_params.init.src_request = DMA_REQUEST_UART0_RX;
306 rx_dma_params.init.dst_request = DMA_REQUEST_MEM;
307 rx_dma_params.init.direction = DMA_PERIPH_TO_MEMORY;
308 rx_dma_params.init.src_increment = DMA_SRC_NO_CHANGE;
309 rx_dma_params.init.dst_increment = DMA_DST_INCREMENT;
310 rx_dma_params.init.src_data_alignment = DMA_SDATAALIGN_BYTE;
311 rx_dma_params.init.dst_data_alignment = DMA_DDATAALIGN_BYTE;
312 rx_dma_params.init.mode = DMA_NORMAL;
313 rx_dma_params.init.priority = DMA_PRIORITY_HIGH;
314 s_uart_env[p_params->id].dma_id[1] = app_dma_init(&rx_dma_params, NULL);
315
316 if (s_uart_env[p_params->id].dma_id[1] < 0) {
317 return APP_DRV_ERR_INVALID_PARAM;
318 }
319
320 /* Associate the initialized DMA handle to the the UART handle */
321 s_uart_env[p_params->id].handle.p_dmarx = app_dma_get_handle(s_uart_env[p_params->id].dma_id[1]);
322 s_uart_env[p_params->id].handle.p_dmarx->p_parent = (void*)&s_uart_env[p_params->id].handle;
323
324 return APP_DRV_SUCCESS;
325 }
326
app_uart_start_transmit_async(app_uart_id_t id)327 static uint16_t app_uart_start_transmit_async(app_uart_id_t id)
328 {
329 uint16_t items_count = ring_buffer_items_count_get(&s_uart_env[id].tx_ring_buffer);
330 uint16_t send_size = items_count;
331 hal_status_t err_code;
332
333 if ((items_count == 0) || (s_uart_env[id].start_flush_flag == true)) {
334 s_uart_env[id].start_tx_flag = false;
335 return APP_DRV_SUCCESS;
336 }
337
338 if (items_count >= TX_ONCE_MAX_SIZE) {
339 ring_buffer_read(&s_uart_env[id].tx_ring_buffer, s_uart_env[id].tx_send_buf, TX_ONCE_MAX_SIZE);
340 send_size = TX_ONCE_MAX_SIZE;
341 } else {
342 ring_buffer_read(&s_uart_env[id].tx_ring_buffer, s_uart_env[id].tx_send_buf, items_count);
343 }
344
345 switch (s_uart_env[id].use_mode.type) {
346 case APP_UART_TYPE_INTERRUPT:
347 err_code = hal_uart_transmit_it(&s_uart_env[id].handle, s_uart_env[id].tx_send_buf, send_size);
348 HAL_ERR_CODE_CHECK(err_code);
349 break;
350
351 case APP_UART_TYPE_DMA:
352 err_code = hal_uart_transmit_dma(&s_uart_env[id].handle, s_uart_env[id].tx_send_buf, send_size);
353 HAL_ERR_CODE_CHECK(err_code);
354 break;
355
356 default:
357 break;
358 }
359
360 return APP_DRV_SUCCESS;
361 }
362
evt_handler_process(app_uart_id_t id,uart_handle_t * p_uart,app_uart_evt_type_t evt_type)363 static void evt_handler_process(app_uart_id_t id, uart_handle_t *p_uart, app_uart_evt_type_t evt_type)
364 {
365 app_uart_evt_t uart_evt;
366 uart_evt.type = evt_type;
367
368 if (evt_type == APP_UART_EVT_ERROR) {
369 uart_evt.data.error_code = p_uart->error_code;
370 #ifdef ENV_RTOS_USE_SEMP
371 app_driver_sem_post_from_isr(s_uart_env[id].sem_tx);
372 app_driver_sem_post_from_isr(s_uart_env[id].sem_rx);
373 #endif
374 s_uart_env[id].start_tx_flag = false;
375 if (s_uart_env[id].evt_handler != NULL) {
376 s_uart_env[id].evt_handler(&uart_evt);
377 }
378 } else if (evt_type == APP_UART_EVT_TX_CPLT) {
379 uart_evt.data.size = p_uart->tx_xfer_size - p_uart->tx_xfer_count;
380 app_uart_start_transmit_async(id);
381 #ifdef ENV_RTOS_USE_SEMP
382 if (s_uart_env[id].start_tx_flag == false) {
383 app_driver_sem_post_from_isr(s_uart_env[id].sem_tx);
384 }
385 #endif
386 if (s_uart_env[id].start_tx_flag == false && s_uart_env[id].evt_handler != NULL) {
387 s_uart_env[id].evt_handler(&uart_evt);
388 }
389 } else if (evt_type == APP_UART_EVT_RX_DATA) {
390 #ifdef ENV_RTOS_USE_SEMP
391 app_driver_sem_post_from_isr(s_uart_env[id].sem_rx);
392 #endif
393 uart_evt.data.size = p_uart->rx_xfer_size - p_uart->rx_xfer_count;
394 if (s_uart_env[id].evt_handler != NULL) {
395 s_uart_env[id].evt_handler(&uart_evt);
396 }
397 } else if (evt_type == APP_UART_EVT_ABORT_TX) {
398 #ifdef ENV_RTOS_USE_SEMP
399 app_driver_sem_post_from_isr(s_uart_env[id].sem_tx);
400 #endif
401 s_uart_env[id].start_tx_flag = false;
402 if (s_uart_env[id].evt_handler != NULL) {
403 s_uart_env[id].evt_handler(&uart_evt);
404 }
405 } else if (evt_type == APP_UART_EVT_ABORT_RX) {
406 #ifdef ENV_RTOS_USE_SEMP
407 app_driver_sem_post_from_isr(s_uart_env[id].sem_rx);
408 #endif
409 if (s_uart_env[id].evt_handler != NULL) {
410 s_uart_env[id].evt_handler(&uart_evt);
411 }
412 }
413 }
414
app_uart_event_call(uart_handle_t * p_uart,app_uart_evt_type_t evt_type)415 static void app_uart_event_call(uart_handle_t *p_uart, app_uart_evt_type_t evt_type)
416 {
417 app_uart_id_t id = APP_UART_ID_MAX;
418
419 if (p_uart->p_instance == UART0) {
420 id = APP_UART_ID_0;
421 } else if (p_uart->p_instance == UART1) {
422 id = APP_UART_ID_1;
423 }
424
425 evt_handler_process(id, p_uart, evt_type);
426 }
427
428 /*
429 * GLOBAL FUNCTION DEFINITIONS
430 ****************************************************************************************
431 */
params_check(app_uart_params_t * p_params,app_uart_tx_buf_t * tx_buffer)432 static uint16_t params_check(app_uart_params_t *p_params, app_uart_tx_buf_t *tx_buffer)
433 {
434 uint8_t id = p_params->id;
435
436 if (p_params == NULL) {
437 return APP_DRV_ERR_POINTER_NULL;
438 }
439
440 if (id >= APP_UART_ID_MAX) {
441 return APP_DRV_ERR_INVALID_ID;
442 }
443
444 if (p_params->use_mode.type != APP_UART_TYPE_POLLING && tx_buffer == NULL) {
445 return APP_DRV_ERR_INVALID_PARAM;
446 }
447
448 return APP_DRV_SUCCESS;
449 }
450
451 #ifdef ENV_RTOS_USE_SEMP
semp_init_config(uint8_t id)452 static uint16_t semp_init_config(uint8_t id)
453 {
454 app_drv_err_t err_code = APP_DRV_SUCCESS;
455
456 if (s_uart_env[id].sem_tx == NULL) {
457 err_code = app_driver_sem_init(&s_uart_env[id].sem_tx);
458 APP_DRV_ERR_CODE_CHECK(err_code);
459 }
460 if (s_uart_env[id].sem_rx == NULL) {
461 err_code = app_driver_sem_init(&s_uart_env[id].sem_rx);
462 APP_DRV_ERR_CODE_CHECK(err_code);
463 }
464
465 return APP_DRV_SUCCESS;
466 }
467 #endif
468
469 #ifdef ENV_RTOS_USE_MUTEX
mutex_init_config(uint8_t id)470 static uint16_t mutex_init_config(uint8_t id)
471 {
472 app_drv_err_t err_code = APP_DRV_SUCCESS;
473
474 if (s_uart_env[id].mutex_async == NULL) {
475 err_code = app_driver_mutex_init(&s_uart_env[id].mutex_async);
476 APP_DRV_ERR_CODE_CHECK(err_code);
477 }
478 if (s_uart_env[id].mutex_sync == NULL) {
479 err_code = app_driver_mutex_init(&s_uart_env[id].mutex_sync);
480 APP_DRV_ERR_CODE_CHECK(err_code);
481 }
482
483 return APP_DRV_SUCCESS;
484 }
485 #endif
486
sync_params_to_env(app_uart_params_t * p_params,app_uart_evt_handler_t evt_handler,uint8_t id)487 static void sync_params_to_env(app_uart_params_t *p_params, app_uart_evt_handler_t evt_handler, uint8_t id)
488 {
489 s_uart_env[id].use_mode.type = p_params->use_mode.type;
490 s_uart_env[id].use_mode.rx_dma_channel = p_params->use_mode.rx_dma_channel;
491 s_uart_env[id].use_mode.tx_dma_channel = p_params->use_mode.tx_dma_channel;
492 memcpy_s(&s_uart_env[id].pin_cfg, sizeof(s_uart_env[id].pin_cfg), &p_params->pin_cfg, sizeof(app_uart_pin_cfg_t));
493 s_uart_env[id].evt_handler = evt_handler;
494
495 memcpy_s(&s_uart_env[id].handle.init, sizeof(s_uart_env[id].handle.init), &p_params->init, sizeof(uart_init_t));
496 s_uart_env[id].handle.p_instance = (uart_regs_t *)s_uart_instance[id];
497 }
498
register_cb(void)499 static uint16_t register_cb(void)
500 {
501 if (s_sleep_cb_registered_flag == false) { // register sleep callback
502 s_sleep_cb_registered_flag = true;
503 s_uart_pwr_id = pwr_register_sleep_cb(&uart_sleep_cb, APP_DRIVER_UART_WAPEUP_PRIORITY);
504 if (s_uart_pwr_id < 0) {
505 return APP_DRV_ERR_INVALID_PARAM;
506 }
507 }
508 return APP_DRV_SUCCESS;
509 }
510
uart_dma_config(app_uart_params_t * p_params,uint8_t id)511 static uint16_t uart_dma_config(app_uart_params_t *p_params, uint8_t id)
512 {
513 app_drv_err_t err_code = APP_DRV_SUCCESS;
514
515 if (id != APP_UART_ID_0) {
516 return APP_DRV_ERR_INVALID_ID;
517 } else {
518 GLOBAL_EXCEPTION_DISABLE();
519 err_code = app_uart_config_dma(p_params);
520 GLOBAL_EXCEPTION_ENABLE();
521 APP_DRV_ERR_CODE_CHECK(err_code);
522 }
523
524 return APP_DRV_SUCCESS;
525 }
526
app_uart_init(app_uart_params_t * p_params,app_uart_evt_handler_t evt_handler,app_uart_tx_buf_t * tx_buffer)527 uint16_t app_uart_init(app_uart_params_t *p_params, app_uart_evt_handler_t evt_handler, app_uart_tx_buf_t *tx_buffer)
528 {
529 uint8_t id = p_params->id;
530 app_drv_err_t err_code = APP_DRV_SUCCESS;
531
532 err_code = params_check(p_params, tx_buffer);
533 APP_DRV_ERR_CODE_CHECK(err_code);
534
535 #ifdef ENV_RTOS_USE_SEMP
536 err_code = semp_init_config(id);
537 APP_DRV_ERR_CODE_CHECK(err_code);
538 #endif
539
540 #ifdef ENV_RTOS_USE_MUTEX
541 err_code = mutex_init_config(id);
542 APP_DRV_ERR_CODE_CHECK(err_code);
543 #endif
544
545 app_systick_init();
546
547 err_code = uart_gpio_config(p_params->init.hw_flow_ctrl, p_params->pin_cfg);
548 APP_DRV_ERR_CODE_CHECK(err_code);
549
550 if (APP_UART_TYPE_DMA == p_params->use_mode.type) {
551 err_code = uart_dma_config(p_params, id);
552 APP_DRV_ERR_CODE_CHECK(err_code);
553 }
554
555 if (p_params->use_mode.type != APP_UART_TYPE_POLLING) {
556 ring_buffer_init(&s_uart_env[id].tx_ring_buffer, tx_buffer->tx_buf, tx_buffer->tx_buf_size);
557 hal_nvic_clear_pending_irq(s_uart_irq[id]);
558 hal_nvic_enable_irq(s_uart_irq[id]);
559 }
560
561 sync_params_to_env(p_params, evt_handler, id);
562
563 hal_uart_deinit(&s_uart_env[id].handle);
564 hal_uart_init(&s_uart_env[id].handle);
565
566 err_code = register_cb();
567 APP_DRV_ERR_CODE_CHECK(err_code);
568
569 s_uart_env[id].uart_state = APP_UART_ACTIVITY;
570 return APP_DRV_SUCCESS;
571 }
572
573 #ifdef ENV_RTOS_USE_SEMP
semp_deinit_config(uint8_t id)574 static uint16_t semp_deinit_config(uint8_t id)
575 {
576 app_drv_err_t err_code = APP_DRV_SUCCESS;
577
578 if (s_uart_env[id].sem_tx == NULL) {
579 err_code = app_driver_sem_deinit(&s_uart_env[id].sem_tx);
580 APP_DRV_ERR_CODE_CHECK(err_code);
581 }
582 if (s_uart_env[id].sem_rx == NULL) {
583 err_code = app_driver_sem_deinit(&s_uart_env[id].sem_rx);
584 APP_DRV_ERR_CODE_CHECK(err_code);
585 }
586
587 return APP_DRV_SUCCESS;
588 }
589 #endif
590
591 #ifdef ENV_RTOS_USE_MUTEX
mutex_deinit_config(uint8_t id)592 static uint16_t mutex_deinit_config(uint8_t id)
593 {
594 app_drv_err_t err_code = APP_DRV_SUCCESS;
595
596 if (s_uart_env[id].mutex_async == NULL) {
597 err_code = app_driver_mutex_deinit(&s_uart_env[id].mutex_async);
598 APP_DRV_ERR_CODE_CHECK(err_code);
599 }
600 if (s_uart_env[id].mutex_sync == NULL) {
601 err_code = app_driver_mutex_deinit(&s_uart_env[id].mutex_sync);
602 APP_DRV_ERR_CODE_CHECK(err_code);
603 }
604
605 return APP_DRV_SUCCESS;
606 }
607 #endif
608
unregister_cb(void)609 static void unregister_cb(void)
610 {
611 GLOBAL_EXCEPTION_DISABLE();
612 if (s_uart_env[APP_UART_ID_0].uart_state == APP_UART_INVALID &&
613 s_uart_env[APP_UART_ID_1].uart_state == APP_UART_INVALID) {
614 pwr_unregister_sleep_cb(s_uart_pwr_id);
615 s_sleep_cb_registered_flag = false;
616 }
617 GLOBAL_EXCEPTION_ENABLE();
618 }
619
app_uart_deinit(app_uart_id_t id)620 uint16_t app_uart_deinit(app_uart_id_t id)
621 {
622 app_drv_err_t err_code = APP_DRV_SUCCESS;
623
624 if ((id >= APP_UART_ID_MAX) || (s_uart_env[id].uart_state == APP_UART_INVALID)) {
625 return APP_DRV_ERR_INVALID_ID;
626 }
627
628 #ifdef ENV_RTOS_USE_SEMP
629 err_code = semp_deinit_config(id);
630 APP_DRV_ERR_CODE_CHECK(err_code);
631 #endif
632
633 #ifdef ENV_RTOS_USE_MUTEX
634 err_code = mutex_deinit_config(id);
635 APP_DRV_ERR_CODE_CHECK(err_code);
636 #endif
637
638 err_code = app_io_deinit(s_uart_env[id].pin_cfg.tx.type, s_uart_env[id].pin_cfg.tx.pin);
639 APP_DRV_ERR_CODE_CHECK(err_code);
640
641 err_code = app_io_deinit(s_uart_env[id].pin_cfg.rx.type, s_uart_env[id].pin_cfg.rx.pin);
642 APP_DRV_ERR_CODE_CHECK(err_code);
643
644 if (UART_HWCONTROL_RTS_CTS == s_uart_env[id].handle.init.hw_flow_ctrl) {
645 err_code = app_io_deinit(s_uart_env[id].pin_cfg.rts.type, s_uart_env[id].pin_cfg.rts.pin);
646 APP_DRV_ERR_CODE_CHECK(err_code);
647
648 err_code = app_io_deinit(s_uart_env[id].pin_cfg.cts.type, s_uart_env[id].pin_cfg.cts.pin);
649 APP_DRV_ERR_CODE_CHECK(err_code);
650 }
651
652 hal_nvic_disable_irq(s_uart_irq[id]);
653
654 if (s_uart_env[id].use_mode.type == APP_UART_TYPE_DMA) {
655 err_code = app_dma_deinit(s_uart_env[id].dma_id[0]);
656 APP_DRV_ERR_CODE_CHECK(err_code);
657
658 err_code = app_dma_deinit(s_uart_env[id].dma_id[1]);
659 APP_DRV_ERR_CODE_CHECK(err_code);
660 }
661
662 s_uart_env[id].uart_state = APP_UART_INVALID;
663 s_uart_env[id].start_tx_flag = false;
664 s_uart_env[id].start_flush_flag = false;
665
666 unregister_cb();
667
668 app_systick_deinit();
669
670 hal_uart_deinit(&s_uart_env[id].handle);
671
672 return APP_DRV_SUCCESS;
673 }
674
app_uart_receive_async(app_uart_id_t id,uint8_t * p_data,uint16_t size)675 uint16_t app_uart_receive_async(app_uart_id_t id, uint8_t *p_data, uint16_t size)
676 {
677 hal_status_t err_code = HAL_OK;
678
679 if (id >= APP_UART_ID_MAX ||
680 p_data == NULL ||
681 size == 0 ||
682 s_uart_env[id].uart_state == APP_UART_INVALID) {
683 return APP_DRV_ERR_INVALID_PARAM;
684 }
685
686 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
687 uart_wake_up(id);
688 #endif
689
690 switch (s_uart_env[id].use_mode.type) {
691 case APP_UART_TYPE_INTERRUPT:
692 err_code = hal_uart_receive_it(&s_uart_env[id].handle, p_data, size);
693 break;
694
695 case APP_UART_TYPE_DMA:
696 err_code = hal_uart_receive_dma(&s_uart_env[id].handle, p_data, size);
697 break;
698
699 case APP_UART_TYPE_POLLING:
700 break;
701
702 default:
703 break;
704 }
705 if (err_code != HAL_OK) {
706 return (uint16_t)err_code;
707 }
708
709 return APP_DRV_SUCCESS;
710 }
711
app_uart_receive_sync(app_uart_id_t id,uint8_t * p_data,uint16_t size,uint32_t timeout)712 uint16_t app_uart_receive_sync(app_uart_id_t id, uint8_t *p_data, uint16_t size, uint32_t timeout)
713 {
714 hal_status_t err_code;
715
716 if (id >= APP_UART_ID_MAX ||
717 p_data == NULL ||
718 size == 0 ||
719 s_uart_env[id].uart_state == APP_UART_INVALID) {
720 return APP_DRV_ERR_INVALID_PARAM;
721 }
722
723 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
724 uart_wake_up(id);
725 #endif
726
727 err_code = hal_uart_receive(&s_uart_env[id].handle, p_data, size, timeout);
728 if (err_code != HAL_OK) {
729 return (uint16_t)err_code;
730 }
731
732 return APP_DRV_SUCCESS;
733 }
734
735 #ifdef ENV_RTOS_USE_SEMP
app_uart_receive_sem_sync(app_uart_id_t id,uint8_t * p_data,uint16_t size)736 uint16_t app_uart_receive_sem_sync(app_uart_id_t id, uint8_t *p_data, uint16_t size)
737 {
738 hal_status_t err_code = HAL_OK;
739
740 #ifdef ENV_RTOS_USE_MUTEX
741 APP_UART_DRV_ASYNC_MUTEX_LOCK(id);
742 #endif
743
744 if (id >= APP_UART_ID_MAX ||
745 p_data == NULL ||
746 size == 0 ||
747 s_uart_env[id].uart_state == APP_UART_INVALID) {
748 #ifdef ENV_RTOS_USE_MUTEX
749 APP_UART_DRV_ASYNC_MUTEX_UNLOCK(id);
750 #endif
751 return APP_DRV_ERR_INVALID_PARAM;
752 }
753
754 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
755 uart_wake_up(id);
756 #endif
757
758 switch (s_uart_env[id].use_mode.type) {
759 case APP_UART_TYPE_INTERRUPT:
760 err_code = hal_uart_receive_it(&s_uart_env[id].handle, p_data, size);
761 break;
762
763 case APP_UART_TYPE_DMA:
764 err_code = hal_uart_receive_dma(&s_uart_env[id].handle, p_data, size);
765 break;
766
767 case APP_UART_TYPE_POLLING:
768 break;
769
770 default:
771 break;
772 }
773 if (err_code != HAL_OK) {
774 #ifdef ENV_RTOS_USE_MUTEX
775 APP_UART_DRV_ASYNC_MUTEX_UNLOCK(id);
776 #endif
777 return (uint16_t)err_code;
778 }
779
780 app_driver_sem_pend(s_uart_env[id].sem_rx, OS_WAIT_FOREVER);
781
782 #ifdef ENV_RTOS_USE_MUTEX
783 APP_UART_DRV_ASYNC_MUTEX_UNLOCK(id);
784 #endif
785
786 return APP_DRV_SUCCESS;
787 }
788 #endif
789
app_uart_transmit_async(app_uart_id_t id,uint8_t * p_data,uint16_t size)790 uint16_t app_uart_transmit_async(app_uart_id_t id, uint8_t *p_data, uint16_t size)
791 {
792 uint16_t err_code;
793
794 if (id >= APP_UART_ID_MAX ||
795 p_data == NULL ||
796 size == 0 ||
797 s_uart_env[id].uart_state == APP_UART_INVALID) {
798 return APP_DRV_ERR_INVALID_PARAM;
799 }
800
801 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
802 uart_wake_up(id);
803 #endif
804
805 ring_buffer_write(&s_uart_env[id].tx_ring_buffer, p_data, size);
806
807 if ((s_uart_env[id].start_tx_flag == false) && (s_uart_env[id].start_flush_flag == false) &&
808 (s_uart_env[id].uart_state == APP_UART_ACTIVITY) &&
809 ll_uart_is_enabled_fifo(s_uart_env[id].handle.p_instance)) {
810 s_uart_env[id].start_tx_flag = true;
811
812 err_code = app_uart_start_transmit_async(id);
813 if (err_code != APP_DRV_SUCCESS) {
814 s_uart_env[id].start_tx_flag = false;
815 return err_code;
816 }
817 }
818
819 return APP_DRV_SUCCESS;
820 }
821
822 #ifdef ENV_RTOS_USE_SEMP
app_uart_transmit_sem_sync(app_uart_id_t id,uint8_t * p_data,uint16_t size)823 uint16_t app_uart_transmit_sem_sync(app_uart_id_t id, uint8_t *p_data, uint16_t size)
824 {
825 uint16_t err_code;
826
827 #ifdef ENV_RTOS_USE_MUTEX
828 APP_UART_DRV_ASYNC_MUTEX_LOCK(id);
829 #endif
830
831 if (id >= APP_UART_ID_MAX ||
832 p_data == NULL ||
833 size == 0 ||
834 s_uart_env[id].uart_state == APP_UART_INVALID) {
835 #ifdef ENV_RTOS_USE_MUTEX
836 APP_UART_DRV_ASYNC_MUTEX_UNLOCK(id);
837 #endif
838 return APP_DRV_ERR_INVALID_PARAM;
839 }
840
841 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
842 uart_wake_up(id);
843 #endif
844
845 ring_buffer_write(&s_uart_env[id].tx_ring_buffer, p_data, size);
846
847 if ((s_uart_env[id].start_tx_flag == false) && (s_uart_env[id].start_flush_flag == false) &&
848 (s_uart_env[id].uart_state == APP_UART_ACTIVITY) &&
849 ll_uart_is_enabled_fifo(s_uart_env[id].handle.p_instance)) {
850 s_uart_env[id].start_tx_flag = true;
851
852 err_code = app_uart_start_transmit_async(id);
853 if (err_code != APP_DRV_SUCCESS) {
854 #ifdef ENV_RTOS_USE_MUTEX
855 APP_UART_DRV_ASYNC_MUTEX_UNLOCK(id);
856 #endif
857 s_uart_env[id].start_tx_flag = false;
858 return err_code;
859 }
860
861 app_driver_sem_pend(s_uart_env[id].sem_tx, OS_WAIT_FOREVER);
862 }
863
864 #ifdef ENV_RTOS_USE_MUTEX
865 APP_UART_DRV_ASYNC_MUTEX_UNLOCK(id);
866 #endif
867
868 return APP_DRV_SUCCESS;
869 }
870 #endif
871
app_uart_transmit_sync(app_uart_id_t id,uint8_t * p_data,uint16_t size,uint32_t timeout)872 uint16_t app_uart_transmit_sync(app_uart_id_t id, uint8_t *p_data, uint16_t size, uint32_t timeout)
873 {
874 hal_status_t err_code;
875
876 if (id >= APP_UART_ID_MAX ||
877 p_data == NULL ||
878 size == 0 ||
879 s_uart_env[id].uart_state == APP_UART_INVALID) {
880 return APP_DRV_ERR_INVALID_PARAM;
881 }
882
883 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
884 uart_wake_up(id);
885 #endif
886
887 err_code = hal_uart_transmit(&s_uart_env[id].handle, p_data, size, timeout);
888 if (err_code != HAL_OK) {
889 return err_code;
890 }
891
892 return APP_DRV_SUCCESS;
893 }
894
app_uart_get_handle(app_uart_id_t id)895 uart_handle_t *app_uart_get_handle(app_uart_id_t id)
896 {
897 if (id >= APP_UART_ID_MAX || s_uart_env[id].uart_state == APP_UART_INVALID) {
898 return NULL;
899 }
900
901 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
902 uart_wake_up(id);
903 #endif
904
905 return &s_uart_env[id].handle;
906 }
907
flush_process(app_uart_id_t id)908 static void flush_process(app_uart_id_t id)
909 {
910 uint16_t items_count;
911
912 if (APP_UART_TYPE_POLLING != s_uart_env[id].use_mode.type) {
913 uint16_t tx_xfer_size = 0;
914 uint16_t tx_xfer_count = 0;
915 uint32_t tx_wait_count = 0;
916 uint32_t data_width = 1 + s_uart_env[id].handle.init.data_bits + \
917 5 + s_uart_env[id].handle.init.stop_bits + 1 + \
918 (s_uart_env[id].handle.init.parity & 1);
919
920 while (!ll_uart_is_active_flag_tfe(s_uart_env[id].handle.p_instance));
921
922 if (APP_UART_TYPE_INTERRUPT == s_uart_env[id].use_mode.type) {
923 tx_xfer_size = s_uart_env[id].handle.tx_xfer_size;
924 tx_xfer_count = s_uart_env[id].handle.tx_xfer_count;
925 hal_uart_abort_transmit_it(&s_uart_env[id].handle);
926 hal_uart_transmit(&s_uart_env[id].handle,
927 s_uart_env[id].tx_send_buf + tx_xfer_size - tx_xfer_count,
928 tx_xfer_count,
929 MS_5000);
930 } else {
931 do {
932 tx_wait_count++;
933 } while (HAL_UART_STATE_READY != hal_uart_get_state(&s_uart_env[id].handle) &&
934 (tx_wait_count <= data_width * TX_ONCE_MAX_SIZE * \
935 (SystemCoreClock/s_uart_env[id].handle.init.baud_rate)));
936 }
937
938 do {
939 items_count = ring_buffer_items_count_get(&s_uart_env[id].tx_ring_buffer);
940 while (items_count) {
941 uint8_t send_char;
942
943 ring_buffer_read(&s_uart_env[id].tx_ring_buffer, &send_char, 1);
944
945 while (!ll_uart_is_active_flag_tfnf(s_uart_env[id].handle.p_instance));
946
947 ll_uart_transmit_data8(s_uart_env[id].handle.p_instance, send_char);
948
949 items_count--;
950 }
951 } while (ring_buffer_items_count_get(&s_uart_env[id].tx_ring_buffer));
952 }
953 }
954
app_uart_flush(app_uart_id_t id)955 void app_uart_flush(app_uart_id_t id)
956 {
957 uart_handle_t *p_uart = &s_uart_env[id].handle;
958
959 if (APP_UART_ID_MAX <= id || s_uart_env[id].uart_state == APP_UART_INVALID) {
960 return;
961 }
962
963 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
964 uart_wake_up(id);
965 #endif
966
967 app_systick_init();
968
969 if (s_uart_env[id].uart_state == APP_UART_ACTIVITY) {
970 s_uart_env[id].start_flush_flag = true;
971
972 flush_process(id);
973
974 while (!ll_uart_is_active_flag_tfe(s_uart_env[id].handle.p_instance));
975
976 if (APP_UART_TYPE_POLLING != s_uart_env[id].use_mode.type) {
977 /* Enable the UART Transmit Data Register Empty Interrupt */
978 __HAL_UART_ENABLE_IT(p_uart, UART_IT_THRE);
979 }
980
981 s_uart_env[id].start_flush_flag = false;
982 }
983 }
984
hal_uart_tx_cplt_callback(uart_handle_t * p_uart)985 void hal_uart_tx_cplt_callback(uart_handle_t *p_uart)
986 {
987 app_uart_event_call(p_uart, APP_UART_EVT_TX_CPLT);
988 }
989
hal_uart_rx_cplt_callback(uart_handle_t * p_uart)990 void hal_uart_rx_cplt_callback(uart_handle_t *p_uart)
991 {
992 app_uart_event_call(p_uart, APP_UART_EVT_RX_DATA);
993 }
994
hal_uart_error_callback(uart_handle_t * p_uart)995 void hal_uart_error_callback(uart_handle_t *p_uart)
996 {
997 app_uart_event_call(p_uart, APP_UART_EVT_ERROR);
998 }
999
hal_uart_abort_tx_cplt_callback(uart_handle_t * p_uart)1000 void hal_uart_abort_tx_cplt_callback(uart_handle_t *p_uart)
1001 {
1002 app_uart_event_call(p_uart, APP_UART_EVT_ABORT_TX);
1003 }
1004
hal_uart_abort_rx_cplt_callback(uart_handle_t * p_uart)1005 void hal_uart_abort_rx_cplt_callback(uart_handle_t *p_uart)
1006 {
1007 app_uart_event_call(p_uart, APP_UART_EVT_ABORT_RX);
1008 }
1009
UART0_IRQHandler(void)1010 SECTION_RAM_CODE void UART0_IRQHandler(void)
1011 {
1012 #if FLASH_PROTECT_PRIORITY
1013 platform_interrupt_protection_push();
1014 #endif
1015 hal_uart_irq_handler(&s_uart_env[APP_UART_ID_0].handle);
1016 #if FLASH_PROTECT_PRIORITY
1017 platform_interrupt_protection_pop();
1018 #endif
1019 }
1020
UART1_IRQHandler(void)1021 SECTION_RAM_CODE void UART1_IRQHandler(void)
1022 {
1023 #if FLASH_PROTECT_PRIORITY
1024 platform_interrupt_protection_push();
1025 #endif
1026 hal_uart_irq_handler(&s_uart_env[APP_UART_ID_1].handle);
1027 #if FLASH_PROTECT_PRIORITY
1028 platform_interrupt_protection_pop();
1029 #endif
1030 }
1031
1032