1 /******************************************************************************
2 *
3 * Copyright (C) 2009-2018 Realtek Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * Filename: userial_vendor.c
22 *
23 * Description: Contains vendor-specific userial functions
24 *
25 ******************************************************************************/
26 #undef NDEBUG
27 #define LOG_TAG "bt_userial_vendor"
28
29 #include <utils/Log.h>
30 #include <termios.h>
31 #include <fcntl.h>
32 #include <errno.h>
33 #include <stdio.h>
34 #include <sys/eventfd.h>
35 #include "userial.h"
36 #include "userial_vendor.h"
37 #include "rtk_socket.h"
38 #include <sys/socket.h>
39
40 #ifdef CONFIG_SCO_OVER_HCI
41 #include "sbc.h"
42 #endif
43 /******************************************************************************
44 ** Constants & Macros
45 ******************************************************************************/
46
47 #ifndef VNDUSERIAL_DBG
48 #define VNDUSERIAL_DBG TRUE
49 #endif
50
51 #if (VNDUSERIAL_DBG == TRUE)
52 #define VNDUSERIALDBG(param, ...) \
53 { \
54 HILOGD(param, ##__VA_ARGS__); \
55 }
56 #else
57 #define VNDUSERIALDBG(param, ...) \
58 { \
59 }
60 #endif
61
62 #define VND_PORT_NAME_MAXLEN 256
63
64 #ifndef BT_CHIP_HW_FLOW_CTRL_ON
65 #define BT_CHIP_HW_FLOW_CTRL_ON TRUE
66 #endif
67
68 /******************************************************************************
69 ** Extern functions
70 ******************************************************************************/
71 extern char rtkbt_transtype;
72 extern void Heartbeat_cleanup();
73 extern void Heartbeat_init();
74
75 /******************************************************************************
76 ** Local type definitions
77 ******************************************************************************/
78 #if !defined(EFD_SEMAPHORE)
79 #define EFD_SEMAPHORE (1 << 0)
80 #endif
81
82 #define RTK_DATA_RECEIVED 1
83 #define RTK_DATA_SEND 0
84 struct rtk_object_t
85 {
86 int fd; // the file descriptor to monitor for events.
87 void *context; // a context that's passed back to the *_ready functions..
88 pthread_mutex_t lock; // protects the lifetime of this object and all variables.
89
90 void (*read_ready)(void *context); // function to call when the file descriptor becomes readable.
91 void (*write_ready)(void *context); // function to call when the file descriptor becomes writeable.
92 };
93
94 /* vendor serial control block */
95 typedef struct
96 {
97 int fd; /* fd to Bluetooth device */
98 int uart_fd[2];
99 int signal_fd[2];
100 int epoll_fd;
101 int cpoll_fd;
102 int event_fd;
103 struct termios termios; /* serial terminal of BT port */
104 char port_name[VND_PORT_NAME_MAXLEN];
105 pthread_t thread_socket_id;
106 pthread_t thread_uart_id;
107 pthread_t thread_coex_id;
108 bool thread_running;
109
110 RTB_QUEUE_HEAD *recv_data;
111 RTB_QUEUE_HEAD *send_data;
112 RTB_QUEUE_HEAD *data_order;
113 volatile bool btdriver_state;
114 } vnd_userial_cb_t;
115
116 #ifdef CONFIG_SCO_OVER_HCI
117 uint16_t btui_msbc_h2[] = {0x0801, 0x3801, 0xc801, 0xf801};
118 typedef struct
119 {
120 pthread_mutex_t sco_recv_mutex;
121 pthread_cond_t sco_recv_cond;
122 pthread_mutex_t sco_send_mutex;
123 pthread_t thread_socket_sco_id;
124 pthread_t thread_recv_sco_id;
125 pthread_t thread_send_sco_id;
126 uint16_t sco_handle;
127 bool thread_sco_running;
128 bool thread_recv_sco_running;
129 bool thread_send_sco_running;
130 uint16_t voice_settings;
131 RTB_QUEUE_HEAD *recv_sco_data;
132 RTB_QUEUE_HEAD *send_sco_data;
133 unsigned char enc_data[480];
134 unsigned int current_pos;
135 uint16_t sco_packet_len;
136 bool msbc_used;
137 int ctrl_fd, data_fd;
138 sbc_t sbc_dec, sbc_enc;
139 uint32_t pcm_enc_seq;
140 int signal_fd[2];
141 } sco_cb_t;
142 #endif
143
144 /******************************************************************************
145 ** Static functions
146 ******************************************************************************/
147 static void h5_data_ready_cb(serial_data_type_t type, unsigned int total_length);
148 static uint16_t h5_int_transmit_data_cb(serial_data_type_t type, uint8_t *data, uint16_t length);
149 extern void RTK_btservice_destroyed();
150 /******************************************************************************
151 ** Static variables
152 ******************************************************************************/
153 #ifdef CONFIG_SCO_OVER_HCI
154 static sco_cb_t sco_cb;
155 #endif
156 static vnd_userial_cb_t vnd_userial;
157 static const hci_h5_t *h5_int_interface;
158 static int packet_recv_state = RTKBT_PACKET_IDLE;
159 static unsigned int packet_bytes_need = 0;
160 static serial_data_type_t current_type = 0;
161 static struct rtk_object_t rtk_socket_object;
162 static struct rtk_object_t rtk_coex_object;
163 static unsigned char h4_read_buffer[2048] = {0};
164 static int h4_read_length = 0;
165
166 static int coex_packet_recv_state = RTKBT_PACKET_IDLE;
167 static int coex_packet_bytes_need = 0;
168 static serial_data_type_t coex_current_type = 0;
169 static unsigned char coex_resvered_buffer[2048] = {0};
170 static int coex_resvered_length = 0;
171
172 #ifdef RTK_HANDLE_EVENT
173 static int received_packet_state = RTKBT_PACKET_IDLE;
174 static unsigned int received_packet_bytes_need = 0;
175 static serial_data_type_t recv_packet_current_type = 0;
176 static unsigned char received_resvered_header[2048] = {0};
177 static int received_resvered_length = 0;
178 static rtkbt_version_t rtkbt_version;
179 static rtkbt_lescn_t rtkbt_adv_con;
180 #endif
181
182 static rtk_parse_manager_t *rtk_parse_manager = NULL;
183
184 static hci_h5_callbacks_t h5_int_callbacks = {
185 .h5_int_transmit_data_cb = h5_int_transmit_data_cb,
186 .h5_data_ready_cb = h5_data_ready_cb,
187 };
188
189 static const uint8_t hci_preamble_sizes[] = {
190 COMMAND_PREAMBLE_SIZE,
191 ACL_PREAMBLE_SIZE,
192 SCO_PREAMBLE_SIZE,
193 EVENT_PREAMBLE_SIZE};
194
195 /*****************************************************************************
196 ** Helper Functions
197 *****************************************************************************/
198
199 /*******************************************************************************
200 **
201 ** Function userial_to_tcio_baud
202 **
203 ** Description helper function converts USERIAL baud rates into TCIO
204 ** conforming baud rates
205 **
206 ** Returns TRUE/FALSE
207 **
208 *******************************************************************************/
userial_to_tcio_baud(uint8_t cfg_baud,uint32_t * baud)209 uint8_t userial_to_tcio_baud(uint8_t cfg_baud, uint32_t *baud)
210 {
211 if (cfg_baud == USERIAL_BAUD_115200)
212 *baud = B115200;
213 else if (cfg_baud == USERIAL_BAUD_4M)
214 *baud = B4000000;
215 else if (cfg_baud == USERIAL_BAUD_3M)
216 *baud = B3000000;
217 else if (cfg_baud == USERIAL_BAUD_2M)
218 *baud = B2000000;
219 else if (cfg_baud == USERIAL_BAUD_1M)
220 *baud = B1000000;
221 else if (cfg_baud == USERIAL_BAUD_1_5M)
222 *baud = B1500000;
223 else if (cfg_baud == USERIAL_BAUD_921600)
224 *baud = B921600;
225 else if (cfg_baud == USERIAL_BAUD_460800)
226 *baud = B460800;
227 else if (cfg_baud == USERIAL_BAUD_230400)
228 *baud = B230400;
229 else if (cfg_baud == USERIAL_BAUD_57600)
230 *baud = B57600;
231 else if (cfg_baud == USERIAL_BAUD_19200)
232 *baud = B19200;
233 else if (cfg_baud == USERIAL_BAUD_9600)
234 *baud = B9600;
235 else if (cfg_baud == USERIAL_BAUD_1200)
236 *baud = B1200;
237 else if (cfg_baud == USERIAL_BAUD_600)
238 *baud = B600;
239 else
240 {
241 HILOGE("userial vendor open: unsupported baud idx %i", cfg_baud);
242 *baud = B115200;
243 return FALSE;
244 }
245
246 return TRUE;
247 }
248
249 #if (BT_WAKE_VIA_USERIAL_IOCTL == TRUE)
250 /*******************************************************************************
251 **
252 ** Function userial_ioctl_init_bt_wake
253 **
254 ** Description helper function to set the open state of the bt_wake if ioctl
255 ** is used. it should not hurt in the rfkill case but it might
256 ** be better to compile it out.
257 **
258 ** Returns none
259 **
260 *******************************************************************************/
userial_ioctl_init_bt_wake(int fd)261 void userial_ioctl_init_bt_wake(int fd)
262 {
263 uint32_t bt_wake_state;
264
265 /* assert BT_WAKE through ioctl */
266 ioctl(fd, USERIAL_IOCTL_BT_WAKE_ASSERT, NULL);
267 ioctl(fd, USERIAL_IOCTL_BT_WAKE_GET_ST, &bt_wake_state);
268 VNDUSERIALDBG("userial_ioctl_init_bt_wake read back BT_WAKE state=%i",
269 bt_wake_state);
270 }
271 #endif // (BT_WAKE_VIA_USERIAL_IOCTL==TRUE)
272
273 /*****************************************************************************
274 ** Userial Vendor API Functions
275 *****************************************************************************/
276
277 /*******************************************************************************
278 **
279 ** Function userial_vendor_init
280 **
281 ** Description Initialize userial vendor-specific control block
282 **
283 ** Returns None
284 **
285 *******************************************************************************/
userial_vendor_init(char * bt_device_node)286 void userial_vendor_init(char *bt_device_node)
287 {
288 memset(&rtkbt_adv_con, 0, sizeof(rtkbt_lescn_t));
289 memset(&vnd_userial, 0, sizeof(vnd_userial_cb_t));
290 vnd_userial.fd = -1;
291 char value[100];
292 snprintf(vnd_userial.port_name, VND_PORT_NAME_MAXLEN, "%s",
293 bt_device_node);
294 if (rtkbt_transtype & RTKBT_TRANS_H5)
295 {
296 h5_int_interface = hci_get_h5_int_interface();
297 h5_int_interface->h5_int_init(&h5_int_callbacks);
298 }
299 rtk_parse_manager = NULL;
300 memset(value, 0, sizeof(value));
301 strcpy(value, "true");
302 if (strncmp(value, "true", 4) == 0)
303 {
304 rtk_parse_manager = rtk_parse_manager_get_interface();
305 rtk_parse_manager->rtk_parse_init();
306 }
307 vnd_userial.data_order = RtbQueueInit();
308 vnd_userial.recv_data = RtbQueueInit();
309 vnd_userial.send_data = RtbQueueInit();
310
311 // reset coex gloable variables
312 coex_packet_recv_state = RTKBT_PACKET_IDLE;
313 coex_packet_bytes_need = 0;
314 coex_current_type = 0;
315 coex_resvered_length = 0;
316
317 #ifdef RTK_HANDLE_EVENT
318 // reset handle event gloable variables
319 received_packet_state = RTKBT_PACKET_IDLE;
320 received_packet_bytes_need = 0;
321 recv_packet_current_type = 0;
322 received_resvered_length = 0;
323 #endif
324
325 #ifdef CONFIG_SCO_OVER_HCI
326 sco_cb.recv_sco_data = RtbQueueInit();
327 sco_cb.send_sco_data = RtbQueueInit();
328 pthread_mutex_init(&sco_cb.sco_recv_mutex, NULL);
329 pthread_cond_init(&sco_cb.sco_recv_cond, NULL);
330 pthread_mutex_init(&sco_cb.sco_send_mutex, NULL);
331 memset(&sco_cb.sbc_enc, 0, sizeof(sbc_t));
332 sbc_init_msbc(&sco_cb.sbc_enc, 0L);
333 sco_cb.sbc_enc.endian = SBC_LE;
334 memset(&sco_cb.sbc_dec, 0, sizeof(sbc_t));
335 sbc_init_msbc(&sco_cb.sbc_dec, 0L);
336 sco_cb.sbc_dec.endian = SBC_LE;
337 #endif
338 }
339
340 /*******************************************************************************
341 **
342 ** Function userial_vendor_open
343 **
344 ** Description Open the serial port with the given configuration
345 **
346 ** Returns device fd
347 **
348 *******************************************************************************/
userial_vendor_open(tUSERIAL_CFG * p_cfg)349 int userial_vendor_open(tUSERIAL_CFG *p_cfg)
350 {
351 uint32_t baud;
352 uint8_t data_bits;
353 uint16_t parity;
354 uint8_t stop_bits;
355
356 vnd_userial.fd = -1;
357
358 if (!userial_to_tcio_baud(p_cfg->baud, &baud))
359 {
360 return -1;
361 }
362
363 if (p_cfg->fmt & USERIAL_DATABITS_8)
364 data_bits = CS8;
365 else if (p_cfg->fmt & USERIAL_DATABITS_7)
366 data_bits = CS7;
367 else if (p_cfg->fmt & USERIAL_DATABITS_6)
368 data_bits = CS6;
369 else if (p_cfg->fmt & USERIAL_DATABITS_5)
370 data_bits = CS5;
371 else
372 {
373 HILOGE("userial vendor open: unsupported data bits");
374 return -1;
375 }
376
377 if (p_cfg->fmt & USERIAL_PARITY_NONE)
378 parity = 0;
379 else if (p_cfg->fmt & USERIAL_PARITY_EVEN)
380 parity = PARENB;
381 else if (p_cfg->fmt & USERIAL_PARITY_ODD)
382 parity = (PARENB | PARODD);
383 else
384 {
385 HILOGE("userial vendor open: unsupported parity bit mode");
386 return -1;
387 }
388
389 if (p_cfg->fmt & USERIAL_STOPBITS_1)
390 stop_bits = 0;
391 else if (p_cfg->fmt & USERIAL_STOPBITS_2)
392 stop_bits = CSTOPB;
393 else
394 {
395 HILOGE("userial vendor open: unsupported stop bits");
396 return -1;
397 }
398
399 HILOGI("userial vendor open: opening %s", vnd_userial.port_name);
400
401 if ((vnd_userial.fd = open(vnd_userial.port_name, O_RDWR)) == -1)
402 {
403 HILOGE("userial vendor open: unable to open %s", vnd_userial.port_name);
404 return -1;
405 }
406
407 tcflush(vnd_userial.fd, TCIOFLUSH);
408
409 tcgetattr(vnd_userial.fd, &vnd_userial.termios);
410 cfmakeraw(&vnd_userial.termios);
411
412 if (p_cfg->hw_fctrl == USERIAL_HW_FLOW_CTRL_ON)
413 {
414 HILOGI("userial vendor open: with HW flowctrl ON");
415 vnd_userial.termios.c_cflag |= (CRTSCTS | stop_bits | parity);
416 }
417 else
418 {
419 HILOGI("userial vendor open: with HW flowctrl OFF");
420 vnd_userial.termios.c_cflag &= ~CRTSCTS;
421 vnd_userial.termios.c_cflag |= (stop_bits | parity);
422 }
423
424 tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios);
425 tcflush(vnd_userial.fd, TCIOFLUSH);
426
427 tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios);
428 tcflush(vnd_userial.fd, TCIOFLUSH);
429 tcflush(vnd_userial.fd, TCIOFLUSH);
430
431 /* set input/output baudrate */
432 cfsetospeed(&vnd_userial.termios, baud);
433 cfsetispeed(&vnd_userial.termios, baud);
434 tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios);
435
436 #if (BT_WAKE_VIA_USERIAL_IOCTL == TRUE)
437 userial_ioctl_init_bt_wake(vnd_userial.fd);
438 #endif
439
440 vnd_userial.btdriver_state = true;
441 HILOGI("device fd = %d open", vnd_userial.fd);
442
443 return vnd_userial.fd;
444 }
445
userial_socket_close(void)446 static void userial_socket_close(void)
447 {
448 int result;
449
450 if ((vnd_userial.uart_fd[0] > 0) && (result = close(vnd_userial.uart_fd[0])) < 0)
451 HILOGE("%s (fd:%d) FAILED result:%d", __func__, vnd_userial.uart_fd[0], result);
452
453 if (epoll_ctl(vnd_userial.epoll_fd, EPOLL_CTL_DEL, vnd_userial.uart_fd[1], NULL) == -1)
454 HILOGE("%s unable to unregister fd %d from epoll set: %s", __func__, vnd_userial.uart_fd[1], strerror(errno));
455
456 if (epoll_ctl(vnd_userial.epoll_fd, EPOLL_CTL_DEL, vnd_userial.signal_fd[1], NULL) == -1)
457 HILOGE("%s unable to unregister signal fd %d from epoll set: %s", __func__, vnd_userial.signal_fd[1], strerror(errno));
458
459 if ((vnd_userial.uart_fd[1] > 0) && (result = close(vnd_userial.uart_fd[1])) < 0)
460 HILOGE("%s (fd:%d) FAILED result:%d", __func__, vnd_userial.uart_fd[1], result);
461
462 if (vnd_userial.thread_socket_id != (pthread_t)-1)
463 pthread_join(vnd_userial.thread_socket_id, NULL);
464
465 if (vnd_userial.epoll_fd > 0)
466 close(vnd_userial.epoll_fd);
467
468 if ((vnd_userial.signal_fd[0] > 0) && (result = close(vnd_userial.signal_fd[0])) < 0)
469 HILOGE("%s (signal fd[0]:%d) FAILED result:%d", __func__, vnd_userial.signal_fd[0], result);
470 if ((vnd_userial.signal_fd[1] > 0) && (result = close(vnd_userial.signal_fd[1])) < 0)
471 HILOGE("%s (signal fd[1]:%d) FAILED result:%d", __func__, vnd_userial.signal_fd[1], result);
472
473 vnd_userial.epoll_fd = -1;
474 vnd_userial.uart_fd[0] = -1;
475 vnd_userial.uart_fd[1] = -1;
476 vnd_userial.signal_fd[0] = -1;
477 vnd_userial.signal_fd[1] = -1;
478 }
479
userial_uart_close(void)480 static void userial_uart_close(void)
481 {
482 int result;
483 if ((vnd_userial.fd > 0) && (result = close(vnd_userial.fd)) < 0)
484 HILOGE("%s (fd:%d) FAILED result:%d", __func__, vnd_userial.fd, result);
485 if (vnd_userial.thread_uart_id != (pthread_t)-1)
486 pthread_join(vnd_userial.thread_uart_id, NULL);
487 }
488
userial_coex_close(void)489 static void userial_coex_close(void)
490 {
491 int result;
492
493 if (epoll_ctl(vnd_userial.cpoll_fd, EPOLL_CTL_DEL, vnd_userial.event_fd, NULL) == -1)
494 HILOGE("%s unable to unregister fd %d from cpoll set: %s", __func__, vnd_userial.event_fd, strerror(errno));
495
496 if (epoll_ctl(vnd_userial.cpoll_fd, EPOLL_CTL_DEL, vnd_userial.signal_fd[1], NULL) == -1)
497 HILOGE("%s unable to unregister fd %d from cpoll set: %s", __func__, vnd_userial.signal_fd[1], strerror(errno));
498
499 if ((result = close(vnd_userial.event_fd)) < 0)
500 HILOGE("%s (fd:%d) FAILED result:%d", __func__, vnd_userial.event_fd, result);
501
502 close(vnd_userial.cpoll_fd);
503 if (vnd_userial.thread_coex_id != (pthread_t)-1)
504 pthread_join(vnd_userial.thread_coex_id, NULL);
505 vnd_userial.cpoll_fd = -1;
506 vnd_userial.event_fd = -1;
507 }
508
userial_send_close_signal(void)509 void userial_send_close_signal(void)
510 {
511 unsigned char close_signal = 1;
512 ssize_t ret;
513 RTK_NO_INTR(ret = write(vnd_userial.signal_fd[0], &close_signal, 1));
514 }
515
516 /*******************************************************************************
517 **
518 ** Function userial_vendor_close
519 **
520 ** Description Conduct vendor-specific close work
521 **
522 ** Returns None
523 **
524 *******************************************************************************/
userial_vendor_close(void)525 void userial_vendor_close(void)
526 {
527 if (vnd_userial.fd == -1)
528 return;
529
530 if ((rtkbt_transtype & RTKBT_TRANS_UART) && (rtkbt_transtype & RTKBT_TRANS_H5))
531 {
532 #if (BT_WAKE_VIA_USERIAL_IOCTL == TRUE)
533 /* de-assert bt_wake BEFORE closing port */
534 ioctl(vnd_userial.fd, USERIAL_IOCTL_BT_WAKE_DEASSERT, NULL);
535 #endif
536 // h5_int_interface->h5_int_cleanup();
537 }
538
539 vnd_userial.thread_running = false;
540 #ifdef CONFIG_SCO_OVER_HCI
541 if (sco_cb.thread_sco_running)
542 {
543 sco_cb.thread_sco_running = false;
544 unsigned char close_signal = 1;
545 ssize_t ret;
546 RTK_NO_INTR(ret = write(sco_cb.signal_fd[0], &close_signal, 1));
547 pthread_join(sco_cb.thread_socket_sco_id, NULL);
548 }
549 #endif
550 Heartbeat_cleanup();
551 RTK_btservice_destroyed();
552 userial_send_close_signal();
553 userial_uart_close();
554 userial_coex_close();
555 userial_socket_close();
556
557 if ((rtkbt_transtype & RTKBT_TRANS_UART) && (rtkbt_transtype & RTKBT_TRANS_H5))
558 {
559 h5_int_interface->h5_int_cleanup();
560 }
561
562 vnd_userial.fd = -1;
563 vnd_userial.btdriver_state = false;
564 if (rtk_parse_manager)
565 {
566 rtk_parse_manager->rtk_parse_cleanup();
567 }
568 rtk_parse_manager = NULL;
569 #ifdef CONFIG_SCO_OVER_HCI
570 sbc_finish(&sco_cb.sbc_enc);
571 sbc_finish(&sco_cb.sbc_dec);
572 #endif
573 HILOGD("%s finish", __func__);
574 }
575
576 /*******************************************************************************
577 **
578 ** Function userial_vendor_set_baud
579 **
580 ** Description Set new baud rate
581 **
582 ** Returns None
583 **
584 *******************************************************************************/
userial_vendor_set_baud(uint8_t userial_baud)585 void userial_vendor_set_baud(uint8_t userial_baud)
586 {
587 uint32_t tcio_baud;
588 HILOGI("userial_vendor_set_baud");
589 userial_to_tcio_baud(userial_baud, &tcio_baud);
590
591 if (cfsetospeed(&vnd_userial.termios, tcio_baud) < 0)
592 HILOGE("cfsetospeed fail");
593
594 if (cfsetispeed(&vnd_userial.termios, tcio_baud) < 0)
595 HILOGE("cfsetispeed fail");
596
597 if (tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios) < 0)
598 HILOGE("tcsetattr fail ");
599
600 tcflush(vnd_userial.fd, TCIOFLUSH);
601 }
602
603 /*******************************************************************************
604 **
605 ** Function userial_vendor_ioctl
606 **
607 ** Description ioctl inteface
608 **
609 ** Returns None
610 **
611 *******************************************************************************/
userial_vendor_ioctl(userial_vendor_ioctl_op_t op,void * p_data)612 void userial_vendor_ioctl(userial_vendor_ioctl_op_t op, void *p_data)
613 {
614 RTK_UNUSED(p_data);
615 switch (op)
616 {
617 #if (BT_WAKE_VIA_USERIAL_IOCTL == TRUE)
618 case USERIAL_OP_ASSERT_BT_WAKE:
619 VNDUSERIALDBG("## userial_vendor_ioctl: Asserting BT_Wake ##");
620 ioctl(vnd_userial.fd, USERIAL_IOCTL_BT_WAKE_ASSERT, NULL);
621 break;
622
623 case USERIAL_OP_DEASSERT_BT_WAKE:
624 VNDUSERIALDBG("## userial_vendor_ioctl: De-asserting BT_Wake ##");
625 ioctl(vnd_userial.fd, USERIAL_IOCTL_BT_WAKE_DEASSERT, NULL);
626 break;
627
628 case USERIAL_OP_GET_BT_WAKE_STATE:
629 ioctl(vnd_userial.fd, USERIAL_IOCTL_BT_WAKE_GET_ST, p_data);
630 break;
631 #endif // (BT_WAKE_VIA_USERIAL_IOCTL==TRUE)
632
633 default:
634 break;
635 }
636 }
637
638 /*******************************************************************************
639 **
640 ** Function userial_set_port
641 **
642 ** Description Configure UART port name
643 **
644 ** Returns 0 : Success
645 ** Otherwise : Fail
646 **
647 *******************************************************************************/
userial_set_port(char * p_conf_name,char * p_conf_value,int param)648 int userial_set_port(char *p_conf_name, char *p_conf_value, int param)
649 {
650 RTK_UNUSED(p_conf_name);
651 RTK_UNUSED(param);
652 strcpy(vnd_userial.port_name, p_conf_value);
653
654 return 0;
655 }
656
657 /*******************************************************************************
658 **
659 ** Function userial_vendor_set_hw_fctrl
660 **
661 ** Description Conduct vendor-specific close work
662 **
663 ** Returns None
664 **
665 *******************************************************************************/
userial_vendor_set_hw_fctrl(uint8_t hw_fctrl)666 void userial_vendor_set_hw_fctrl(uint8_t hw_fctrl)
667 {
668 struct termios termios_old;
669
670 if (vnd_userial.fd == -1)
671 {
672 HILOGE("vnd_userial.fd is -1");
673 return;
674 }
675
676 tcgetattr(vnd_userial.fd, &termios_old);
677 if (hw_fctrl)
678 {
679 if (termios_old.c_cflag & CRTSCTS)
680 {
681 BTVNDDBG("userial_vendor_set_hw_fctrl already hw flowcontrol on");
682 return;
683 }
684 else
685 {
686 termios_old.c_cflag |= CRTSCTS;
687 tcsetattr(vnd_userial.fd, TCSANOW, &termios_old);
688 BTVNDDBG("userial_vendor_set_hw_fctrl set hw flowcontrol on");
689 }
690 }
691 else
692 {
693 if (termios_old.c_cflag & CRTSCTS)
694 {
695 termios_old.c_cflag &= ~CRTSCTS;
696 tcsetattr(vnd_userial.fd, TCSANOW, &termios_old);
697 return;
698 }
699 else
700 {
701 HILOGI("userial_vendor_set_hw_fctrl set hw flowcontrol off");
702 return;
703 }
704 }
705 }
706
h4_int_transmit_data(uint8_t * data,uint16_t total_length)707 static uint16_t h4_int_transmit_data(uint8_t *data, uint16_t total_length)
708 {
709 assert(data != NULL);
710 assert(total_length > 0);
711
712 uint16_t length = total_length;
713 uint16_t transmitted_length = 0;
714 while (length > 0 && vnd_userial.btdriver_state)
715 {
716 ssize_t ret = write(vnd_userial.fd, data + transmitted_length, length);
717 switch (ret)
718 {
719 case -1:
720 HILOGE("In %s, error writing to the uart serial port: %s", __func__, strerror(errno));
721 goto done;
722 case 0:
723 // If we wrote nothing, don't loop more because we
724 // can't go to infinity or beyond, ohterwise H5 can resend data
725 HILOGE("%s, ret %zd", __func__, ret);
726 goto done;
727 default:
728 transmitted_length += ret;
729 length -= ret;
730 break;
731 }
732 }
733
734 done:;
735 return transmitted_length;
736 }
737
userial_enqueue_coex_rawdata(unsigned char * buffer,int length,bool is_recved)738 static void userial_enqueue_coex_rawdata(unsigned char *buffer, int length, bool is_recved)
739 {
740 RTK_BUFFER *skb_data = RtbAllocate(length, 0);
741 RTK_BUFFER *skb_type = RtbAllocate(1, 0);
742 memcpy(skb_data->Data, buffer, length);
743 skb_data->Length = length;
744 if (is_recved)
745 {
746 *skb_type->Data = RTK_DATA_RECEIVED;
747 skb_type->Length = 1;
748 RtbQueueTail(vnd_userial.recv_data, skb_data);
749 RtbQueueTail(vnd_userial.data_order, skb_type);
750 }
751 else
752 {
753 *skb_type->Data = RTK_DATA_SEND;
754 skb_type->Length = 1;
755 RtbQueueTail(vnd_userial.send_data, skb_data);
756 RtbQueueTail(vnd_userial.data_order, skb_type);
757 }
758
759 if (eventfd_write(vnd_userial.event_fd, 1) == -1)
760 {
761 HILOGE("%s unable to write for coex event fd.", __func__);
762 }
763 }
764
userial_send_cmd_to_controller(unsigned char * recv_buffer,int total_length)765 static void userial_send_cmd_to_controller(unsigned char *recv_buffer, int total_length)
766 {
767 if (rtkbt_transtype & RTKBT_TRANS_H4)
768 {
769 h4_int_transmit_data(recv_buffer, total_length);
770 }
771 else
772 {
773 h5_int_interface->h5_send_cmd(DATA_TYPE_COMMAND, &recv_buffer[1], (total_length - 1));
774 }
775 userial_enqueue_coex_rawdata(recv_buffer, total_length, false);
776 }
777
userial_send_acl_to_controller(unsigned char * recv_buffer,int total_length)778 static void userial_send_acl_to_controller(unsigned char *recv_buffer, int total_length)
779 {
780 if (rtkbt_transtype & RTKBT_TRANS_H4)
781 {
782 h4_int_transmit_data(recv_buffer, total_length);
783 }
784 else
785 {
786 h5_int_interface->h5_send_acl_data(DATA_TYPE_ACL, &recv_buffer[1], (total_length - 1));
787 }
788 userial_enqueue_coex_rawdata(recv_buffer, total_length, false);
789 }
790
userial_send_sco_to_controller(unsigned char * recv_buffer,int total_length)791 static void userial_send_sco_to_controller(unsigned char *recv_buffer, int total_length)
792 {
793 if (rtkbt_transtype & RTKBT_TRANS_H4)
794 {
795 h4_int_transmit_data(recv_buffer, total_length);
796 }
797 else
798 {
799 h5_int_interface->h5_send_sco_data(DATA_TYPE_SCO, &recv_buffer[1], (total_length - 1));
800 }
801 userial_enqueue_coex_rawdata(recv_buffer, total_length, false);
802 }
803
userial_coex_recv_data_handler(unsigned char * recv_buffer,int total_length)804 static int userial_coex_recv_data_handler(unsigned char *recv_buffer, int total_length)
805 {
806 serial_data_type_t type = 0;
807 unsigned char *p_data = recv_buffer;
808 int length = total_length;
809 HC_BT_HDR *p_buf;
810 uint8_t boundary_flag;
811 uint16_t len, handle, acl_length, l2cap_length;
812 switch (coex_packet_recv_state)
813 {
814 case RTKBT_PACKET_IDLE:
815 coex_packet_bytes_need = 1;
816 while (length)
817 {
818 type = p_data[0];
819 length--;
820 p_data++;
821 assert((type > DATA_TYPE_COMMAND) && (type <= DATA_TYPE_EVENT));
822 if (type < DATA_TYPE_ACL || type > DATA_TYPE_EVENT)
823 {
824 HILOGE("%s invalid data type: %d", __func__, type);
825 if (!length)
826 return total_length;
827
828 continue;
829 }
830 break;
831 }
832 coex_current_type = type;
833 coex_packet_recv_state = RTKBT_PACKET_TYPE;
834 // fall through
835
836 case RTKBT_PACKET_TYPE:
837 if (coex_current_type == DATA_TYPE_ACL)
838 {
839 coex_packet_bytes_need = 4;
840 }
841 else if (coex_current_type == DATA_TYPE_EVENT)
842 {
843 coex_packet_bytes_need = 2;
844 }
845 else
846 {
847 coex_packet_bytes_need = 3;
848 }
849 coex_resvered_length = 0;
850 coex_packet_recv_state = RTKBT_PACKET_HEADER;
851 // fall through
852
853 case RTKBT_PACKET_HEADER:
854 if (length >= coex_packet_bytes_need)
855 {
856 memcpy(&coex_resvered_buffer[coex_resvered_length], p_data, coex_packet_bytes_need);
857 coex_resvered_length += coex_packet_bytes_need;
858 length -= coex_packet_bytes_need;
859 p_data += coex_packet_bytes_need;
860 }
861 else
862 {
863 memcpy(&coex_resvered_buffer[coex_resvered_length], p_data, length);
864 coex_resvered_length += length;
865 coex_packet_bytes_need -= length;
866 length = 0;
867 return total_length;
868 }
869 coex_packet_recv_state = RTKBT_PACKET_CONTENT;
870
871 if (coex_current_type == DATA_TYPE_ACL)
872 {
873 coex_packet_bytes_need = *(uint16_t *)&coex_resvered_buffer[2];
874 }
875 else if (coex_current_type == DATA_TYPE_EVENT)
876 {
877 coex_packet_bytes_need = coex_resvered_buffer[1];
878 }
879 else
880 {
881 coex_packet_bytes_need = coex_resvered_buffer[2];
882 }
883 // fall through
884
885 case RTKBT_PACKET_CONTENT:
886 if (length >= coex_packet_bytes_need)
887 {
888 memcpy(&coex_resvered_buffer[coex_resvered_length], p_data, coex_packet_bytes_need);
889 length -= coex_packet_bytes_need;
890 p_data += coex_packet_bytes_need;
891 coex_resvered_length += coex_packet_bytes_need;
892 coex_packet_bytes_need = 0;
893 }
894 else
895 {
896 memcpy(&coex_resvered_buffer[coex_resvered_length], p_data, length);
897 coex_resvered_length += length;
898 coex_packet_bytes_need -= length;
899 length = 0;
900 return total_length;
901 }
902 coex_packet_recv_state = RTKBT_PACKET_END;
903 // fall through
904
905 case RTKBT_PACKET_END:
906 {
907 len = BT_HC_HDR_SIZE + coex_resvered_length;
908 uint8_t packet[len];
909 p_buf = (HC_BT_HDR *)packet;
910 p_buf->offset = 0;
911 p_buf->layer_specific = 0;
912 p_buf->len = coex_resvered_length;
913 memcpy((uint8_t *)(p_buf + 1), coex_resvered_buffer, coex_resvered_length);
914 switch (coex_current_type)
915 {
916 case DATA_TYPE_EVENT:
917 p_buf->event = MSG_HC_TO_STACK_HCI_EVT;
918 if (rtk_parse_manager)
919 rtk_parse_manager->rtk_parse_internal_event_intercept(coex_resvered_buffer);
920 break;
921
922 case DATA_TYPE_ACL:
923 p_buf->event = MSG_HC_TO_STACK_HCI_ACL;
924 handle = *(uint16_t *)coex_resvered_buffer;
925 acl_length = *(uint16_t *)&coex_resvered_buffer[2];
926 l2cap_length = *(uint16_t *)&coex_resvered_buffer[4];
927 boundary_flag = RTK_GET_BOUNDARY_FLAG(handle);
928 if (rtk_parse_manager)
929 rtk_parse_manager->rtk_parse_l2cap_data(coex_resvered_buffer, 0);
930 break;
931
932 case DATA_TYPE_SCO:
933 p_buf->event = MSG_HC_TO_STACK_HCI_SCO;
934 break;
935
936 default:
937 p_buf->event = MSG_HC_TO_STACK_HCI_ERR;
938 break;
939 }
940 rtk_btsnoop_capture(p_buf, true);
941 }
942 break;
943
944 default:
945
946 break;
947 }
948
949 coex_packet_recv_state = RTKBT_PACKET_IDLE;
950 coex_packet_bytes_need = 0;
951 coex_current_type = 0;
952 coex_resvered_length = 0;
953
954 return (total_length - length);
955 }
956
userial_coex_send_data_handler(unsigned char * send_buffer,int total_length)957 static void userial_coex_send_data_handler(unsigned char *send_buffer, int total_length)
958 {
959 serial_data_type_t type = 0;
960 type = send_buffer[0];
961 int length = total_length;
962 HC_BT_HDR *p_buf;
963 uint8_t boundary_flag;
964 uint16_t len, handle, acl_length, l2cap_length;
965
966 len = BT_HC_HDR_SIZE + (length - 1);
967 uint8_t packet[len];
968 p_buf = (HC_BT_HDR *)packet;
969 p_buf->offset = 0;
970 p_buf->layer_specific = 0;
971 p_buf->len = total_length - 1;
972 memcpy((uint8_t *)(p_buf + 1), &send_buffer[1], length - 1);
973
974 switch (type)
975 {
976 case DATA_TYPE_COMMAND:
977 p_buf->event = MSG_STACK_TO_HC_HCI_CMD;
978 if (rtk_parse_manager)
979 rtk_parse_manager->rtk_parse_command(&send_buffer[1]);
980 break;
981
982 case DATA_TYPE_ACL:
983 p_buf->event = MSG_STACK_TO_HC_HCI_ACL;
984 handle = *(uint16_t *)&send_buffer[1];
985 acl_length = *(uint16_t *)&send_buffer[3];
986 l2cap_length = *(uint16_t *)&send_buffer[5];
987 boundary_flag = RTK_GET_BOUNDARY_FLAG(handle);
988 if (rtk_parse_manager)
989 rtk_parse_manager->rtk_parse_l2cap_data(&send_buffer[1], 1);
990
991 break;
992
993 case DATA_TYPE_SCO:
994 p_buf->event = MSG_STACK_TO_HC_HCI_SCO;
995 break;
996 default:
997 p_buf->event = 0;
998 HILOGE("%s invalid data type: %d", __func__, type);
999 break;
1000 }
1001 rtk_btsnoop_capture(p_buf, false);
1002 }
1003
userial_coex_handler(void * context)1004 static void userial_coex_handler(void *context)
1005 {
1006 RTK_UNUSED(context);
1007 RTK_BUFFER *skb_data;
1008 RTK_BUFFER *skb_type;
1009 eventfd_t value;
1010 unsigned int read_length = 0;
1011 eventfd_read(vnd_userial.event_fd, &value);
1012 if (!value && !vnd_userial.thread_running)
1013 {
1014 return;
1015 }
1016
1017 while (!RtbQueueIsEmpty(vnd_userial.data_order))
1018 {
1019 read_length = 0;
1020 skb_type = RtbDequeueHead(vnd_userial.data_order);
1021 if (skb_type)
1022 {
1023 if (*(skb_type->Data) == RTK_DATA_RECEIVED)
1024 {
1025 skb_data = RtbDequeueHead(vnd_userial.recv_data);
1026 if (skb_data)
1027 {
1028 do
1029 {
1030 read_length += userial_coex_recv_data_handler((skb_data->Data + read_length), (skb_data->Length - read_length));
1031 } while (read_length < skb_data->Length);
1032 RtbFree(skb_data);
1033 }
1034 }
1035 else
1036 {
1037 skb_data = RtbDequeueHead(vnd_userial.send_data);
1038 if (skb_data)
1039 {
1040 userial_coex_send_data_handler(skb_data->Data, skb_data->Length);
1041 RtbFree(skb_data);
1042 }
1043 }
1044
1045 RtbFree(skb_type);
1046 }
1047 }
1048 }
1049
1050 #ifdef CONFIG_SCO_OVER_HCI
1051 // receive sco encode or non-encode data over hci, we need to decode msbc data to pcm, and send it to sco audio hal
userial_recv_sco_thread(void * arg)1052 static void *userial_recv_sco_thread(void *arg)
1053 {
1054 RTK_UNUSED(arg);
1055 RTK_BUFFER *skb_sco_data;
1056 unsigned char dec_data[480];
1057 unsigned char pcm_data[960];
1058 int index = 0;
1059 // uint16_t sco_packet_len = 60;
1060 uint8_t *p_data = NULL;
1061 int res = 0;
1062 size_t writen = 0;
1063 prctl(PR_SET_NAME, (unsigned long)"userial_recv_sco_thread", 0, 0, 0);
1064 /*
1065 FILE *file;
1066 unsigned char enc_data[60];
1067 file = fopen("/data/misc/bluedroid/sco_capture.raw", "rb");
1068 FILE *file2;
1069 file2 = fopen("/data/misc/bluedroid/sco_capture.pcm", "wb");
1070 if (!file) {
1071 HILOGE("Unable to create file");
1072 return NULL;
1073 }
1074 */
1075 // RtbEmptyQueue(sco_cb.recv_sco_data);
1076 pthread_mutex_lock(&sco_cb.sco_recv_mutex);
1077 while (RtbGetQueueLen(sco_cb.recv_sco_data) > 60)
1078 {
1079 RTK_BUFFER *sco_data = RtbDequeueHead(sco_cb.recv_sco_data);
1080 if (sco_data)
1081 RtbFree(sco_data);
1082 }
1083 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
1084
1085 HILOGE("userial_recv_sco_thread start");
1086 while (sco_cb.thread_recv_sco_running)
1087 {
1088 pthread_mutex_lock(&sco_cb.sco_recv_mutex);
1089 while (RtbQueueIsEmpty(sco_cb.recv_sco_data) && sco_cb.thread_sco_running)
1090 {
1091 pthread_cond_wait(&sco_cb.sco_recv_cond, &sco_cb.sco_recv_mutex);
1092 }
1093 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
1094 skb_sco_data = RtbDequeueHead(sco_cb.recv_sco_data);
1095 if (!skb_sco_data)
1096 continue;
1097 p_data = skb_sco_data->Data;
1098
1099 if (!sco_cb.msbc_used)
1100 {
1101 res = Skt_Send_noblock(sco_cb.data_fd, p_data, sco_cb.sco_packet_len);
1102 if (res < 0)
1103 {
1104 HILOGE("userial_recv_sco_thread, send noblock error");
1105 }
1106 }
1107 else
1108 {
1109 // if (fwrite(skb_sco_data->Data, 1, 60, file) != 60) {
1110 // HILOGE("Error capturing sample");
1111 //}
1112 /*
1113 if(fread(enc_data, 1, 60, file) > 0) {
1114 HILOGE("userial_recv_sco_thread, fread data");
1115 res = sbc_decode(&sco_cb.sbc_dec, &enc_data[2], 58, dec_data, 240, &writen);
1116 }
1117 else {
1118 fseek(file, 0L, SEEK_SET);
1119 if(fread(enc_data, 1, 60, file) > 0) {
1120 res = sbc_decode(&sco_cb.sbc_dec, &enc_data[2], 58, dec_data, 240, &writen);
1121 }
1122 }
1123 */
1124 res = sbc_decode(&sco_cb.sbc_dec, (p_data + 2), 58, dec_data, 240, &writen);
1125 if (res > 0)
1126 {
1127 memcpy(&pcm_data[240 * index], dec_data, 240);
1128 // if (fwrite(dec_data, 240, 1, file2) != 240) {
1129 // HILOGE("Error capturing sample");
1130 //}
1131 index = (index + 1) % 4;
1132 if (index == 0)
1133 {
1134 Skt_Send_noblock(sco_cb.data_fd, pcm_data, 960);
1135 }
1136 }
1137 else
1138 {
1139 HILOGE("msbc decode fail!");
1140 }
1141 }
1142 RtbFree(skb_sco_data);
1143 }
1144 HILOGE("userial_recv_sco_thread exit");
1145 RtbEmptyQueue(sco_cb.recv_sco_data);
1146 return NULL;
1147 }
1148
userial_send_sco_thread(void * arg)1149 static void *userial_send_sco_thread(void *arg)
1150 {
1151 RTK_UNUSED(arg);
1152 unsigned char enc_data[240];
1153 unsigned char pcm_data[960 * 2];
1154 unsigned char send_data[100];
1155 int writen = 0;
1156 int num_read;
1157 prctl(PR_SET_NAME, (unsigned long)"userial_send_sco_thread", 0, 0, 0);
1158 sco_cb.pcm_enc_seq = 0;
1159 int i;
1160
1161 /*
1162 FILE *file;
1163 file = fopen("/data/misc/bluedroid/sco_playback.raw", "rb");
1164 if (!file) {
1165 HILOGE("Unable to create file");
1166 return NULL;
1167 }
1168 */
1169 // when start sco send thread, first send 6 sco data to controller
1170 if (!sco_cb.msbc_used)
1171 {
1172 memset(pcm_data, 0, (48 * 6));
1173 for (i = 0; i < 6; i++)
1174 {
1175 send_data[0] = DATA_TYPE_SCO;
1176 send_data[3] = 48;
1177 *(uint16_t *)&send_data[1] = sco_cb.sco_handle;
1178 memcpy(&send_data[4], &pcm_data[i * 48], 48);
1179 userial_send_sco_to_controller(send_data, 52);
1180 }
1181 }
1182 HILOGE("userial_send_sco_thread start");
1183 while (sco_cb.thread_send_sco_running)
1184 {
1185 if (!sco_cb.msbc_used)
1186 {
1187 num_read = Skt_Read(sco_cb.data_fd, pcm_data, 48 * 5, &sco_cb.thread_send_sco_running);
1188 if (!num_read)
1189 continue;
1190 for (i = 0; i < 5; i++)
1191 {
1192 send_data[0] = DATA_TYPE_SCO;
1193 send_data[3] = 48;
1194 *(uint16_t *)&send_data[1] = sco_cb.sco_handle;
1195 memcpy(&send_data[4], &pcm_data[i * 48], 48);
1196 userial_send_sco_to_controller(send_data, 52);
1197 }
1198 }
1199 else
1200 {
1201 num_read = Skt_Read(sco_cb.data_fd, pcm_data, 960, &sco_cb.thread_send_sco_running);
1202 /*
1203 for(i = 0; i < 5; i ++) {
1204 if(fread(&enc_data[4], 1, 48, file) > 0) {
1205 enc_data[0] = DATA_TYPE_SCO;
1206 enc_data[3] = 48;
1207 *(uint16_t *)&enc_data[1] = sco_cb.sco_handle;
1208 userial_send_sco_to_controller(enc_data, 52);
1209 }
1210 else {
1211 fseek(file, 0L, SEEK_SET);
1212 }
1213 }
1214 //usleep(7500);
1215 continue;
1216 */
1217 if (!num_read)
1218 continue;
1219 for (i = 0; i < 4; i++)
1220 {
1221 if (sbc_encode(&sco_cb.sbc_enc, &pcm_data[240 * i], 240, &enc_data[i * 60 + 2], 58, (ssize_t *)&writen) <= 0)
1222 {
1223 HILOGE("sbc encode error!");
1224 }
1225 else
1226 {
1227 *(uint16_t *)(&(enc_data[i * 60])) = btui_msbc_h2[sco_cb.pcm_enc_seq % 4];
1228 sco_cb.pcm_enc_seq++;
1229 enc_data[i * 60 + 59] = 0x00; // padding
1230 }
1231 }
1232 for (i = 0; i < 5; i++)
1233 {
1234 send_data[0] = DATA_TYPE_SCO;
1235 send_data[3] = 48;
1236 *(uint16_t *)&send_data[1] = sco_cb.sco_handle;
1237 memcpy(&send_data[4], &enc_data[i * 48], 48);
1238 userial_send_sco_to_controller(send_data, 52);
1239 }
1240 }
1241 }
1242 HILOGE("userial_send_sco_thread exit");
1243 return NULL;
1244 }
1245
userial_sco_send_socket_stop()1246 static void userial_sco_send_socket_stop()
1247 {
1248 HILOGE("%s", __func__);
1249 pthread_mutex_lock(&sco_cb.sco_send_mutex);
1250 if (sco_cb.thread_send_sco_running)
1251 {
1252 sco_cb.thread_send_sco_running = false;
1253 }
1254 else
1255 {
1256 pthread_mutex_unlock(&sco_cb.sco_send_mutex);
1257 return;
1258 }
1259 pthread_mutex_unlock(&sco_cb.sco_send_mutex);
1260
1261 if (sco_cb.thread_send_sco_id != -1)
1262 {
1263 pthread_join(sco_cb.thread_send_sco_id, NULL);
1264 sco_cb.thread_send_sco_id = -1;
1265 }
1266 }
1267
userial_sco_recv_socket_stop()1268 static void userial_sco_recv_socket_stop()
1269 {
1270 HILOGE("%s", __func__);
1271 pthread_mutex_lock(&sco_cb.sco_recv_mutex);
1272 if (sco_cb.thread_recv_sco_running)
1273 {
1274 sco_cb.thread_recv_sco_running = false;
1275 pthread_cond_signal(&sco_cb.sco_recv_cond);
1276 }
1277 else
1278 {
1279 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
1280 return;
1281 }
1282 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
1283
1284 if (sco_cb.thread_recv_sco_id != -1)
1285 {
1286 pthread_join(sco_cb.thread_recv_sco_id, NULL);
1287 sco_cb.thread_recv_sco_id = -1;
1288 }
1289 }
1290
userial_sco_socket_stop()1291 static void userial_sco_socket_stop()
1292 {
1293 HILOGE("%s", __func__);
1294 userial_sco_send_socket_stop();
1295 userial_sco_recv_socket_stop();
1296 if (sco_cb.ctrl_fd > 0)
1297 {
1298 close(sco_cb.ctrl_fd);
1299 sco_cb.ctrl_fd = -1;
1300 }
1301 if (sco_cb.data_fd > 0)
1302 {
1303 close(sco_cb.data_fd);
1304 sco_cb.data_fd = -1;
1305 }
1306 RtbEmptyQueue(sco_cb.recv_sco_data);
1307 }
1308
userial_sco_ctrl_skt_handle()1309 static void userial_sco_ctrl_skt_handle()
1310 {
1311 uint8_t cmd = 0, ack = 0;
1312 ;
1313 int result = Skt_Read(sco_cb.ctrl_fd, &cmd, 1, NULL);
1314
1315 if (result == 0)
1316 {
1317 userial_sco_socket_stop();
1318 return;
1319 }
1320
1321 HILOGE("%s, cmd = %d, msbc_used = %d", __func__, cmd, sco_cb.msbc_used);
1322 switch (cmd)
1323 {
1324 case SCO_CTRL_CMD_CHECK_READY:
1325
1326 break;
1327
1328 case SCO_CTRL_CMD_OUT_START:
1329 {
1330 pthread_attr_t thread_attr;
1331 pthread_attr_init(&thread_attr);
1332 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
1333 sco_cb.thread_send_sco_running = true;
1334 if (pthread_create(&sco_cb.thread_send_sco_id, &thread_attr, userial_send_sco_thread, NULL) != 0)
1335 {
1336 HILOGE("pthread_create : %s", strerror(errno));
1337 }
1338 }
1339 break;
1340
1341 case SCO_CTRL_CMD_IN_START:
1342 {
1343 pthread_attr_t thread_attr;
1344 pthread_attr_init(&thread_attr);
1345 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
1346 sco_cb.thread_recv_sco_running = true;
1347 if (pthread_create(&sco_cb.thread_recv_sco_id, &thread_attr, userial_recv_sco_thread, NULL) != 0)
1348 {
1349 HILOGE("pthread_create : %s", strerror(errno));
1350 }
1351 }
1352 break;
1353
1354 case SCO_CTRL_CMD_OUT_STOP:
1355 userial_sco_send_socket_stop();
1356 break;
1357
1358 case SCO_CTRL_CMD_IN_STOP:
1359 userial_sco_recv_socket_stop();
1360
1361 break;
1362
1363 case SCO_CTRL_CMD_SUSPEND:
1364
1365 break;
1366
1367 case SCO_CTRL_GET_AUDIO_CONFIG:
1368 if (sco_cb.msbc_used)
1369 {
1370 ack = 2;
1371 Skt_Send(sco_cb.ctrl_fd, &ack, 1);
1372 }
1373 else
1374 {
1375 ack = 1;
1376 Skt_Send(sco_cb.ctrl_fd, &ack, 1);
1377 }
1378 break;
1379
1380 case SCO_CTRL_CMD_CLOSE:
1381 userial_sco_socket_stop();
1382 break;
1383
1384 default:
1385
1386 break;
1387 }
1388 }
1389
userial_socket_sco_thread(void * arg)1390 static void *userial_socket_sco_thread(void *arg)
1391 {
1392 RTK_UNUSED(arg);
1393 struct sockaddr_un addr, remote;
1394 // socklen_t alen;
1395 socklen_t len = sizeof(struct sockaddr_un);
1396 fd_set read_set, active_set;
1397 int result, max_fd;
1398 int s_ctrl = socket(AF_LOCAL, SOCK_STREAM, 0);
1399 if (s_ctrl < 0)
1400 {
1401 HILOGE("ctrl socket create fail");
1402 return NULL;
1403 }
1404 int s_data = socket(AF_LOCAL, SOCK_STREAM, 0);
1405 if (s_data < 0)
1406 {
1407 HILOGE("data socket create fail");
1408 close(s_ctrl);
1409 return NULL;
1410 }
1411 prctl(PR_SET_NAME, (unsigned long)"userial_socket_sco_thread", 0, 0, 0);
1412
1413 if ((socketpair(AF_UNIX, SOCK_STREAM, 0, sco_cb.signal_fd)) < 0)
1414 {
1415 HILOGE("%s, errno : %s", __func__, strerror(errno));
1416 goto socket_close;
1417 }
1418
1419 // bind sco ctrl socket
1420 // unlink(SCO_CTRL_PATH);
1421
1422 #if 0
1423 memset(&addr, 0, sizeof(addr));
1424 strcpy(addr.sun_path, SCO_CTRL_PATH);
1425 addr.sun_family = AF_UNIX;
1426 addr.sun_path[0] = 0;
1427 alen = strlen(addr.sun_path) + offsetof(struct sockaddr_un, sun_path);
1428 if (bind(s_ctrl, (struct sockaddr *)&addr, alen) < 0) {
1429 HILOGE("userial_socket_sco_thread, bind ctrl socket error : %s", strerror(errno));
1430 return NULL;
1431 }
1432 #else
1433 if (socket_local_server_bind(s_ctrl, SCO_CTRL_PATH, ANDROID_SOCKET_NAMESPACE_ABSTRACT) < 0)
1434 {
1435 HILOGE("ctrl socket failed to create (%s)", strerror(errno));
1436 goto signal_close;
1437 }
1438 #endif
1439
1440 if (listen(s_ctrl, 5) < 0)
1441 {
1442 HILOGE("userial_socket_sco_thread, listen ctrl socket error : %s", strerror(errno));
1443 goto signal_close;
1444 }
1445
1446 int res = chmod(SCO_CTRL_PATH, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
1447 if (res < 0)
1448 {
1449 HILOGE("chmod ctrl path fail");
1450 }
1451 // bind sco data socket
1452 // unlink(SCO_DATA_PATH);
1453 #if 0
1454 memset(&addr, 0, sizeof(addr));
1455 strcpy(addr.sun_path, SCO_DATA_PATH);
1456 addr.sun_family = AF_UNIX;
1457 addr.sun_path[0] = 0;
1458 alen = strlen(addr.sun_path) + offsetof(struct sockaddr_un, sun_path);
1459 if (bind(s_data, (struct sockaddr *)&addr, alen) < 0) {
1460 HILOGE("userial_socket_sco_thread, bind data socket error : %s", strerror(errno));
1461 return NULL;
1462 }
1463
1464 #else
1465 if (socket_local_server_bind(s_data, SCO_DATA_PATH, ANDROID_SOCKET_NAMESPACE_ABSTRACT) < 0)
1466 {
1467 HILOGE("data socket failed to create (%s)", strerror(errno));
1468 goto signal_close;
1469 }
1470
1471 #endif
1472 if (listen(s_data, 5) < 0)
1473 {
1474 HILOGE("userial_socket_sco_thread, listen data socket error : %s", strerror(errno));
1475 goto signal_close;
1476 }
1477 res = chmod(SCO_DATA_PATH, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
1478 if (res < 0)
1479 {
1480 HILOGE("chmod data path fail");
1481 }
1482
1483 HILOGE("userial_socket_sco_thread");
1484 FD_ZERO(&read_set);
1485 FD_ZERO(&active_set);
1486 FD_SET(s_ctrl, &active_set);
1487 FD_SET(s_data, &active_set);
1488 FD_SET(sco_cb.signal_fd[1], &active_set);
1489 max_fd = MAX(s_ctrl, s_data);
1490 max_fd = MAX(max_fd, sco_cb.signal_fd[1]) + 1;
1491 while (sco_cb.thread_sco_running)
1492 {
1493 read_set = active_set;
1494 result = select(max_fd, &read_set, NULL, NULL, NULL);
1495 if (result == 0)
1496 {
1497 HILOGE("select timeout");
1498 continue;
1499 }
1500 if (result < 0)
1501 {
1502 if (errno != EINTR)
1503 HILOGE("select failed %s", strerror(errno));
1504 continue;
1505 }
1506 if (FD_ISSET(s_ctrl, &read_set))
1507 {
1508 if (sco_cb.ctrl_fd > 0)
1509 {
1510 HILOGE("Already has connect a control fd: %d", sco_cb.ctrl_fd);
1511 FD_SET(sco_cb.ctrl_fd, &read_set);
1512 close(sco_cb.ctrl_fd);
1513 }
1514 RTK_NO_INTR(sco_cb.ctrl_fd = accept(s_ctrl, (struct sockaddr *)&remote, &len));
1515 if (sco_cb.ctrl_fd == -1)
1516 {
1517 HILOGE("sock accept failed (%s)", strerror(errno));
1518 continue;
1519 }
1520 const int size = (512);
1521 setsockopt(sco_cb.ctrl_fd, SOL_SOCKET, SO_RCVBUF, (char *)&size, (int)sizeof(size));
1522 FD_SET(sco_cb.ctrl_fd, &active_set);
1523 max_fd = (MAX(max_fd, sco_cb.ctrl_fd)) + 1;
1524 }
1525
1526 if (FD_ISSET(s_data, &read_set))
1527 {
1528 if (sco_cb.data_fd > 0)
1529 {
1530 HILOGE("Already has connect a control fd: %d", sco_cb.data_fd);
1531 close(sco_cb.data_fd);
1532 }
1533 RTK_NO_INTR(sco_cb.data_fd = accept(s_data, (struct sockaddr *)&remote, &len));
1534 if (sco_cb.data_fd == -1)
1535 {
1536 HILOGE("socket accept failed (%s)", strerror(errno));
1537 continue;
1538 }
1539 const int size = (30 * 960);
1540 int ret = setsockopt(sco_cb.data_fd, SOL_SOCKET, SO_RCVBUF, (char *)&size, (int)sizeof(size));
1541 ret = setsockopt(sco_cb.data_fd, SOL_SOCKET, SO_SNDBUF, (char *)&size, (int)sizeof(size));
1542 }
1543
1544 if (sco_cb.ctrl_fd > 0 && FD_ISSET(sco_cb.ctrl_fd, &read_set))
1545 {
1546 userial_sco_ctrl_skt_handle();
1547 }
1548 }
1549
1550 userial_sco_socket_stop();
1551 signal_close:
1552 close(sco_cb.signal_fd[0]);
1553 close(sco_cb.signal_fd[1]);
1554 socket_close:
1555 close(s_ctrl);
1556 close(s_data);
1557
1558 memset(&addr, 0, sizeof(addr));
1559 strcpy((addr.sun_path + 1), SCO_DATA_PATH);
1560 addr.sun_path[0] = 0;
1561 unlink(addr.sun_path);
1562
1563 memset(&addr, 0, sizeof(addr));
1564 strcpy((addr.sun_path + 1), SCO_CTRL_PATH);
1565 addr.sun_path[0] = 0;
1566 unlink(addr.sun_path);
1567 HILOGE("userial_socket_sco_thread exit");
1568 return NULL;
1569 }
1570
1571 #endif
1572
1573 #ifdef RTK_HANDLE_CMD
userial_handle_cmd(unsigned char * recv_buffer,int total_length)1574 static void userial_handle_cmd(unsigned char *recv_buffer, int total_length)
1575 {
1576 RTK_UNUSED(total_length);
1577 uint16_t opcode = *(uint16_t *)recv_buffer;
1578 uint16_t scan_int, scan_win;
1579 static uint16_t voice_settings;
1580 char prop_value[100];
1581 switch (opcode)
1582 {
1583 case HCI_BLE_WRITE_SCAN_PARAMS:
1584 scan_int = *(uint16_t *)&recv_buffer[4];
1585 scan_win = *(uint16_t *)&recv_buffer[6];
1586 if (scan_win > 20)
1587 {
1588 if ((scan_int / scan_win) > 2)
1589 {
1590 *(uint16_t *)&recv_buffer[4] = (scan_int * 20) / scan_win;
1591 *(uint16_t *)&recv_buffer[6] = 20;
1592 }
1593 else
1594 {
1595 *(uint16_t *)&recv_buffer[4] = 40;
1596 *(uint16_t *)&recv_buffer[6] = 20;
1597 }
1598 }
1599 else if (scan_win == scan_int)
1600 {
1601 *(uint16_t *)&recv_buffer[4] = (scan_int * 5) & 0xFE;
1602 }
1603 else if ((scan_int / scan_win) <= 2)
1604 {
1605 *(uint16_t *)&recv_buffer[4] = (scan_int * 3) & 0xFE;
1606 }
1607 break;
1608
1609 case HCI_LE_SET_EXTENDED_SCAN_PARAMETERS:
1610 scan_int = *(uint16_t *)&recv_buffer[7];
1611 scan_win = *(uint16_t *)&recv_buffer[9];
1612 if (scan_win > 20)
1613 {
1614 if ((scan_int / scan_win) > 2)
1615 {
1616 *(uint16_t *)&recv_buffer[7] = (scan_int * 20) / scan_win;
1617 *(uint16_t *)&recv_buffer[9] = 20;
1618 }
1619 else
1620 {
1621 *(uint16_t *)&recv_buffer[7] = 40;
1622 *(uint16_t *)&recv_buffer[9] = 20;
1623 }
1624 }
1625 else if (scan_win == scan_int)
1626 {
1627 *(uint16_t *)&recv_buffer[7] = (scan_int * 5) & 0xFE;
1628 }
1629 else if ((scan_int / scan_win) <= 2)
1630 {
1631 *(uint16_t *)&recv_buffer[9] = (scan_int * 3) & 0xFE;
1632 }
1633
1634 break;
1635
1636 case HCI_WRITE_VOICE_SETTINGS:
1637 voice_settings = *(uint16_t *)&recv_buffer[3];
1638 if (rtkbt_transtype & RTKBT_TRANS_USB)
1639 {
1640 userial_vendor_usb_ioctl(SET_ISO_CFG, &voice_settings);
1641 }
1642 #ifdef CONFIG_SCO_OVER_HCI
1643 sco_cb.voice_settings = voice_settings;
1644 #endif
1645 break;
1646 #ifdef CONFIG_SCO_OVER_HCI
1647 case HCI_SETUP_ESCO_CONNECTION:
1648 sco_cb.voice_settings = *(uint16_t *)&recv_buffer[15];
1649 sco_cb.ctrl_fd = -1;
1650 sco_cb.data_fd = -1;
1651 break;
1652 #endif
1653 case HCI_SET_EVENT_MASK:
1654 HILOGE("set event mask, it should bt stack init, set coex bt on");
1655 if (rtk_parse_manager)
1656 {
1657 rtk_parse_manager->rtk_set_bt_on(1);
1658 }
1659 Heartbeat_init();
1660 break;
1661
1662 case HCI_ACCEPT_CONNECTION_REQUEST:
1663 memset(prop_value, 0, sizeof(prop_value));
1664 strcpy(prop_value, "master");
1665 if (strcmp(prop_value, "none") != 0)
1666 {
1667 int role = recv_buffer[9];
1668 if (role == 0x01 && (strcmp(prop_value, "master") == 0))
1669 recv_buffer[9] = 0x00;
1670 else if (role == 0x00 && (strcmp(prop_value, "slave") == 0))
1671 recv_buffer[9] = 0x01;
1672 }
1673 break;
1674
1675 case HCI_BLE_WRITE_ADV_PARAMS:
1676 {
1677 if (rtkbt_version.hci_version > HCI_PROTO_VERSION_4_2)
1678 {
1679 break;
1680 }
1681 rtkbt_adv_con.adverting_type = recv_buffer[7];
1682 memset(prop_value, 0, sizeof(prop_value));
1683 strcpy(prop_value, "false");
1684 if (rtkbt_adv_con.adverting_type == 0x00 && (strcmp(prop_value, "true") == 0))
1685 {
1686 recv_buffer[7] = 0x03;
1687 rtkbt_adv_con.adverting_type = 0x03;
1688 }
1689 }
1690 break;
1691 case HCI_BLE_WRITE_ADV_ENABLE:
1692 {
1693 if (rtkbt_version.hci_version > HCI_PROTO_VERSION_4_2)
1694 {
1695 break;
1696 }
1697 if (recv_buffer[2] == 0x01)
1698 {
1699 rtkbt_adv_con.adverting_start = TRUE;
1700 }
1701 else if (recv_buffer[2] == 0x00)
1702 {
1703 rtkbt_adv_con.adverting_type = 0;
1704 rtkbt_adv_con.adverting_enable = FALSE;
1705 rtkbt_adv_con.adverting_start = FALSE;
1706 }
1707 }
1708 break;
1709 case HCI_BLE_CREATE_LL_CONN:
1710 if (rtkbt_version.hci_version > HCI_PROTO_VERSION_4_2)
1711 {
1712 break;
1713 }
1714 if (rtkbt_adv_con.adverting_enable &&
1715 ((rtkbt_adv_con.adverting_type == 0x00) ||
1716 (rtkbt_adv_con.adverting_type == 0x01) ||
1717 (rtkbt_adv_con.adverting_type == 0x04)))
1718 {
1719 uint8_t disable_adv_cmd[5] = {0x01, 0x0A, 0x20, 0x01, 0x00};
1720 rtkbt_adv_con.adverting_enable = FALSE;
1721 userial_send_cmd_to_controller(disable_adv_cmd, 5);
1722 }
1723 break;
1724 default:
1725 break;
1726 }
1727 }
1728 #endif
1729
1730 // This recv data from bt process. The data type only have ACL/SCO/COMMAND
1731 // direction BT HOST ----> CONTROLLER
userial_recv_H4_rawdata(void * context)1732 static void userial_recv_H4_rawdata(void *context)
1733 {
1734 RTK_UNUSED(context);
1735 serial_data_type_t type = 0;
1736 ssize_t bytes_read;
1737 uint16_t opcode;
1738 uint16_t transmitted_length = 0;
1739 // unsigned char *buffer = NULL;
1740
1741 switch (packet_recv_state)
1742 {
1743 case RTKBT_PACKET_IDLE:
1744 packet_bytes_need = 1;
1745 do
1746 {
1747 RTK_NO_INTR(bytes_read = read(vnd_userial.uart_fd[1], &type, 1));
1748 if (bytes_read == -1)
1749 {
1750 HILOGE("%s, state = %d, read error %s", __func__, packet_recv_state, strerror(errno));
1751 return;
1752 }
1753 if (!bytes_read && packet_bytes_need)
1754 {
1755 HILOGE("%s, state = %d, bytes_read 0", __func__, packet_recv_state);
1756 return;
1757 }
1758
1759 if (type < DATA_TYPE_COMMAND || type > DATA_TYPE_SCO)
1760 {
1761 HILOGE("%s invalid data type: %d", __func__, type);
1762 assert((type >= DATA_TYPE_COMMAND) && (type <= DATA_TYPE_SCO));
1763 }
1764 else
1765 {
1766 packet_bytes_need -= bytes_read;
1767 packet_recv_state = RTKBT_PACKET_TYPE;
1768 current_type = type;
1769 h4_read_buffer[0] = type;
1770 }
1771 } while (packet_bytes_need);
1772 // fall through
1773
1774 case RTKBT_PACKET_TYPE:
1775 packet_bytes_need = hci_preamble_sizes[HCI_PACKET_TYPE_TO_INDEX(current_type)];
1776 h4_read_length = 0;
1777 packet_recv_state = RTKBT_PACKET_HEADER;
1778 // fall through
1779
1780 case RTKBT_PACKET_HEADER:
1781 do
1782 {
1783 RTK_NO_INTR(bytes_read = read(vnd_userial.uart_fd[1], &h4_read_buffer[h4_read_length + 1], packet_bytes_need));
1784 if (bytes_read == -1)
1785 {
1786 HILOGE("%s, state = %d, read error %s", __func__, packet_recv_state, strerror(errno));
1787 return;
1788 }
1789 if (!bytes_read && packet_bytes_need)
1790 {
1791 HILOGE("%s, state = %d, bytes_read 0, type : %d", __func__, packet_recv_state, current_type);
1792 return;
1793 }
1794 packet_bytes_need -= bytes_read;
1795 h4_read_length += bytes_read;
1796 } while (packet_bytes_need);
1797 packet_recv_state = RTKBT_PACKET_CONTENT;
1798
1799 if (current_type == DATA_TYPE_ACL)
1800 {
1801 packet_bytes_need = *(uint16_t *)&h4_read_buffer[COMMON_DATA_LENGTH_INDEX];
1802 }
1803 else if (current_type == DATA_TYPE_EVENT)
1804 {
1805 packet_bytes_need = h4_read_buffer[EVENT_DATA_LENGTH_INDEX];
1806 }
1807 else
1808 {
1809 packet_bytes_need = h4_read_buffer[COMMON_DATA_LENGTH_INDEX];
1810 }
1811 // fall through
1812
1813 case RTKBT_PACKET_CONTENT:
1814 while (packet_bytes_need)
1815 {
1816 RTK_NO_INTR(bytes_read = read(vnd_userial.uart_fd[1], &h4_read_buffer[h4_read_length + 1], packet_bytes_need));
1817 if (bytes_read == -1)
1818 {
1819 HILOGE("%s, state = %d, read error %s", __func__, packet_recv_state, strerror(errno));
1820 return;
1821 }
1822 if (!bytes_read)
1823 {
1824 HILOGE("%s, state = %d, bytes_read 0", __func__, packet_recv_state);
1825 return;
1826 }
1827
1828 packet_bytes_need -= bytes_read;
1829 h4_read_length += bytes_read;
1830 }
1831 packet_recv_state = RTKBT_PACKET_END;
1832 // fall through
1833
1834 case RTKBT_PACKET_END:
1835 switch (current_type)
1836 {
1837 case DATA_TYPE_COMMAND:
1838 #ifdef RTK_HANDLE_CMD
1839 userial_handle_cmd(&h4_read_buffer[1], h4_read_length);
1840 #endif
1841 if (rtkbt_transtype & RTKBT_TRANS_H4)
1842 {
1843 h4_int_transmit_data(h4_read_buffer, (h4_read_length + 1));
1844 }
1845 else
1846 {
1847 opcode = *(uint16_t *)&h4_read_buffer[1];
1848 if (opcode == HCI_VSC_H5_INIT)
1849 {
1850 h5_int_interface->h5_send_sync_cmd(opcode, NULL, h4_read_length);
1851 }
1852 else
1853 {
1854 transmitted_length = h5_int_interface->h5_send_cmd(type, &h4_read_buffer[1], h4_read_length);
1855 }
1856 }
1857 userial_enqueue_coex_rawdata(h4_read_buffer, (h4_read_length + 1), false);
1858 break;
1859
1860 case DATA_TYPE_ACL:
1861 userial_send_acl_to_controller(h4_read_buffer, (h4_read_length + 1));
1862 break;
1863
1864 case DATA_TYPE_SCO:
1865 userial_send_sco_to_controller(h4_read_buffer, (h4_read_length + 1));
1866 break;
1867 default:
1868 HILOGE("%s invalid data type: %d", __func__, current_type);
1869 userial_enqueue_coex_rawdata(h4_read_buffer, (h4_read_length + 1), false);
1870 break;
1871 }
1872 break;
1873
1874 default:
1875
1876 break;
1877 }
1878
1879 packet_recv_state = RTKBT_PACKET_IDLE;
1880 packet_bytes_need = 0;
1881 current_type = 0;
1882 h4_read_length = 0;
1883 }
1884
h5_int_transmit_data_cb(serial_data_type_t type,uint8_t * data,uint16_t length)1885 static uint16_t h5_int_transmit_data_cb(serial_data_type_t type, uint8_t *data, uint16_t length)
1886 {
1887 assert(data != NULL);
1888 assert(length > 0);
1889
1890 if (type != DATA_TYPE_H5)
1891 {
1892 HILOGE("%s invalid data type: %d", __func__, type);
1893 return 0;
1894 }
1895
1896 uint16_t transmitted_length = 0;
1897 while (length > 0 && vnd_userial.btdriver_state)
1898 {
1899 ssize_t ret = write(vnd_userial.fd, data + transmitted_length, length);
1900 switch (ret)
1901 {
1902 case -1:
1903 HILOGE("In %s, error writing to the uart serial port: %s", __func__, strerror(errno));
1904 goto done;
1905 case 0:
1906 // If we wrote nothing, don't loop more because we
1907 // can't go to infinity or beyond, ohterwise H5 can resend data
1908 HILOGE("%s, ret %zd", __func__, ret);
1909 goto done;
1910 default:
1911 transmitted_length += ret;
1912 length -= ret;
1913 break;
1914 }
1915 }
1916
1917 done:;
1918 return transmitted_length;
1919 }
1920
1921 #ifdef RTK_HANDLE_EVENT
userial_handle_event(unsigned char * recv_buffer,int total_length)1922 static void userial_handle_event(unsigned char *recv_buffer, int total_length)
1923 {
1924 RTK_UNUSED(total_length);
1925 uint8_t event;
1926 uint8_t *p_data = recv_buffer;
1927 event = p_data[0];
1928 switch (event)
1929 {
1930 case HCI_COMMAND_COMPLETE_EVT:
1931 {
1932 uint16_t opcode = *((uint16_t *)&p_data[3]);
1933 uint8_t *stream = &p_data[6];
1934 if (opcode == HCI_READ_LOCAL_VERSION_INFO)
1935 {
1936 STREAM_TO_UINT8(rtkbt_version.hci_version, stream);
1937 STREAM_TO_UINT16(rtkbt_version.hci_revision, stream);
1938 STREAM_TO_UINT8(rtkbt_version.lmp_version, stream);
1939 STREAM_TO_UINT16(rtkbt_version.manufacturer, stream);
1940 STREAM_TO_UINT16(rtkbt_version.lmp_subversion, stream);
1941 }
1942 else if (opcode == HCI_BLE_WRITE_ADV_ENABLE)
1943 {
1944 if (rtkbt_version.hci_version > HCI_PROTO_VERSION_4_2)
1945 {
1946 break;
1947 }
1948 if (rtkbt_adv_con.adverting_start && (p_data[5] == HCI_SUCCESS))
1949 {
1950 rtkbt_adv_con.adverting_enable = TRUE;
1951 rtkbt_adv_con.adverting_start = FALSE;
1952 }
1953 }
1954 }
1955 break;
1956 #ifdef CONFIG_SCO_OVER_HCI
1957 case HCI_ESCO_CONNECTION_COMP_EVT:
1958 {
1959 if (p_data[2] != 0)
1960 {
1961 sco_cb.thread_sco_running = false;
1962 sco_cb.thread_recv_sco_running = false;
1963 sco_cb.thread_send_sco_running = false;
1964 sco_cb.data_fd = -1;
1965 sco_cb.ctrl_fd = -1;
1966 }
1967 else
1968 {
1969 sco_cb.sco_handle = *((uint16_t *)&p_data[3]);
1970 pthread_attr_t thread_attr;
1971 pthread_attr_init(&thread_attr);
1972 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
1973 sco_cb.thread_sco_running = true;
1974 sco_cb.thread_recv_sco_running = false;
1975 sco_cb.thread_send_sco_running = false;
1976 sco_cb.data_fd = -1;
1977 sco_cb.ctrl_fd = -1;
1978 if (pthread_create(&sco_cb.thread_socket_sco_id, &thread_attr, userial_socket_sco_thread, NULL) != 0)
1979 {
1980 HILOGE("pthread_create : %s", strerror(errno));
1981 }
1982
1983 RtbEmptyQueue(sco_cb.recv_sco_data);
1984 if (!(sco_cb.voice_settings & 0x0003))
1985 {
1986 sco_cb.sco_packet_len = 240; // every 5 cvsd packets form a sco pcm data
1987 sco_cb.msbc_used = false;
1988 }
1989 else
1990 {
1991 sco_cb.sco_packet_len = 60;
1992 sco_cb.msbc_used = true;
1993 }
1994 sco_cb.current_pos = 0;
1995 }
1996
1997 HILOGE("userial_handle_event sco_handle: %d", sco_cb.sco_handle);
1998 }
1999 break;
2000
2001 case HCI_DISCONNECTION_COMP_EVT:
2002 {
2003 if ((*((uint16_t *)&p_data[3])) == sco_cb.sco_handle)
2004 {
2005 sco_cb.sco_handle = 0;
2006 sco_cb.msbc_used = false;
2007 RtbEmptyQueue(sco_cb.recv_sco_data);
2008 if (sco_cb.thread_sco_running)
2009 {
2010 sco_cb.thread_sco_running = false;
2011 unsigned char close_signal = 1;
2012 ssize_t ret;
2013 RTK_NO_INTR(ret = write(sco_cb.signal_fd[0], &close_signal, 1));
2014 }
2015 }
2016 }
2017 break;
2018 #endif
2019 default:
2020 break;
2021 }
2022 }
2023
2024 #ifdef CONFIG_SCO_OVER_HCI
userial_enqueue_recv_sco_data(unsigned char * recv_buffer,int total_length)2025 static void userial_enqueue_recv_sco_data(unsigned char *recv_buffer, int total_length)
2026 {
2027 RTK_UNUSED(total_length);
2028 uint16_t sco_handle;
2029 uint8_t sco_length;
2030 uint8_t *p_data = recv_buffer;
2031 RTK_BUFFER *skb_sco_data;
2032 int i;
2033 sco_handle = *((uint16_t *)p_data);
2034 uint16_t current_pos = sco_cb.current_pos;
2035 uint16_t sco_packet_len = sco_cb.sco_packet_len;
2036
2037 if (sco_handle == sco_cb.sco_handle)
2038 {
2039 sco_length = p_data[SCO_PREAMBLE_SIZE - 1];
2040 p_data += SCO_PREAMBLE_SIZE;
2041
2042 if (current_pos)
2043 {
2044 if ((sco_packet_len - current_pos) <= sco_length)
2045 {
2046 memcpy(&sco_cb.enc_data[current_pos], p_data, (sco_packet_len - current_pos));
2047 skb_sco_data = RtbAllocate(sco_packet_len, 0);
2048 memcpy(skb_sco_data->Data, sco_cb.enc_data, sco_packet_len);
2049 RtbAddTail(skb_sco_data, sco_packet_len);
2050 pthread_mutex_lock(&sco_cb.sco_recv_mutex);
2051 RtbQueueTail(sco_cb.recv_sco_data, skb_sco_data);
2052 pthread_cond_signal(&sco_cb.sco_recv_cond);
2053 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
2054
2055 sco_cb.current_pos = 0;
2056 p_data += (sco_packet_len - current_pos);
2057 sco_length -= (sco_packet_len - current_pos);
2058 }
2059 else
2060 {
2061 memcpy(&sco_cb.enc_data[current_pos], p_data, sco_length);
2062 sco_cb.current_pos += sco_length;
2063 return;
2064 }
2065 }
2066
2067 // if use cvsd codec
2068 if (!sco_cb.msbc_used)
2069 {
2070 for (i = 0; i < (sco_length / sco_packet_len); i++)
2071 {
2072 skb_sco_data = RtbAllocate(sco_packet_len, 0);
2073 memcpy(skb_sco_data->Data, p_data + i * sco_packet_len, sco_packet_len);
2074 RtbAddTail(skb_sco_data, sco_packet_len);
2075 RtbQueueTail(sco_cb.recv_sco_data, skb_sco_data);
2076 }
2077 if ((sco_length / sco_packet_len))
2078 {
2079 pthread_mutex_lock(&sco_cb.sco_recv_mutex);
2080 pthread_cond_signal(&sco_cb.sco_recv_cond);
2081 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
2082 }
2083
2084 i = (sco_length % sco_packet_len);
2085 current_pos = sco_length - i;
2086 if (i)
2087 {
2088 memcpy(sco_cb.enc_data, p_data + current_pos, i);
2089 sco_cb.current_pos = i;
2090 }
2091 return;
2092 }
2093
2094 // use msbc codec
2095 for (i = 0; i < sco_length; i++)
2096 {
2097 if ((p_data[i] == 0x01) && ((p_data[i + 1] & 0x0f) == 0x08) && (p_data[i + 2] == 0xAD))
2098 {
2099 if ((sco_length - i) < sco_packet_len)
2100 {
2101 memcpy(sco_cb.enc_data, &p_data[i], (sco_length - i));
2102 sco_cb.current_pos = sco_length - i;
2103 return;
2104 }
2105 else
2106 {
2107 memcpy(sco_cb.enc_data, &p_data[i], sco_packet_len); // complete msbc data
2108 skb_sco_data = RtbAllocate(sco_packet_len, 0);
2109 memcpy(skb_sco_data->Data, sco_cb.enc_data, sco_packet_len);
2110 RtbAddTail(skb_sco_data, sco_packet_len);
2111 pthread_mutex_lock(&sco_cb.sco_recv_mutex);
2112 RtbQueueTail(sco_cb.recv_sco_data, skb_sco_data);
2113 pthread_cond_signal(&sco_cb.sco_recv_cond);
2114 pthread_mutex_unlock(&sco_cb.sco_recv_mutex);
2115
2116 sco_cb.current_pos = 0;
2117 i += (sco_packet_len - 1);
2118 }
2119 }
2120 }
2121 }
2122 }
2123 #endif
2124
userial_handle_recv_data(unsigned char * recv_buffer,unsigned int total_length)2125 static int userial_handle_recv_data(unsigned char *recv_buffer, unsigned int total_length)
2126 {
2127 serial_data_type_t type = 0;
2128 unsigned char *p_data = recv_buffer;
2129 unsigned int length = total_length;
2130 uint8_t event;
2131
2132 if (!length)
2133 {
2134 HILOGE("%s, length is 0, return immediately", __func__);
2135 return total_length;
2136 }
2137 switch (received_packet_state)
2138 {
2139 case RTKBT_PACKET_IDLE:
2140 received_packet_bytes_need = 1;
2141 while (length)
2142 {
2143 type = p_data[0];
2144 length--;
2145 p_data++;
2146 if (type < DATA_TYPE_ACL || type > DATA_TYPE_EVENT)
2147 {
2148 HILOGE("%s invalid data type: %d", __func__, type);
2149 assert((type > DATA_TYPE_COMMAND) && (type <= DATA_TYPE_EVENT));
2150 if (!length)
2151 return total_length;
2152
2153 continue;
2154 }
2155 break;
2156 }
2157 recv_packet_current_type = type;
2158 received_packet_state = RTKBT_PACKET_TYPE;
2159 // fall through
2160
2161 case RTKBT_PACKET_TYPE:
2162 received_packet_bytes_need = hci_preamble_sizes[HCI_PACKET_TYPE_TO_INDEX(recv_packet_current_type)];
2163 received_resvered_length = 0;
2164 received_packet_state = RTKBT_PACKET_HEADER;
2165 // fall through
2166
2167 case RTKBT_PACKET_HEADER:
2168 if (length >= received_packet_bytes_need)
2169 {
2170 memcpy(&received_resvered_header[received_resvered_length], p_data, received_packet_bytes_need);
2171 received_resvered_length += received_packet_bytes_need;
2172 length -= received_packet_bytes_need;
2173 p_data += received_packet_bytes_need;
2174 }
2175 else
2176 {
2177 memcpy(&received_resvered_header[received_resvered_length], p_data, length);
2178 received_resvered_length += length;
2179 received_packet_bytes_need -= length;
2180 length = 0;
2181 return total_length;
2182 }
2183 received_packet_state = RTKBT_PACKET_CONTENT;
2184
2185 if (recv_packet_current_type == DATA_TYPE_ACL)
2186 {
2187 received_packet_bytes_need = *(uint16_t *)&received_resvered_header[2];
2188 }
2189 else if (recv_packet_current_type == DATA_TYPE_EVENT)
2190 {
2191 received_packet_bytes_need = received_resvered_header[1];
2192 }
2193 else
2194 {
2195 received_packet_bytes_need = received_resvered_header[2];
2196 }
2197 // fall through
2198
2199 case RTKBT_PACKET_CONTENT:
2200 if (recv_packet_current_type == DATA_TYPE_EVENT)
2201 {
2202 event = received_resvered_header[0];
2203
2204 if (event == HCI_COMMAND_COMPLETE_EVT)
2205 {
2206 if (received_resvered_length == 2)
2207 {
2208 if (length >= 1)
2209 {
2210 *p_data = 1;
2211 }
2212 }
2213 }
2214 else if (event == HCI_COMMAND_STATUS_EVT)
2215 {
2216 if (received_resvered_length < 4)
2217 {
2218 unsigned int act_len = 4 - received_resvered_length;
2219 if (length >= act_len)
2220 {
2221 *(p_data + act_len - 1) = 1;
2222 }
2223 }
2224 }
2225 }
2226 if (length >= received_packet_bytes_need)
2227 {
2228 memcpy(&received_resvered_header[received_resvered_length], p_data, received_packet_bytes_need);
2229 length -= received_packet_bytes_need;
2230 p_data += received_packet_bytes_need;
2231 received_resvered_length += received_packet_bytes_need;
2232 received_packet_bytes_need = 0;
2233 }
2234 else
2235 {
2236 memcpy(&received_resvered_header[received_resvered_length], p_data, length);
2237 received_resvered_length += length;
2238 received_packet_bytes_need -= length;
2239 length = 0;
2240 return total_length;
2241 }
2242 received_packet_state = RTKBT_PACKET_END;
2243 // fall through
2244
2245 case RTKBT_PACKET_END:
2246 switch (recv_packet_current_type)
2247 {
2248 case DATA_TYPE_EVENT:
2249 userial_handle_event(received_resvered_header, received_resvered_length);
2250 break;
2251 #ifdef CONFIG_SCO_OVER_HCI
2252 case DATA_TYPE_SCO:
2253 userial_enqueue_recv_sco_data(received_resvered_header, received_resvered_length);
2254 break;
2255 #endif
2256 default:
2257
2258 break;
2259 }
2260 break;
2261
2262 default:
2263
2264 break;
2265 }
2266
2267 received_packet_state = RTKBT_PACKET_IDLE;
2268 received_packet_bytes_need = 0;
2269 recv_packet_current_type = 0;
2270 received_resvered_length = 0;
2271
2272 return (total_length - length);
2273 }
2274 #endif
2275
h5_data_ready_cb(serial_data_type_t type,unsigned int total_length)2276 static void h5_data_ready_cb(serial_data_type_t type, unsigned int total_length)
2277 {
2278 unsigned char buffer[1028] = {0};
2279 int length = 0;
2280 length = h5_int_interface->h5_int_read_data(&buffer[1], total_length);
2281 if (length == -1)
2282 {
2283 HILOGE("%s, error read length", __func__);
2284 assert(length != -1);
2285 }
2286 buffer[0] = type;
2287 length++;
2288 uint16_t transmitted_length = 0;
2289 unsigned int real_length = length;
2290 #ifdef RTK_HANDLE_EVENT
2291 unsigned int read_length = 0;
2292 do
2293 {
2294 read_length += userial_handle_recv_data(buffer + read_length, real_length - read_length);
2295 } while (vnd_userial.thread_running && read_length < total_length);
2296 #endif
2297
2298 while (length > 0)
2299 {
2300 ssize_t ret;
2301 RTK_NO_INTR(ret = write(vnd_userial.uart_fd[1], buffer + transmitted_length, length));
2302 switch (ret)
2303 {
2304 case -1:
2305 HILOGE("In %s, error writing to the uart serial port: %s", __func__, strerror(errno));
2306 goto done;
2307 case 0:
2308 // If we wrote nothing, don't loop more because we
2309 // can't go to infinity or beyond
2310 goto done;
2311 default:
2312 transmitted_length += ret;
2313 length -= ret;
2314 break;
2315 }
2316 }
2317 done:;
2318 if (real_length)
2319 userial_enqueue_coex_rawdata(buffer, real_length, true);
2320 return;
2321 }
2322
2323 // This recv data from driver which is sent or recv by the controller. The data type have ACL/SCO/EVENT
2324 // direction CONTROLLER -----> BT HOST
userial_recv_uart_rawdata(unsigned char * buffer,unsigned int total_length)2325 static void userial_recv_uart_rawdata(unsigned char *buffer, unsigned int total_length)
2326 {
2327 unsigned int length = total_length;
2328 uint16_t transmitted_length = 0;
2329 #ifdef RTK_HANDLE_EVENT
2330 unsigned int read_length = 0;
2331 do
2332 {
2333 read_length += userial_handle_recv_data(buffer + read_length, total_length - read_length);
2334 } while (read_length < total_length);
2335 #endif
2336 while (length > 0 && vnd_userial.thread_running)
2337 {
2338 ssize_t ret;
2339 RTK_NO_INTR(ret = write(vnd_userial.uart_fd[1], buffer + transmitted_length, length));
2340 switch (ret)
2341 {
2342 case -1:
2343 HILOGE("In %s, error writing to the uart serial port: %s", __func__, strerror(errno));
2344 goto done;
2345 case 0:
2346 // If we wrote nothing, don't loop more because we
2347 // can't go to infinity or beyond
2348 goto done;
2349 default:
2350 transmitted_length += ret;
2351 length -= ret;
2352 break;
2353 }
2354 }
2355 done:;
2356 if (total_length)
2357 userial_enqueue_coex_rawdata(buffer, total_length, true);
2358 return;
2359 }
2360
userial_recv_rawdata_hook(unsigned char * buffer,unsigned int total_length)2361 void userial_recv_rawdata_hook(unsigned char *buffer, unsigned int total_length)
2362 {
2363 uint16_t transmitted_length = 0;
2364 unsigned int real_length = total_length;
2365
2366 while (vnd_userial.thread_running && (total_length > 0))
2367 {
2368 ssize_t ret;
2369 RTK_NO_INTR(ret = write(vnd_userial.uart_fd[1], buffer + transmitted_length, total_length));
2370 switch (ret)
2371 {
2372 case -1:
2373 HILOGE("In %s, error writing to the uart serial port: %s", __func__, strerror(errno));
2374 goto done;
2375 case 0:
2376 // If we wrote nothing, don't loop more because we
2377 // can't go to infinity or beyond
2378 goto done;
2379 default:
2380 transmitted_length += ret;
2381 total_length -= ret;
2382 break;
2383 }
2384 }
2385 done:;
2386 if (real_length && vnd_userial.thread_running)
2387 userial_enqueue_coex_rawdata(buffer, real_length, true);
2388 return;
2389 }
2390
userial_recv_socket_thread(void * arg)2391 static void *userial_recv_socket_thread(void *arg)
2392 {
2393 RTK_UNUSED(arg);
2394 struct epoll_event events[64];
2395 int j;
2396 while (vnd_userial.thread_running)
2397 {
2398 int ret;
2399 do
2400 {
2401 ret = epoll_wait(vnd_userial.epoll_fd, events, 32, 500);
2402 } while (vnd_userial.thread_running && ret == -1 && errno == EINTR);
2403
2404 if (ret == -1)
2405 {
2406 HILOGE("%s error in epoll_wait: %s", __func__, strerror(errno));
2407 }
2408 for (j = 0; j < ret; ++j)
2409 {
2410 struct rtk_object_t *object = (struct rtk_object_t *)events[j].data.ptr;
2411 if (events[j].data.ptr == NULL)
2412 continue;
2413 else
2414 {
2415 if (events[j].events & (EPOLLIN | EPOLLHUP | EPOLLRDHUP | EPOLLERR) && object->read_ready)
2416 object->read_ready(object->context);
2417 if (events[j].events & EPOLLOUT && object->write_ready)
2418 object->write_ready(object->context);
2419 }
2420 }
2421 }
2422 vnd_userial.thread_socket_id = (pthread_t)-1;
2423 HILOGD("%s exit", __func__);
2424 return NULL;
2425 }
2426
userial_recv_uart_thread(void * arg)2427 static void *userial_recv_uart_thread(void *arg)
2428 {
2429 RTK_UNUSED(arg);
2430 struct pollfd pfd[2];
2431 pfd[0].events = POLLIN | POLLHUP | POLLERR | POLLRDHUP;
2432 pfd[0].fd = vnd_userial.signal_fd[1];
2433 pfd[1].events = POLLIN | POLLHUP | POLLERR | POLLRDHUP;
2434 pfd[1].fd = vnd_userial.fd;
2435 int ret;
2436 unsigned char read_buffer[2056] = {0};
2437 ssize_t bytes_read;
2438 while (vnd_userial.thread_running)
2439 {
2440 do
2441 {
2442 ret = poll(pfd, 2, 500);
2443 } while (ret == -1 && errno == EINTR && vnd_userial.thread_running);
2444
2445 // exit signal is always at first index
2446 if (pfd[0].revents && !vnd_userial.thread_running)
2447 {
2448 HILOGE("receive exit signal and stop thread ");
2449 return NULL;
2450 }
2451
2452 if (pfd[1].revents & POLLIN)
2453 {
2454 RTK_NO_INTR(bytes_read = read(vnd_userial.fd, read_buffer, sizeof(read_buffer)));
2455 if (!bytes_read)
2456 continue;
2457 if (bytes_read < 0)
2458 {
2459 HILOGE("%s, read fail, error : %s", __func__, strerror(errno));
2460 continue;
2461 }
2462
2463 if (rtkbt_transtype & RTKBT_TRANS_H5)
2464 {
2465 h5_int_interface->h5_recv_msg(read_buffer, bytes_read);
2466 }
2467 else
2468 {
2469 userial_recv_uart_rawdata(read_buffer, bytes_read);
2470 }
2471 }
2472
2473 if (pfd[1].revents & (POLLERR | POLLHUP))
2474 {
2475 HILOGE("%s poll error, fd : %d", __func__, vnd_userial.fd);
2476 vnd_userial.btdriver_state = false;
2477 close(vnd_userial.fd);
2478 return NULL;
2479 }
2480 if (ret < 0)
2481 {
2482 HILOGE("%s : error (%d)", __func__, ret);
2483 continue;
2484 }
2485 }
2486 vnd_userial.thread_uart_id = (pthread_t)-1;
2487 HILOGD("%s exit", __func__);
2488 return NULL;
2489 }
2490
userial_coex_thread(void * arg)2491 static void *userial_coex_thread(void *arg)
2492 {
2493 RTK_UNUSED(arg);
2494 struct epoll_event events[64];
2495 int j;
2496 while (vnd_userial.thread_running)
2497 {
2498 int ret;
2499 do
2500 {
2501 ret = epoll_wait(vnd_userial.cpoll_fd, events, 64, 500);
2502 } while (ret == -1 && errno == EINTR && vnd_userial.thread_running);
2503 if (ret == -1)
2504 {
2505 HILOGE("%s error in epoll_wait: %s", __func__, strerror(errno));
2506 }
2507 for (j = 0; j < ret; ++j)
2508 {
2509 struct rtk_object_t *object = (struct rtk_object_t *)events[j].data.ptr;
2510 if (events[j].data.ptr == NULL)
2511 continue;
2512 else
2513 {
2514 if (events[j].events & (EPOLLIN | EPOLLHUP | EPOLLRDHUP | EPOLLERR) && object->read_ready)
2515 object->read_ready(object->context);
2516 if (events[j].events & EPOLLOUT && object->write_ready)
2517 object->write_ready(object->context);
2518 }
2519 }
2520 }
2521 vnd_userial.thread_coex_id = (pthread_t)-1;
2522 HILOGD("%s exit", __func__);
2523 return NULL;
2524 }
2525
userial_socket_open()2526 int userial_socket_open()
2527 {
2528 int ret = 0;
2529 struct epoll_event event;
2530 if ((ret = socketpair(AF_UNIX, SOCK_STREAM, 0, vnd_userial.uart_fd)) < 0)
2531 {
2532 HILOGE("%s, errno : %s", __func__, strerror(errno));
2533 return ret;
2534 }
2535
2536 if ((ret = socketpair(AF_UNIX, SOCK_STREAM, 0, vnd_userial.signal_fd)) < 0)
2537 {
2538 HILOGE("%s, errno : %s", __func__, strerror(errno));
2539 return ret;
2540 }
2541
2542 vnd_userial.epoll_fd = epoll_create(64);
2543 if (vnd_userial.epoll_fd == -1)
2544 {
2545 HILOGE("%s unable to create epoll instance: %s", __func__, strerror(errno));
2546 return -1;
2547 }
2548
2549 rtk_socket_object.fd = vnd_userial.uart_fd[1];
2550 rtk_socket_object.read_ready = userial_recv_H4_rawdata;
2551 memset(&event, 0, sizeof(event));
2552 event.events |= EPOLLIN | EPOLLHUP | EPOLLRDHUP | EPOLLERR;
2553 event.data.ptr = (void *)&rtk_socket_object;
2554 if (epoll_ctl(vnd_userial.epoll_fd, EPOLL_CTL_ADD, vnd_userial.uart_fd[1], &event) == -1)
2555 {
2556 HILOGE("%s unable to register fd %d to epoll set: %s", __func__, vnd_userial.uart_fd[1], strerror(errno));
2557 close(vnd_userial.epoll_fd);
2558 vnd_userial.epoll_fd = -1;
2559 return -1;
2560 }
2561
2562 event.data.ptr = NULL;
2563 if (epoll_ctl(vnd_userial.epoll_fd, EPOLL_CTL_ADD, vnd_userial.signal_fd[1], &event) == -1)
2564 {
2565 HILOGE("%s unable to register signal fd %d to epoll set: %s", __func__, vnd_userial.signal_fd[1], strerror(errno));
2566 close(vnd_userial.epoll_fd);
2567 vnd_userial.epoll_fd = -1;
2568 return -1;
2569 }
2570 pthread_attr_t thread_attr;
2571 pthread_attr_init(&thread_attr);
2572 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
2573 vnd_userial.thread_running = true;
2574 if (pthread_create(&vnd_userial.thread_socket_id, &thread_attr, userial_recv_socket_thread, NULL) != 0)
2575 {
2576 HILOGE("pthread_create : %s", strerror(errno));
2577 close(vnd_userial.epoll_fd);
2578 vnd_userial.epoll_fd = -1;
2579 vnd_userial.thread_socket_id = (pthread_t)-1;
2580 return -1;
2581 }
2582
2583 if (pthread_create(&vnd_userial.thread_uart_id, &thread_attr, userial_recv_uart_thread, NULL) != 0)
2584 {
2585 HILOGE("pthread_create : %s", strerror(errno));
2586 close(vnd_userial.epoll_fd);
2587 vnd_userial.thread_running = false;
2588 pthread_join(vnd_userial.thread_socket_id, NULL);
2589 vnd_userial.thread_socket_id = (pthread_t)-1;
2590 return -1;
2591 }
2592
2593 vnd_userial.cpoll_fd = epoll_create(64);
2594 assert(vnd_userial.cpoll_fd != -1);
2595
2596 vnd_userial.event_fd = eventfd(10, EFD_NONBLOCK);
2597 assert(vnd_userial.event_fd != -1);
2598 if (vnd_userial.event_fd != -1)
2599 {
2600 rtk_coex_object.fd = vnd_userial.event_fd;
2601 rtk_coex_object.read_ready = userial_coex_handler;
2602 memset(&event, 0, sizeof(event));
2603 event.events |= EPOLLIN | EPOLLHUP | EPOLLRDHUP | EPOLLERR;
2604 event.data.ptr = (void *)&rtk_coex_object;
2605 if (epoll_ctl(vnd_userial.cpoll_fd, EPOLL_CTL_ADD, vnd_userial.event_fd, &event) == -1)
2606 {
2607 HILOGE("%s unable to register fd %d to cpoll set: %s", __func__, vnd_userial.event_fd, strerror(errno));
2608 assert(false);
2609 }
2610
2611 event.data.ptr = NULL;
2612 if (epoll_ctl(vnd_userial.cpoll_fd, EPOLL_CTL_ADD, vnd_userial.signal_fd[1], &event) == -1)
2613 {
2614 HILOGE("%s unable to register fd %d to cpoll set: %s", __func__, vnd_userial.signal_fd[1], strerror(errno));
2615 assert(false);
2616 }
2617
2618 if (pthread_create(&vnd_userial.thread_coex_id, &thread_attr, userial_coex_thread, NULL) != 0)
2619 {
2620 HILOGE("pthread create coex : %s", strerror(errno));
2621 vnd_userial.thread_coex_id = (pthread_t)-1;
2622 assert(false);
2623 }
2624 }
2625
2626 ret = vnd_userial.uart_fd[0];
2627 return ret;
2628 }
2629
userial_vendor_usb_ioctl(int operation,void * param)2630 int userial_vendor_usb_ioctl(int operation, void *param)
2631 {
2632 int retval;
2633 retval = ioctl(vnd_userial.fd, operation, param);
2634 if (retval == -1)
2635 HILOGE("%s: error: %d : %s", __func__, errno, strerror(errno));
2636 return retval;
2637 }
2638
userial_vendor_usb_open(void)2639 int userial_vendor_usb_open(void)
2640 {
2641 if ((vnd_userial.fd = open(vnd_userial.port_name, O_RDWR)) == -1)
2642 {
2643 HILOGE("%s: unable to open %s: %s", __func__, vnd_userial.port_name, strerror(errno));
2644 return -1;
2645 }
2646
2647 vnd_userial.btdriver_state = true;
2648 HILOGI("device fd = %d open", vnd_userial.fd);
2649
2650 return vnd_userial.fd;
2651 }
2652