1 /*
2 * Copyright (c) 2022 Winner Microelectronics Co., Ltd. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "wm_debug.h"
17 #include "wm_regs.h"
18 #include "wm_params.h"
19 #include "wm_fwup.h"
20 #include "wm_uart_task.h"
21 #if (GCC_COMPILE==1)
22 #include "wm_cmdp_hostif_gcc.h"
23 #else
24 #endif
25 #include "wm_irq.h"
26 #include "utils.h"
27 #include "wm_config.h"
28 #include "wm_socket.h"
29 #include "wm_mem.h"
30 #include "wm_wl_task.h"
31 #include "wm_io.h"
32
33 #define ONE 1
34 #define TWO 2
35 #define THREE 3
36 #define FOUR 4
37 #define FIVE 5
38 #define EIGHT 8
39 #define TEN 10
40 #define TWELVE 12
41 #define SIXTEEN 16
42 #define FIFTY 50
43 #define ONE_HUNDRED 100
44 #define FIVE_HUNDRED_AND_TWELVE 512
45 #define ONE_THOUSAND 1000
46 #define ONE_MILLION 1000000
47
48 #if (TLS_CONFIG_HOSTIF && TLS_CONFIG_UART)
49
50 extern struct tls_uart_port uart_port[TWO];
51 struct tls_uart uart_st[TWO];
52 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
53 static u32 uart1_delaytime = 0;
54 #endif
55
56 #define UART_NET_SEND_DATA_SIZE 256 // 512
57
58 struct uart_tx_msg {
59 struct tls_uart *uart;
60 struct tls_hostif_tx_msg *tx_msg;
61 };
62
63 extern void tls_uart_set_fc_status(int uart_no,
64 TLS_UART_FLOW_CTRL_MODE_T status);
65 extern void tls_uart_free_tx_sent_data(struct tls_uart_port *port);
66 extern void tls_uart_tx_callback_register(u16 uart_no,
67 s16(*tx_callback) (struct tls_uart_port *port));
68
69 void uart_rx_timeout_handler(void *arg);
70 void uart_rx(struct tls_uart *uart);
71 void uart_tx(struct uart_tx_msg *tx_data);
uart_tx_event_finish_callback(void * arg)72 static void uart_tx_event_finish_callback(void *arg)
73 {
74 if (arg)
75 tls_mem_free(arg);
76 }
77
78 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
uart_tx_socket_finish_callback(void * arg)79 static void uart_tx_socket_finish_callback(void *arg)
80 {
81 if (arg) {
82 struct pbuf *p = (struct pbuf *) arg;
83 pbuf_free(p);
84 }
85 }
86 #endif
87
88 extern struct task_parameter wl_task_param_hostif;
uart_send_tx_msg(u8 hostif_mode,struct tls_hostif_tx_msg * tx_msg,bool is_event)89 static void uart_send_tx_msg(u8 hostif_mode, struct tls_hostif_tx_msg *tx_msg,
90 bool is_event)
91 {
92 struct uart_tx_msg *tx_data = NULL;
93 if (tx_msg == NULL)
94 return;
95 switch (hostif_mode) {
96 case HOSTIF_MODE_UART0:
97 if (uart_st[0].uart_port == NULL) {
98 free_tx_msg_buffer(tx_msg);
99 tls_mem_free(tx_msg);
100 return;
101 }
102 tx_data = tls_mem_alloc(sizeof(struct uart_tx_msg));
103 if (tx_data == NULL) {
104 free_tx_msg_buffer(tx_msg);
105 tls_mem_free(tx_msg);
106 return;
107 }
108 tx_data->tx_msg = tx_msg;
109 tx_data->uart = &uart_st[0];
110 if (tls_wl_task_callback(&wl_task_param_hostif, (start_routine) uart_tx, tx_data, 0)) {
111 TLS_DBGPRT_INFO("send tx msg error.\n");
112 free_tx_msg_buffer(tx_msg);
113 tls_mem_free(tx_msg);
114 tls_mem_free(tx_data);
115 return;
116 }
117 break;
118 case HOSTIF_MODE_UART1_LS:
119 case HOSTIF_MODE_UART1_HS:
120 if (uart_st[1].uart_port == NULL) {
121 free_tx_msg_buffer(tx_msg);
122 tls_mem_free(tx_msg);
123 return;
124 }
125 if (is_event && (hostif_mode != HOSTIF_MODE_UART1_HS || uart_st[1].cmd_mode != UART_RICMD_MODE)) {
126 free_tx_msg_buffer(tx_msg);
127 tls_mem_free(tx_msg);
128 return;
129 }
130 tx_data = tls_mem_alloc(sizeof(struct uart_tx_msg));
131 if (tx_data == NULL) {
132 free_tx_msg_buffer(tx_msg);
133 tls_mem_free(tx_msg);
134 return;
135 }
136 tx_data->tx_msg = tx_msg;
137 tx_data->uart = &uart_st[1];
138 if (tls_wl_task_callback(&wl_task_param_hostif, (start_routine) uart_tx, tx_data, 0)) {
139 TLS_DBGPRT_INFO("send tx msg error.\n");
140 free_tx_msg_buffer(tx_msg);
141 tls_mem_free(tx_msg);
142 tls_mem_free(tx_data);
143 return;
144 }
145 break;
146 default:
147 break;
148 }
149 }
150
uart_get_uart1_port(struct tls_uart_port ** uart1_port)151 static void uart_get_uart1_port(struct tls_uart_port **uart1_port)
152 {
153 *uart1_port = uart_st[1].uart_port;
154 }
155
uart_set_uart1_mode(u32 cmd_mode)156 static void uart_set_uart1_mode(u32 cmd_mode)
157 {
158 uart_st[1].cmd_mode = cmd_mode;
159 if (UART_TRANS_MODE == cmd_mode) {
160 tls_uart_set_fc_status(uart_st[1].uart_port->uart_no,
161 TLS_UART_FLOW_CTRL_HARDWARE);
162 } else {
163 tls_uart_set_fc_status(uart_st[1].uart_port->uart_no,
164 TLS_UART_FLOW_CTRL_NONE);
165 }
166 }
167
uart_set_uart0_mode(u32 cmd_mode)168 static void uart_set_uart0_mode(u32 cmd_mode)
169 {
170 uart_st[0].cmd_mode = cmd_mode;
171 if (UART_TRANS_MODE == cmd_mode) {
172 tls_uart_set_fc_status(uart_st[0].uart_port->uart_no,
173 TLS_UART_FLOW_CTRL_HARDWARE);
174 } else {
175 tls_uart_set_fc_status(uart_st[0].uart_port->uart_no,
176 TLS_UART_FLOW_CTRL_NONE);
177 }
178 }
179
uart_set_uart1_sock_param(u16 sksnd_cnt,bool rx_idle)180 static void uart_set_uart1_sock_param(u16 sksnd_cnt, bool rx_idle)
181 {
182 uart_st[1].sksnd_cnt = sksnd_cnt;
183 }
184
uart_tx_sent_callback(struct tls_uart_port * port)185 s16 uart_tx_sent_callback(struct tls_uart_port *port)
186 {
187 return tls_wl_task_callback_static(&wl_task_param_hostif,
188 (start_routine)
189 tls_uart_free_tx_sent_data, port, 0,
190 TLS_MSG_ID_UART_SENT_FREE);
191 }
192
tls_uart_init(void)193 void tls_uart_init(void)
194 {
195 struct tls_uart_options uart_opts;
196 struct tls_uart *uart;
197 struct tls_hostif *hif = tls_get_hostif();
198 struct tls_param_uart uart_cfg;
199
200 memset(uart_st, 0, TWO * sizeof(struct tls_uart));
201
202 /* init socket config */
203 tls_cmd_init_socket_cfg();
204 tls_cmd_register_set_uart0_mode(uart_set_uart0_mode);
205
206 /* setting uart0 */
207 if (WM_SUCCESS != tls_uart_port_init(TLS_UART_0, NULL, 0))
208 return;
209 tls_uart_tx_callback_register(TLS_UART_0, uart_tx_sent_callback);
210 uart = tls_uart_open(TLS_UART_0, TLS_UART_MODE_INT);
211 if (uart == NULL)
212 return;
213
214 uart->cmd_mode = UART_ATCMD_MODE;
215 hif->uart_send_tx_msg_callback = uart_send_tx_msg;
216 tls_param_get(TLS_PARAM_ID_UART, (void *) &uart_cfg, 0);
217 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
218 if (uart_cfg.baudrate) {
219 uart1_delaytime =
220 (UART_NET_SEND_DATA_SIZE * (TEN * ONE_MILLION / uart_cfg.baudrate) /
221 ONE_THOUSAND + FIVE);
222 } else {
223 uart1_delaytime = ONE_HUNDRED;
224 }
225 #endif
226 tls_cmd_register_get_uart1_port(uart_get_uart1_port);
227 tls_cmd_register_set_uart1_mode(uart_set_uart1_mode);
228 tls_cmd_register_set_uart1_sock_param(uart_set_uart1_sock_param);
229 if (hif->hostif_mode == HOSTIF_MODE_UART1_HS) {
230 /* 根据flash读取的参数配置串口寄存器 */
231 uart_opts.baudrate = uart_cfg.baudrate;
232 uart_opts.charlength = TLS_UART_CHSIZE_8BIT;
233 uart_opts.flow_ctrl = (enum TLS_UART_FLOW_CTRL_MODE) uart_cfg.flow;
234 uart_opts.paritytype = (enum TLS_UART_PMODE) uart_cfg.parity;
235 uart_opts.stopbits = (enum TLS_UART_STOPBITS) uart_cfg.stop_bits;
236
237 if (WM_SUCCESS != tls_uart_port_init(TLS_UART_1, &uart_opts, 0))
238 return;
239 tls_uart_tx_callback_register(TLS_UART_1, uart_tx_sent_callback);
240 uart = tls_uart_open(TLS_UART_1, TLS_UART_MODE_INT);
241 if (uart == NULL)
242 return;
243
244 uart->cmd_mode = UART_RICMD_MODE;
245 } else if (hif->hostif_mode == HOSTIF_MODE_UART1_LS) {
246 uart_opts.baudrate = uart_cfg.baudrate;
247 if (uart_cfg.charsize == 0) {
248 uart_opts.charlength = TLS_UART_CHSIZE_8BIT;
249 } else {
250 uart_opts.charlength = (TLS_UART_CHSIZE_T) uart_cfg.charsize;
251 }
252 uart_opts.flow_ctrl = (enum TLS_UART_FLOW_CTRL_MODE) uart_cfg.flow;
253 uart_opts.paritytype = (enum TLS_UART_PMODE) uart_cfg.parity;
254 uart_opts.stopbits = (enum TLS_UART_STOPBITS) uart_cfg.stop_bits;
255 if (WM_SUCCESS != tls_uart_port_init(TLS_UART_1, &uart_opts, 0))
256 return;
257 tls_uart_tx_callback_register(TLS_UART_1, uart_tx_sent_callback);
258 uart = tls_uart_open(TLS_UART_1, TLS_UART_MODE_INT);
259 if (uart == NULL)
260 return;
261 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
262 if (tls_cmd_get_auto_mode()) {
263 uart->cmd_mode = UART_TRANS_MODE;
264 tls_uart_set_fc_status(uart->uart_port->uart_no,
265 TLS_UART_FLOW_CTRL_HARDWARE);
266 } else
267 #endif /* TLS_CONFIG_SOCKET_RAW */
268 {
269 uart->cmd_mode = UART_ATCMD_MODE; // 指令模式关闭流控
270 tls_uart_set_fc_status(uart->uart_port->uart_no,
271 TLS_UART_FLOW_CTRL_NONE);
272 }
273 } else {
274 ;
275 }
276
277 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
278 tls_hostif_set_net_status_callback();
279 #endif
280 }
281
tls_uart0_task_rx_cb(u16 len,void * p)282 static s16 tls_uart0_task_rx_cb(u16 len, void *p)
283 {
284 struct tls_uart *uart = &uart_st[0];
285
286 if ((UART_TRANS_MODE == uart->cmd_mode)
287 && (uart->uart_port->plus_char_cnt == THREE)) {
288 uart->cmd_mode = UART_ATCMD_MODE;
289 tls_uart_set_fc_status(uart->uart_port->uart_no,
290 TLS_UART_FLOW_CTRL_NONE);
291 }
292
293 if (tls_wl_task_callback_static(&wl_task_param_hostif,
294 (start_routine) uart_rx,
295 uart,
296 0,
297 TLS_MSG_ID_UART0_RX)) {
298 return WM_FAILED;
299 }
300 return WM_SUCCESS;
301 }
302
tls_uart1_task_rx_cb(u16 len,void * p)303 s16 tls_uart1_task_rx_cb(u16 len, void *p)
304 {
305 struct tls_uart *uart = &uart_st[1];
306
307 if ((UART_TRANS_MODE == uart->cmd_mode)
308 && (uart->uart_port->plus_char_cnt == THREE)) {
309 uart->cmd_mode = UART_ATCMD_MODE;
310 tls_uart_set_fc_status(uart->uart_port->uart_no,
311 TLS_UART_FLOW_CTRL_NONE);
312 }
313
314 if (tls_wl_task_callback_static(&wl_task_param_hostif, (start_routine) uart_rx,
315 uart, 0, TLS_MSG_ID_UART1_RX)) {
316 return WM_FAILED;
317 }
318 return WM_SUCCESS;
319 }
320
tls_uart_open(u32 uart_no,TLS_UART_MODE_T uart_mode)321 struct tls_uart *tls_uart_open(u32 uart_no, TLS_UART_MODE_T uart_mode)
322 {
323 struct tls_uart *uart;
324 if (uart_no == TLS_UART_0) {
325 uart = &uart_st[0];
326 memset(uart, 0, sizeof(struct tls_uart));
327 uart->uart_port = &uart_port[0];
328 tls_uart_rx_callback_register(uart_no, tls_uart0_task_rx_cb, NULL);
329 } else if (uart_no == TLS_UART_1) {
330 uart = &uart_st[1];
331 memset(uart, 0, sizeof(struct tls_uart));
332 uart->uart_port = &uart_port[1];
333 tls_uart_rx_callback_register(uart_no, tls_uart1_task_rx_cb, NULL);
334 } else
335 return NULL;
336
337 uart->uart_port->uart_mode = uart_mode;
338 return uart;
339 }
340
tls_uart_close(struct tls_uart * uart)341 int tls_uart_close(struct tls_uart *uart)
342 {
343 return WM_FAILED;
344 }
345
find_atcmd_eol(u8 * src,u32 len)346 static u8 *find_atcmd_eol(u8 * src, u32 len)
347 {
348 u8 *p = NULL;
349 u8 *q = NULL;
350 p = memchr(src, '\r', len);
351 q = memchr(src, '\n', len);
352 if (p && q) {
353 if ((p - q) > 1) {
354 return q;
355 }
356 if ((q - p) > 1) {
357 return p;
358 }
359 if ((p - q) == 1) {
360 return p;
361 }
362 if ((q - p) == 1) {
363 return q;
364 }
365 return NULL;
366 }
367 if (p) {
368 return p;
369 }
370 if (q) {
371 return q;
372 }
373 return NULL;
374 }
375
modify_atcmd_tail(struct tls_uart_circ_buf * recv,u8 ** p)376 static void modify_atcmd_tail(struct tls_uart_circ_buf *recv, u8 ** p)
377 {
378 u32 cmd_len;
379
380 if (*p >= &recv->buf[recv->tail]) {
381 cmd_len = *p - &recv->buf[recv->tail];
382 } else {
383 cmd_len = *p + TLS_UART_RX_BUF_SIZE - &recv->buf[recv->tail];
384 }
385
386 if (cmd_len > FIVE_HUNDRED_AND_TWELVE) {
387 recv->tail = recv->head;
388 *p = NULL;
389 TLS_DBGPRT_INFO("EOF char find > 512 \r\n");
390 } else {
391 recv->tail = (recv->tail + cmd_len) & (TLS_UART_RX_BUF_SIZE - 1);
392 }
393 }
394
parse_atcmd_eol(struct tls_uart * uart)395 static u8 *parse_atcmd_eol(struct tls_uart *uart)
396 {
397 struct tls_uart_circ_buf *recv = &uart->uart_port->recv;
398 u8 *p = NULL;
399
400 /* jump to end of line */
401 if (recv->head > recv->tail) {
402 p = find_atcmd_eol((u8 *)&recv->buf[recv->tail], (u32)(recv->head - recv->tail));
403 if (p) {
404 modify_atcmd_tail(recv, &p);
405 }
406 } else {
407 p = find_atcmd_eol((u8 *)&recv->buf[recv->tail],
408 TLS_UART_RX_BUF_SIZE - recv->tail);
409 if (!p) {
410 p = find_atcmd_eol((u8 *)&recv->buf[0], recv->head);
411 if (p) {
412 modify_atcmd_tail(recv, &p);
413 }
414 } else {
415 modify_atcmd_tail(recv, &p);
416 }
417 }
418
419 /* jump over EOF char */
420 if ((recv->buf[recv->tail] == '\r') || (recv->buf[recv->tail] == '\n')) {
421 recv->tail = (recv->tail + 1) & (TLS_UART_RX_BUF_SIZE - 1);
422 }
423 return p;
424 }
425
parse_atcmd_line(struct tls_uart * uart)426 static void parse_atcmd_line(struct tls_uart *uart)
427 {
428 struct tls_uart_circ_buf *recv = &uart->uart_port->recv;
429 u8 *ptr_eol;
430 u32 cmd_len, tail_len = 0;
431 u8 *atcmd_start = NULL;
432 char *buf;
433 u8 hostif_uart_type;
434
435 while ((CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE) >= FOUR)
436 && (atcmd_start == NULL)) { /* check "at+" char */
437 if (((recv->buf[recv->tail] == 'A') || (recv->buf[recv->tail] == 'a'))
438 &&
439 ((recv->buf[(recv->tail + 1) & (TLS_UART_RX_BUF_SIZE - 1)] == 'T')
440 || (recv->buf[(recv->tail + 1) & (TLS_UART_RX_BUF_SIZE - 1)] ==
441 't'))
442 && (recv->buf[(recv->tail + TWO) & (TLS_UART_RX_BUF_SIZE - 1)] ==
443 '+')) {
444 atcmd_start = (u8 *)&recv->buf[recv->tail];
445 recv->tail = (recv->tail + THREE) & (TLS_UART_RX_BUF_SIZE - 1);
446 ptr_eol = parse_atcmd_eol(uart);
447 if (!ptr_eol) { /* no terminator, may receive only half a command */
448 if (CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE) > FIVE_HUNDRED_AND_TWELVE) {
449 recv->tail = recv->head;
450 } else {
451 recv->tail = (recv->tail - THREE) & (TLS_UART_RX_BUF_SIZE - 1);
452 }
453 break;
454 }
455
456 if (ptr_eol >= atcmd_start) { /* Getting the command length */
457 cmd_len = ptr_eol - atcmd_start;
458 } else {
459 tail_len = (u32) (&recv->buf[TLS_UART_RX_BUF_SIZE - 1] - atcmd_start + 1);
460 cmd_len = tail_len + (ptr_eol - &recv->buf[0]);
461 }
462
463 buf = tls_mem_alloc(cmd_len + TWO);
464 if (!buf) {
465 return;
466 }
467
468 if (ptr_eol >= atcmd_start) {
469 MEMCPY(buf, atcmd_start, cmd_len);
470 } else {
471 MEMCPY(buf, atcmd_start, tail_len);
472 MEMCPY(buf + tail_len, (void *)&recv->buf[0], ptr_eol - (u8 *)&recv->buf[0]);
473 }
474
475 if (buf[cmd_len - TWO] == '\r' || buf[cmd_len - TWO] == '\n') {
476 buf[cmd_len - TWO] = '\n';
477 buf[cmd_len - 1] = '\0';
478 cmd_len = cmd_len - 1;
479 } else if (buf[cmd_len - 1] == '\r' || buf[cmd_len - 1] == '\n') {
480 buf[cmd_len - 1] = '\n';
481 buf[cmd_len] = '\0';
482 cmd_len = cmd_len;
483 } else {
484 buf[cmd_len] = '\n';
485 buf[cmd_len + 1] = '\0';
486 cmd_len = cmd_len + 1;
487 }
488
489 if (uart->uart_port->uart_no == TLS_UART_0) {
490 hostif_uart_type = HOSTIF_UART0_AT_CMD;
491 } else {
492 hostif_uart_type = HOSTIF_UART1_AT_CMD;
493 }
494 tls_hostif_cmd_handler(hostif_uart_type, buf, cmd_len);
495 tls_mem_free(buf);
496 atcmd_start = NULL;
497 if (CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE) > 0) {
498 if (uart->uart_port->uart_no == TLS_UART_0) {
499 tls_uart0_task_rx_cb(CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE),
500 NULL);
501 } else {
502 tls_uart1_task_rx_cb(CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE),
503 NULL);
504 }
505 break;
506 }
507 } else {
508 recv->tail = (recv->tail + 1)%TLS_UART_RX_BUF_SIZE;
509 }
510 }
511 }
512
cache_tcp_recv(struct tls_hostif_tx_msg * tx_msg)513 static int cache_tcp_recv(struct tls_hostif_tx_msg *tx_msg)
514 {
515 struct tls_uart_circ_buf *precvmit =
516 tls_hostif_get_recvmit(tx_msg->u.msg_tcp.sock);
517 struct pbuf *p;
518 u16 buflen;
519 u16 copylen;
520 u32 tail = 0;
521 bool overflow = 0;
522
523 p = (struct pbuf *) tx_msg->u.msg_tcp.p;
524 if (p->tot_len >= TLS_SOCKET_RECV_BUF_SIZE) {
525 tx_msg->offset = p->tot_len - TLS_SOCKET_RECV_BUF_SIZE + 1;
526 }
527 TLS_DBGPRT_INFO("p->tot_len=%d\n", p->tot_len);
528 TLS_DBGPRT_INFO("precvmit->head=%d, precvmit->tail=%d\n", precvmit->head,
529 precvmit->tail);
530 buflen = p->tot_len - tx_msg->offset;
531 tail = precvmit->tail;
532 while (1) {
533 copylen = CIRC_SPACE_TO_END_FULL(precvmit->head,
534 tail, TLS_SOCKET_RECV_BUF_SIZE);
535 if (copylen == 0) {
536 tail = 0;
537 overflow = 1;
538 continue;
539 }
540 if (buflen < copylen)
541 copylen = buflen;
542 pbuf_copy_partial(p,
543 (u8 *)precvmit->buf + precvmit->head,
544 copylen, tx_msg->offset);
545 precvmit->head =
546 (precvmit->head + copylen) & (TLS_SOCKET_RECV_BUF_SIZE - 1);
547 TLS_DBGPRT_INFO("precvmit->head=%d, precvmit->tail=%d\n",
548 precvmit->head, precvmit->tail);
549 tx_msg->offset += copylen;
550 buflen -= copylen;
551 if (tx_msg->offset >= p->tot_len)
552 break;
553 };
554 if (overflow)
555 precvmit->tail = precvmit->head + 1;
556
557 /* Check whether the pbuf data is copied to the uart cache */
558 if (tx_msg->offset >= p->tot_len) {
559 pbuf_free(p);
560 }
561
562 return copylen;
563 }
564
565 /*
566 * 处理流程说明：
567 * 首先判断上次的同步帧是否已经处理完成，如果已经处理结束，
568 * 则检查缓存head指向的字节，判断是否是0xAA(SYN_FLAG)，
569 * 如果是，则检查缓存的长度是否大于等于8，如果不是
570 * 则返回，如果是，则提取字节标记和长度信息，校验信息，
571 * 计算校验和，检查校验值是否匹配，
572 */
ricmd_handle_sync(struct tls_uart * uart,struct tls_uart_circ_buf * recv)573 static int ricmd_handle_sync(struct tls_uart *uart, struct tls_uart_circ_buf *recv)
574 {
575 return 0;
576 }
577
data_loop(struct tls_uart * uart,int numbytes,struct tls_uart_circ_buf * recv)578 static int data_loop(struct tls_uart *uart,
579 int numbytes, struct tls_uart_circ_buf *recv)
580 {
581 return 0;
582 }
583
584 #define MAX_RICMD_LENGTH 200
585 u8 ricmd_buffer[MAX_RICMD_LENGTH + EIGHT];
586
cmd_loop(struct tls_uart * uart,int numbytes,struct tls_uart_circ_buf * recv)587 static int cmd_loop(struct tls_uart *uart,
588 int numbytes, struct tls_uart_circ_buf *recv)
589 {
590 unsigned cbytes = uart->ricmd_info.cbytes;
591 unsigned procbytes = 0;
592 unsigned char c;
593
594 while (procbytes < numbytes) {
595 c = recv->head;
596 procbytes++;
597
598 /* append to line buffer if possible */
599 if (cbytes < MAX_RICMD_LENGTH)
600 ricmd_buffer[EIGHT + cbytes] = c;
601 uart->ricmd_info.cbytes++;
602
603 if (uart->ricmd_info.cbytes == uart->ricmd_info.length) {
604 tls_hostif_cmd_handler(HOSTIF_UART1_RI_CMD,
605 (char *) ricmd_buffer,
606 uart->ricmd_info.length + EIGHT);
607 uart->ricmd_info.cbytes = 0;
608 uart->inputstate = 0;
609 break;
610 }
611 }
612 return procbytes;
613 }
614
parse_ricmd_line(struct tls_uart * uart)615 void parse_ricmd_line(struct tls_uart *uart)
616 {
617 struct tls_uart_circ_buf *recv = &uart->uart_port->recv;
618 int skip_count;
619 int numbytes;
620 int procbytes;
621
622 while (!uart_circ_empty(recv)) {
623 /* check for frame header */
624 skip_count = ricmd_handle_sync(uart, recv);
625 if ((skip_count == 0) && !(uart->inputstate & INS_SYNC_CHAR))
626 break;
627
628 if (uart->inputstate & INS_SYNC_CHAR) {
629 /* process a contiguous block of bytes */
630 numbytes = CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE);
631
632 if (uart->inputstate & INS_RICMD)
633 procbytes = cmd_loop(uart, numbytes, recv);
634 else if (uart->inputstate & INS_DATA)
635 procbytes = data_loop(uart, numbytes, recv);
636 else
637 procbytes = numbytes;
638 } else {
639 /* 没有需要处理的数据(第一个字符不是SYNC_FLAG)，而且以前的包已经处理完成 */
640 procbytes = skip_count;
641 }
642 recv->head = (recv->head + procbytes) & (TLS_UART_RX_BUF_SIZE - 1);
643 }
644
645 return;
646 }
647
648 #define UART_UPFW_DATA_SIZE sizeof(struct tls_fwup_block)
649
uart_fwup_rsp(u8 portno,int status)650 static int uart_fwup_rsp(u8 portno, int status)
651 {
652 char *cmd_rsp = NULL;
653 u32 len;
654 u8 hostif_type;
655
656 cmd_rsp = tls_mem_alloc(SIXTEEN);
657 if (cmd_rsp == NULL) {
658 return -1;
659 }
660 if (status) {
661 len = sprintf(cmd_rsp, "+OK=%d\r\n\r\n", status);
662 } else {
663 len = sprintf(cmd_rsp, "+ERR=%d\r\n\r\n", status);
664 }
665
666 if (TLS_UART_0 == portno) {
667 hostif_type = HOSTIF_MODE_UART0;
668 } else {
669 hostif_type = HOSTIF_MODE_UART1_LS;
670 }
671
672 if (tls_hostif_process_cmdrsp(hostif_type, cmd_rsp, len)) {
673 tls_mem_free(cmd_rsp);
674 }
675 return 0;
676 }
677
uart_fwup_send(struct tls_uart * uart)678 void uart_fwup_send(struct tls_uart *uart)
679 {
680 struct tls_uart_circ_buf *recv = &uart->uart_port->recv;
681 u32 data_cnt = CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE);
682 struct tls_fwup_block *pfwup = NULL;
683 u8 *p;
684 u32 i, session_id, status;
685
686 if (data_cnt >= UART_UPFW_DATA_SIZE) {
687 uart->cmd_mode = UART_ATCMD_MODE;
688 pfwup = (struct tls_fwup_block *) tls_mem_alloc(UART_UPFW_DATA_SIZE);
689 if (!pfwup) {
690 recv->tail = (recv->tail + UART_UPFW_DATA_SIZE) & (TLS_UART_RX_BUF_SIZE - 1);
691 return;
692 }
693 p = (u8 *) pfwup;
694 for (i = 0; i < UART_UPFW_DATA_SIZE; i++) {
695 *p++ = recv->buf[recv->tail++];
696 recv->tail &= TLS_UART_RX_BUF_SIZE - 1;
697 }
698 session_id = tls_fwup_get_current_session_id();
699 if (session_id) {
700 if (get_crc32((u8 *) pfwup, UART_UPFW_DATA_SIZE - TWELVE) == pfwup->crc32) {
701 if (tls_fwup_set_update_numer(pfwup->number) == TLS_FWUP_STATUS_OK) {
702 struct tls_fwup_block *blk;
703 u8 *buffer;
704 blk = (struct tls_fwup_block *)pfwup;
705 buffer = blk->data;
706 status = 1;
707 uart_fwup_rsp(uart->uart_port->uart_no, status);
708 tls_fwup_request_sync(session_id, buffer, TLS_FWUP_BLK_SIZE);
709 } else {
710 TLS_DBGPRT_INFO("tls_fwup_set_update_numer err!!!\r\n");
711 status = 0;
712 uart_fwup_rsp(uart->uart_port->uart_no, status);
713 }
714 } else {
715 TLS_DBGPRT_INFO("err crc32 !!!\r\n");
716 status = 0;
717 uart_fwup_rsp(uart->uart_port->uart_no, status);
718 }
719 }
720 tls_mem_free(pfwup);
721 }
722 }
723
724 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
uart_rx_timeout_handler(void * arg)725 void uart_rx_timeout_handler(void * arg)
726 {
727 int data_cnt;
728 struct tls_uart *uart = (struct tls_uart *)arg;
729 struct tls_uart_circ_buf *recv = &uart->uart_port->recv;
730
731 if (uart->cmd_mode == UART_TRANS_MODE) {
732 data_cnt = CIRC_CNT(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE);
733 if (data_cnt) {
734 uart_net_send(uart, recv->head, recv->tail, data_cnt);
735 }
736 }
737 }
738 #endif
739
uart_rx(struct tls_uart * uart)740 void uart_rx(struct tls_uart *uart)
741 {
742 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
743 struct tls_uart_circ_buf *recv = &uart->uart_port->recv;
744 int data_cnt;
745 u8 send_data = 0;
746 #endif
747 int err = 0;
748 u8 len = 0;
749 char *cmd_rsp = NULL;
750
751 if (uart->cmd_mode == UART_ATCMD_MODE) {
752 if (uart->uart_port->plus_char_cnt == THREE) {
753 cmd_rsp = tls_mem_alloc(strlen("+OK!!\r\n\r\n") + 1);
754 if (!cmd_rsp) {
755 return;
756 }
757 len = sprintf(cmd_rsp, "+OK!!\r\n\r\n");
758 uart->uart_port->plus_char_cnt = 0;
759 err = tls_hostif_process_cmdrsp(HOSTIF_MODE_UART1_LS, cmd_rsp, len);
760 if (err) {
761 tls_mem_free(cmd_rsp);
762 }
763 }
764 parse_atcmd_line(uart);
765 } else if (uart->cmd_mode == UART_ATDATA_MODE) {
766 uart_fwup_send(uart);
767 } else if (uart->cmd_mode == UART_RICMD_MODE) {
768 parse_ricmd_line(uart);
769 } else {
770 }
771 }
772
uart_tx(struct uart_tx_msg * tx_data)773 void uart_tx(struct uart_tx_msg *tx_data)
774 {
775 struct tls_uart *uart = tx_data->uart;
776 struct tls_hostif *hif = tls_get_hostif();
777 struct tls_hostif_tx_msg *tx_msg = tx_data->tx_msg;
778 u32 cpu_sr;
779 tls_uart_tx_msg_t *uart_tx_msg;
780 struct pbuf *p;
781
782 switch (tx_msg->type) {
783 case HOSTIF_TX_MSG_TYPE_EVENT:
784 case HOSTIF_TX_MSG_TYPE_CMDRSP:
785 tls_uart_fill_buf(uart->uart_port, tx_msg->u.msg_event.buf,
786 tx_msg->u.msg_event.buflen);
787 uart_tx_event_finish_callback(tx_msg->u.msg_event.buf);
788 tls_uart_tx_chars_start(uart->uart_port);
789 break;
790 #if TLS_CONFIG_SOCKET_RAW || TLS_CONFIG_SOCKET_STD
791 /* Tcp and Udp both use the below case. */
792 case HOSTIF_TX_MSG_TYPE_UDP:
793 case HOSTIF_TX_MSG_TYPE_TCP:
794 if (uart->cmd_mode == UART_TRANS_MODE || hif->rptmode) {
795 p = (struct pbuf *) tx_msg->u.msg_tcp.p;
796 uart_tx_msg = tls_mem_alloc(sizeof(tls_uart_tx_msg_t));
797 if (uart_tx_msg == NULL) {
798 uart_tx_socket_finish_callback(p);
799 goto out;
800 }
801 dl_list_init(&uart_tx_msg->list);
802 uart_tx_msg->buf = p->payload;
803 uart_tx_msg->buflen = p->tot_len;
804 uart_tx_msg->offset = 0;
805 uart_tx_msg->finish_callback = uart_tx_socket_finish_callback;
806 uart_tx_msg->callback_arg = p;
807
808 cpu_sr = tls_os_set_critical();
809 dl_list_add_tail(&uart->uart_port->tx_msg_pending_list,
810 &uart_tx_msg->list);
811 tls_os_release_critical(cpu_sr);
812 tls_uart_tx_chars_start(uart->uart_port);
813 } else {
814 cache_tcp_recv(tx_msg);
815 }
816 break;
817 #endif
818 default:
819 break;
820 }
821 out:
822 if (tx_msg)
823 tls_mem_free(tx_msg);
824 if (tx_data)
825 tls_mem_free(tx_data);
826 }
827 #endif /* CONFIG_UART */
828