1 /*
2 *
3 * Realtek Bluetooth USB driver
4 *
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/types.h>
27 #include <linux/sched.h>
28 #include <linux/errno.h>
29 #include <linux/skbuff.h>
30 #include <linux/usb.h>
31 #include <linux/dcache.h>
32 #include <net/sock.h>
33 #include <asm/unaligned.h>
34
35 #include "rtk_bt.h"
36 #include "rtk_misc.h"
37
38 #define VERSION "3.1.969e923.20210423-153940"
39
40 #ifdef BTCOEX
41 #include "rtk_coex.h"
42 #endif
43
44 #ifdef RTKBT_SWITCH_PATCH
45 #include <linux/semaphore.h>
46 #include <net/bluetooth/hci_core.h>
47 DEFINE_SEMAPHORE(switch_sem);
48 #endif
49
50 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 7, 1)
51 static bool reset = 0;
52 #endif
53
54 static struct usb_driver btusb_driver;
55 static struct usb_device_id btusb_table[] = {
56 {
57 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
58 USB_DEVICE_ID_MATCH_INT_INFO,
59 .idVendor = 0x0bda,
60 .bInterfaceClass = 0xe0,
61 .bInterfaceSubClass = 0x01,
62 .bInterfaceProtocol = 0x01
63 }, {
64 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
65 USB_DEVICE_ID_MATCH_INT_INFO,
66 .idVendor = 0x13d3,
67 .bInterfaceClass = 0xe0,
68 .bInterfaceSubClass = 0x01,
69 .bInterfaceProtocol = 0x01
70 }, {
71 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
72 USB_DEVICE_ID_MATCH_INT_INFO,
73 .idVendor = 0x0489,
74 .bInterfaceClass = 0xe0,
75 .bInterfaceSubClass = 0x01,
76 .bInterfaceProtocol = 0x01
77 }, {
78 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
79 USB_DEVICE_ID_MATCH_INT_INFO,
80 .idVendor = 0x1358,
81 .bInterfaceClass = 0xe0,
82 .bInterfaceSubClass = 0x01,
83 .bInterfaceProtocol = 0x01
84 }, {
85 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
86 USB_DEVICE_ID_MATCH_INT_INFO,
87 .idVendor = 0x04ca,
88 .bInterfaceClass = 0xe0,
89 .bInterfaceSubClass = 0x01,
90 .bInterfaceProtocol = 0x01
91 }, {
92 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
93 USB_DEVICE_ID_MATCH_INT_INFO,
94 .idVendor = 0x2ff8,
95 .bInterfaceClass = 0xe0,
96 .bInterfaceSubClass = 0x01,
97 .bInterfaceProtocol = 0x01
98 }, {
99 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
100 USB_DEVICE_ID_MATCH_INT_INFO,
101 .idVendor = 0x0b05,
102 .bInterfaceClass = 0xe0,
103 .bInterfaceSubClass = 0x01,
104 .bInterfaceProtocol = 0x01
105 }, {
106 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
107 USB_DEVICE_ID_MATCH_INT_INFO,
108 .idVendor = 0x0930,
109 .bInterfaceClass = 0xe0,
110 .bInterfaceSubClass = 0x01,
111 .bInterfaceProtocol = 0x01
112 }, {
113 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
114 USB_DEVICE_ID_MATCH_INT_INFO,
115 .idVendor = 0x10ec,
116 .bInterfaceClass = 0xe0,
117 .bInterfaceSubClass = 0x01,
118 .bInterfaceProtocol = 0x01
119 }, {
120 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
121 USB_DEVICE_ID_MATCH_INT_INFO,
122 .idVendor = 0x04c5,
123 .bInterfaceClass = 0xe0,
124 .bInterfaceSubClass = 0x01,
125 .bInterfaceProtocol = 0x01
126 }, {
127 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
128 USB_DEVICE_ID_MATCH_INT_INFO,
129 .idVendor = 0x0cb5,
130 .bInterfaceClass = 0xe0,
131 .bInterfaceSubClass = 0x01,
132 .bInterfaceProtocol = 0x01
133 }, {
134 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
135 USB_DEVICE_ID_MATCH_INT_INFO,
136 .idVendor = 0x0cb8,
137 .bInterfaceClass = 0xe0,
138 .bInterfaceSubClass = 0x01,
139 .bInterfaceProtocol = 0x01
140 }, { }
141 };
142
rtk_free(struct btusb_data * data)143 static void rtk_free(struct btusb_data *data)
144 {
145 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 1)
146 kfree(data);
147 #endif
148 return;
149 }
150
rtk_alloc(struct usb_interface * intf)151 static struct btusb_data *rtk_alloc(struct usb_interface *intf)
152 {
153 struct btusb_data *data;
154 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 1)
155 data = kzalloc(sizeof(*data), GFP_KERNEL);
156 #else
157 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
158 #endif
159 return data;
160 }
161
162 MODULE_DEVICE_TABLE(usb, btusb_table);
163
inc_tx(struct btusb_data * data)164 static int inc_tx(struct btusb_data *data)
165 {
166 unsigned long flags;
167 int rv;
168
169 spin_lock_irqsave(&data->txlock, flags);
170 rv = test_bit(BTUSB_SUSPENDING, &data->flags);
171 if (!rv)
172 data->tx_in_flight++;
173 spin_unlock_irqrestore(&data->txlock, flags);
174
175 return rv;
176 }
177
178 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0)
btusb_free_frags(struct btusb_data * data)179 static inline void btusb_free_frags(struct btusb_data *data)
180 {
181 unsigned long flags;
182
183 spin_lock_irqsave(&data->rxlock, flags);
184
185 kfree_skb(data->evt_skb);
186 data->evt_skb = NULL;
187
188 kfree_skb(data->acl_skb);
189 data->acl_skb = NULL;
190
191 kfree_skb(data->sco_skb);
192 data->sco_skb = NULL;
193
194 spin_unlock_irqrestore(&data->rxlock, flags);
195 }
196
btusb_recv_intr(struct btusb_data * data,void * buffer,int count)197 static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)
198 {
199 struct sk_buff *skb;
200 int err = 0;
201
202 spin_lock(&data->rxlock);
203 skb = data->evt_skb;
204
205 while (count) {
206 int len;
207
208 if (!skb) {
209 skb = bt_skb_alloc(HCI_MAX_EVENT_SIZE, GFP_ATOMIC);
210 if (!skb) {
211 err = -ENOMEM;
212 break;
213 }
214
215 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
216 bt_cb(skb)->expect = HCI_EVENT_HDR_SIZE;
217 }
218
219 len = min_t(uint, bt_cb(skb)->expect, count);
220 memcpy(skb_put(skb, len), buffer, len);
221
222 count -= len;
223 buffer += len;
224 bt_cb(skb)->expect -= len;
225
226 if (skb->len == HCI_EVENT_HDR_SIZE) {
227 /* Complete event header */
228 bt_cb(skb)->expect = hci_event_hdr(skb)->plen;
229
230 if (skb_tailroom(skb) < bt_cb(skb)->expect) {
231 kfree_skb(skb);
232 skb = NULL;
233
234 err = -EILSEQ;
235 break;
236 }
237 }
238
239 if (bt_cb(skb)->expect == 0) {
240 /* Complete frame */
241 hci_recv_frame(data->hdev, skb);
242 skb = NULL;
243 }
244 }
245
246 data->evt_skb = skb;
247 spin_unlock(&data->rxlock);
248
249 return err;
250 }
251
btusb_recv_bulk(struct btusb_data * data,void * buffer,int count)252 static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)
253 {
254 struct sk_buff *skb;
255 int err = 0;
256
257 spin_lock(&data->rxlock);
258 skb = data->acl_skb;
259
260 while (count) {
261 int len;
262
263 if (!skb) {
264 skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
265 if (!skb) {
266 err = -ENOMEM;
267 break;
268 }
269
270 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
271 bt_cb(skb)->expect = HCI_ACL_HDR_SIZE;
272 }
273
274 len = min_t(uint, bt_cb(skb)->expect, count);
275 memcpy(skb_put(skb, len), buffer, len);
276
277 count -= len;
278 buffer += len;
279 bt_cb(skb)->expect -= len;
280
281 if (skb->len == HCI_ACL_HDR_SIZE) {
282 __le16 dlen = hci_acl_hdr(skb)->dlen;
283
284 /* Complete ACL header */
285 bt_cb(skb)->expect = __le16_to_cpu(dlen);
286
287 if (skb_tailroom(skb) < bt_cb(skb)->expect) {
288 kfree_skb(skb);
289 skb = NULL;
290
291 err = -EILSEQ;
292 break;
293 }
294 }
295
296 if (bt_cb(skb)->expect == 0) {
297 /* Complete frame */
298 hci_recv_frame(data->hdev, skb);
299 skb = NULL;
300 }
301 }
302
303 data->acl_skb = skb;
304 spin_unlock(&data->rxlock);
305
306 return err;
307 }
308
btusb_recv_isoc(struct btusb_data * data,void * buffer,int count)309 static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)
310 {
311 struct sk_buff *skb;
312 int err = 0;
313
314 spin_lock(&data->rxlock);
315 skb = data->sco_skb;
316
317 while (count) {
318 int len;
319
320 if (!skb) {
321 skb = bt_skb_alloc(HCI_MAX_SCO_SIZE, GFP_ATOMIC);
322 if (!skb) {
323 err = -ENOMEM;
324 break;
325 }
326
327 bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
328 bt_cb(skb)->expect = HCI_SCO_HDR_SIZE;
329 }
330
331 len = min_t(uint, bt_cb(skb)->expect, count);
332 memcpy(skb_put(skb, len), buffer, len);
333
334 count -= len;
335 buffer += len;
336 bt_cb(skb)->expect -= len;
337
338 if (skb->len == HCI_SCO_HDR_SIZE) {
339 /* Complete SCO header */
340 bt_cb(skb)->expect = hci_sco_hdr(skb)->dlen;
341
342 if (skb_tailroom(skb) < bt_cb(skb)->expect) {
343 kfree_skb(skb);
344 skb = NULL;
345
346 err = -EILSEQ;
347 break;
348 }
349 }
350
351 if (bt_cb(skb)->expect == 0) {
352 /* Complete frame */
353 hci_recv_frame(data->hdev, skb);
354 skb = NULL;
355 }
356 }
357
358 data->sco_skb = skb;
359 spin_unlock(&data->rxlock);
360
361 return err;
362 }
363 #endif
364
btusb_intr_complete(struct urb * urb)365 static void btusb_intr_complete(struct urb *urb)
366 {
367 struct hci_dev *hdev = urb->context;
368 struct btusb_data *data = GET_DRV_DATA(hdev);
369 int err;
370
371 //RTKBT_DBG("%s: urb %p status %d count %d ", __func__,
372 //urb, urb->status, urb->actual_length);
373
374 if (!test_bit(HCI_RUNNING, &hdev->flags))
375 return;
376
377 if (urb->status == 0) {
378 hdev->stat.byte_rx += urb->actual_length;
379
380 #ifdef BTCOEX
381 rtk_btcoex_parse_event(urb->transfer_buffer,
382 urb->actual_length);
383 #endif
384 #if HCI_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
385 if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
386 urb->transfer_buffer,
387 urb->actual_length) < 0) {
388 RTKBT_ERR("%s: Corrupted event packet", __func__);
389 hdev->stat.err_rx++;
390 }
391 #else
392 if (btusb_recv_intr(data, urb->transfer_buffer,
393 urb->actual_length) < 0) {
394 RTKBT_ERR("%s corrupted event packet", hdev->name);
395 hdev->stat.err_rx++;
396 }
397 #endif
398 }
399 /* Avoid suspend failed when usb_kill_urb */
400 else if (urb->status == -ENOENT) {
401 return;
402 }
403
404 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
405 return;
406
407 usb_mark_last_busy(data->udev);
408 usb_anchor_urb(urb, &data->intr_anchor);
409
410 err = usb_submit_urb(urb, GFP_ATOMIC);
411 if (err < 0) {
412 /* -EPERM: urb is being killed;
413 * -ENODEV: device got disconnected */
414 if (err != -EPERM && err != -ENODEV)
415 RTKBT_ERR("%s: Failed to re-submit urb %p, err %d",
416 __func__, urb, err);
417 usb_unanchor_urb(urb);
418 }
419 }
420
btusb_submit_intr_urb(struct hci_dev * hdev,gfp_t mem_flags)421 static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
422 {
423 struct btusb_data *data = GET_DRV_DATA(hdev);
424 struct urb *urb;
425 unsigned char *buf;
426 unsigned int pipe;
427 int err, size;
428
429 //RTKBT_DBG("%s", hdev->name);
430
431 if (!data->intr_ep)
432 return -ENODEV;
433
434 urb = usb_alloc_urb(0, mem_flags);
435 if (!urb)
436 return -ENOMEM;
437
438 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
439
440 buf = kmalloc(size, mem_flags);
441 if (!buf) {
442 usb_free_urb(urb);
443 return -ENOMEM;
444 }
445
446 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
447
448 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
449 btusb_intr_complete, hdev, data->intr_ep->bInterval);
450
451 urb->transfer_flags |= URB_FREE_BUFFER;
452
453 usb_anchor_urb(urb, &data->intr_anchor);
454
455 err = usb_submit_urb(urb, mem_flags);
456 if (err < 0) {
457 RTKBT_ERR
458 ("btusb_submit_intr_urb %s urb %p submission failed (%d)",
459 hdev->name, urb, -err);
460 usb_unanchor_urb(urb);
461 }
462
463 usb_free_urb(urb);
464
465 return err;
466 }
467
btusb_bulk_complete(struct urb * urb)468 static void btusb_bulk_complete(struct urb *urb)
469 {
470 struct hci_dev *hdev = urb->context;
471 struct btusb_data *data = GET_DRV_DATA(hdev);
472 int err;
473
474 //RTKBT_DBG("%s: urb %p status %d count %d",
475 //__func__, urb, urb->status, urb->actual_length);
476
477 if (!test_bit(HCI_RUNNING, &hdev->flags))
478 return;
479
480 #ifdef BTCOEX
481 if (urb->status == 0)
482 rtk_btcoex_parse_l2cap_data_rx(urb->transfer_buffer,
483 urb->actual_length);
484 #endif
485
486 if (urb->status == 0) {
487 hdev->stat.byte_rx += urb->actual_length;
488
489 #if HCI_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
490 if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
491 urb->transfer_buffer,
492 urb->actual_length) < 0) {
493 RTKBT_ERR("%s: Corrupted ACL packet", __func__);
494 hdev->stat.err_rx++;
495 }
496 #else
497 if (data->recv_bulk(data, urb->transfer_buffer,
498 urb->actual_length) < 0) {
499 RTKBT_ERR("%s corrupted ACL packet", hdev->name);
500 hdev->stat.err_rx++;
501 }
502 #endif
503 }
504 /* Avoid suspend failed when usb_kill_urb */
505 else if (urb->status == -ENOENT) {
506 return;
507 }
508
509 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
510 return;
511
512 usb_anchor_urb(urb, &data->bulk_anchor);
513 usb_mark_last_busy(data->udev);
514
515 err = usb_submit_urb(urb, GFP_ATOMIC);
516 if (err < 0) {
517 /* -EPERM: urb is being killed;
518 * -ENODEV: device got disconnected */
519 if (err != -EPERM && err != -ENODEV)
520 RTKBT_ERR
521 ("btusb_bulk_complete %s urb %p failed to resubmit (%d)",
522 hdev->name, urb, -err);
523 usb_unanchor_urb(urb);
524 }
525 }
526
btusb_submit_bulk_urb(struct hci_dev * hdev,gfp_t mem_flags)527 static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
528 {
529 struct btusb_data *data = GET_DRV_DATA(hdev);
530 struct urb *urb;
531 unsigned char *buf;
532 unsigned int pipe;
533 int err, size = HCI_MAX_FRAME_SIZE;
534
535 //RTKBT_DBG("%s: hdev name %s", __func__, hdev->name);
536
537 if (!data->bulk_rx_ep)
538 return -ENODEV;
539
540 urb = usb_alloc_urb(0, mem_flags);
541 if (!urb)
542 return -ENOMEM;
543
544 buf = kmalloc(size, mem_flags);
545 if (!buf) {
546 usb_free_urb(urb);
547 return -ENOMEM;
548 }
549
550 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
551
552 usb_fill_bulk_urb(urb, data->udev, pipe,
553 buf, size, btusb_bulk_complete, hdev);
554
555 urb->transfer_flags |= URB_FREE_BUFFER;
556
557 usb_mark_last_busy(data->udev);
558 usb_anchor_urb(urb, &data->bulk_anchor);
559
560 err = usb_submit_urb(urb, mem_flags);
561 if (err < 0) {
562 RTKBT_ERR("%s: Failed to submit urb %p, err %d", __func__, urb,
563 err);
564 usb_unanchor_urb(urb);
565 }
566
567 usb_free_urb(urb);
568
569 return err;
570 }
571
btusb_isoc_complete(struct urb * urb)572 static void btusb_isoc_complete(struct urb *urb)
573 {
574 struct hci_dev *hdev = urb->context;
575 struct btusb_data *data = GET_DRV_DATA(hdev);
576 int i, err;
577
578 /*
579 RTKBT_DBG("%s urb %p status %d count %d", hdev->name,
580 urb, urb->status, urb->actual_length);
581 */
582 if (!test_bit(HCI_RUNNING, &hdev->flags))
583 return;
584
585 if (urb->status == 0) {
586 for (i = 0; i < urb->number_of_packets; i++) {
587 unsigned int offset = urb->iso_frame_desc[i].offset;
588 unsigned int length =
589 urb->iso_frame_desc[i].actual_length;
590
591 if (urb->iso_frame_desc[i].status)
592 continue;
593
594 hdev->stat.byte_rx += length;
595
596 #if HCI_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
597 if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
598 urb->transfer_buffer + offset,
599 length) < 0) {
600 RTKBT_ERR("%s: Corrupted SCO packet", __func__);
601 hdev->stat.err_rx++;
602 }
603 #else
604 if (btusb_recv_isoc(data, urb->transfer_buffer + offset,
605 length) < 0) {
606 RTKBT_ERR("%s corrupted SCO packet",
607 hdev->name);
608 hdev->stat.err_rx++;
609 }
610 #endif
611 }
612 }
613 /* Avoid suspend failed when usb_kill_urb */
614 else if (urb->status == -ENOENT) {
615 return;
616 }
617
618 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
619 return;
620
621 usb_anchor_urb(urb, &data->isoc_anchor);
622 i = 0;
623 retry:
624 err = usb_submit_urb(urb, GFP_ATOMIC);
625 if (err < 0) {
626 /* -EPERM: urb is being killed;
627 * -ENODEV: device got disconnected */
628 if (err != -EPERM && err != -ENODEV)
629 RTKBT_ERR
630 ("%s: Failed to re-sumbit urb %p, retry %d, err %d",
631 __func__, urb, i, err);
632 if (i < 10) {
633 i++;
634 mdelay(1);
635 goto retry;
636 }
637
638 usb_unanchor_urb(urb);
639 }
640 }
641
__fill_isoc_descriptor(struct urb * urb,int len,int mtu)642 static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
643 {
644 int i, offset = 0;
645
646 //RTKBT_DBG("len %d mtu %d", len, mtu);
647
648 for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
649 i++, offset += mtu, len -= mtu) {
650 urb->iso_frame_desc[i].offset = offset;
651 urb->iso_frame_desc[i].length = mtu;
652 }
653
654 if (len && i < BTUSB_MAX_ISOC_FRAMES) {
655 urb->iso_frame_desc[i].offset = offset;
656 urb->iso_frame_desc[i].length = len;
657 i++;
658 }
659
660 urb->number_of_packets = i;
661 }
662
btusb_submit_isoc_urb(struct hci_dev * hdev,gfp_t mem_flags)663 static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
664 {
665 struct btusb_data *data = GET_DRV_DATA(hdev);
666 struct urb *urb;
667 unsigned char *buf;
668 unsigned int pipe;
669 int err, size;
670
671 //RTKBT_DBG("%s", hdev->name);
672
673 if (!data->isoc_rx_ep)
674 return -ENODEV;
675
676 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
677 if (!urb)
678 return -ENOMEM;
679
680 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
681 BTUSB_MAX_ISOC_FRAMES;
682
683 buf = kmalloc(size, mem_flags);
684 if (!buf) {
685 usb_free_urb(urb);
686 return -ENOMEM;
687 }
688
689 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
690
691 urb->dev = data->udev;
692 urb->pipe = pipe;
693 urb->context = hdev;
694 urb->complete = btusb_isoc_complete;
695 urb->interval = data->isoc_rx_ep->bInterval;
696
697 urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
698 urb->transfer_buffer = buf;
699 urb->transfer_buffer_length = size;
700
701 __fill_isoc_descriptor(urb, size,
702 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
703
704 usb_anchor_urb(urb, &data->isoc_anchor);
705
706 err = usb_submit_urb(urb, mem_flags);
707 if (err < 0) {
708 RTKBT_ERR("%s %s urb %p submission failed (%d)",
709 __func__, hdev->name, urb, err);
710 usb_unanchor_urb(urb);
711 }
712
713 usb_free_urb(urb);
714
715 return err;
716 }
717
btusb_tx_complete(struct urb * urb)718 static void btusb_tx_complete(struct urb *urb)
719 {
720 struct sk_buff *skb = urb->context;
721 struct hci_dev *hdev = (struct hci_dev *)skb->dev;
722 struct btusb_data *data = GET_DRV_DATA(hdev);
723
724 // RTKBT_DBG("btusb_tx_complete %s urb %p status %d count %d", hdev->name,
725 // urb, urb->status, urb->actual_length);
726
727 if (!test_bit(HCI_RUNNING, &hdev->flags))
728 goto done;
729
730 if (!urb->status)
731 hdev->stat.byte_tx += urb->transfer_buffer_length;
732 else
733 hdev->stat.err_tx++;
734
735 done:
736 spin_lock(&data->txlock);
737 data->tx_in_flight--;
738 spin_unlock(&data->txlock);
739
740 kfree(urb->setup_packet);
741
742 kfree_skb(skb);
743 }
744
btusb_isoc_tx_complete(struct urb * urb)745 static void btusb_isoc_tx_complete(struct urb *urb)
746 {
747 struct sk_buff *skb = urb->context;
748 struct hci_dev *hdev = (struct hci_dev *)skb->dev;
749
750 //RTKBT_DBG("%s: urb %p status %d count %d",
751 //__func__, urb, urb->status, urb->actual_length);
752
753 if (skb && hdev) {
754 if (!test_bit(HCI_RUNNING, &hdev->flags))
755 goto done;
756
757 if (!urb->status)
758 hdev->stat.byte_tx += urb->transfer_buffer_length;
759 else
760 hdev->stat.err_tx++;
761 } else
762 RTKBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev);
763
764 done:
765 kfree(urb->setup_packet);
766
767 kfree_skb(skb);
768 }
769
btusb_open(struct hci_dev * hdev)770 static int btusb_open(struct hci_dev *hdev)
771 {
772 struct btusb_data *data = GET_DRV_DATA(hdev);
773 int err;
774
775 err = usb_autopm_get_interface(data->intf);
776 if (err < 0)
777 return err;
778
779 data->intf->needs_remote_wakeup = 1;
780 RTKBT_DBG("%s start", __func__);
781
782 /*******************************/
783 if (0 == atomic_read(&hdev->promisc)) {
784 RTKBT_ERR("btusb_open hdev->promisc ==0");
785 err = -1;
786 //goto failed;
787 }
788
789 err = download_patch(data->intf);
790 if (err < 0)
791 goto failed;
792 /*******************************/
793
794 RTKBT_INFO("%s set HCI_RUNNING", __func__);
795 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
796 goto done;
797
798 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
799 goto done;
800
801 err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
802 if (err < 0)
803 goto failed;
804
805 err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
806 if (err < 0) {
807 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
808 usb_kill_anchored_urbs(&data->intr_anchor);
809 goto failed;
810 }
811
812 set_bit(BTUSB_BULK_RUNNING, &data->flags);
813 btusb_submit_bulk_urb(hdev, GFP_KERNEL);
814
815 done:
816 usb_autopm_put_interface(data->intf);
817
818 #ifdef BTCOEX
819 rtk_btcoex_open(hdev);
820 #endif
821 RTKBT_DBG("%s end", __FUNCTION__);
822
823 return 0;
824
825 failed:
826 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
827 clear_bit(HCI_RUNNING, &hdev->flags);
828 usb_autopm_put_interface(data->intf);
829 RTKBT_ERR("%s failed", __FUNCTION__);
830 return err;
831 }
832
btusb_stop_traffic(struct btusb_data * data)833 static void btusb_stop_traffic(struct btusb_data *data)
834 {
835 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
836 usb_kill_anchored_urbs(&data->intr_anchor);
837 usb_kill_anchored_urbs(&data->bulk_anchor);
838 usb_kill_anchored_urbs(&data->isoc_anchor);
839 }
840
btusb_close(struct hci_dev * hdev)841 static int btusb_close(struct hci_dev *hdev)
842 {
843 struct btusb_data *data = GET_DRV_DATA(hdev);
844 int err;
845
846 #if HCI_VERSION_CODE < KERNEL_VERSION(4, 1, 0)
847 int i;
848 #endif
849
850 /* When in kernel 4.4.0 and greater, the HCI_RUNNING bit is
851 * cleared in hci_dev_do_close(). */
852 #if HCI_VERSION_CODE < KERNEL_VERSION(4, 4, 0)
853 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
854 return 0;
855 #else
856 if (test_bit(HCI_RUNNING, &hdev->flags)) {
857 RTKBT_ERR("HCI_RUNNING is not cleared before.");
858 return -1;
859 }
860 #endif
861
862 RTKBT_DBG("btusb_close");
863 #if HCI_VERSION_CODE < KERNEL_VERSION(4, 1, 0)
864 /*******************************/
865 for (i = 0; i < NUM_REASSEMBLY; i++) {
866 if (hdev->reassembly[i]) {
867 kfree_skb(hdev->reassembly[i]);
868 hdev->reassembly[i] = NULL;
869 RTKBT_DBG("%s free ressembly i=%d", __FUNCTION__, i);
870 }
871 }
872 /*******************************/
873 #endif
874 cancel_work_sync(&data->work);
875 cancel_work_sync(&data->waker);
876
877 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
878 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
879 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
880
881 btusb_stop_traffic(data);
882 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0)
883 btusb_free_frags(data);
884 #endif
885
886 err = usb_autopm_get_interface(data->intf);
887 if (err < 0)
888 goto failed;
889
890 data->intf->needs_remote_wakeup = 0;
891 usb_autopm_put_interface(data->intf);
892
893 #ifdef BTCOEX
894 rtk_btcoex_close();
895 #endif
896
897 failed:
898 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
899 usb_scuttle_anchored_urbs(&data->deferred);
900
901 #ifdef RTKBT_SWITCH_PATCH
902 down(&switch_sem);
903 if (data->context) {
904 struct api_context *ctx = data->context;
905
906 if (ctx->flags & RTLBT_CLOSE) {
907 ctx->flags &= ~RTLBT_CLOSE;
908 ctx->status = 0;
909 complete(&ctx->done);
910 }
911 }
912 up(&switch_sem);
913 #endif
914
915 return 0;
916 }
917
btusb_flush(struct hci_dev * hdev)918 static int btusb_flush(struct hci_dev *hdev)
919 {
920 struct btusb_data *data = GET_DRV_DATA(hdev);
921
922 RTKBT_DBG("%s add delay ", __FUNCTION__);
923 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
924 usb_kill_anchored_urbs(&data->tx_anchor);
925 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0)
926 btusb_free_frags(data);
927 #endif
928
929 return 0;
930 }
931
932 const char pkt_ind[][8] = {
933 [HCI_COMMAND_PKT] = "cmd",
934 [HCI_ACLDATA_PKT] = "acl",
935 [HCI_SCODATA_PKT] = "sco",
936 };
937
938 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 13, 0)
btusb_send_frame(struct hci_dev * hdev,struct sk_buff * skb)939 int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
940 {
941 #else
942 int btusb_send_frame(struct sk_buff *skb)
943 {
944 struct hci_dev *hdev = (struct hci_dev *)skb->dev;
945 #endif
946
947 struct btusb_data *data = GET_DRV_DATA(hdev);
948 struct usb_ctrlrequest *dr;
949 struct urb *urb;
950 unsigned int pipe;
951 int err;
952
953 //RTKBT_DBG("%s", hdev->name);
954
955 if (!test_bit(HCI_RUNNING, &hdev->flags)) {
956 /* If the parameter is wrong, the hdev isn't the correct
957 * one. Then no HCI commands can be sent.
958 * This issue is related to the wrong HCI_VERSION_CODE set */
959 RTKBT_ERR("HCI is not running");
960 return -EBUSY;
961 }
962
963 /* Before kernel/hci version 3.13.0, the skb->dev is set before
964 * entering btusb_send_frame(). So there is no need to set it here.
965 *
966 * The skb->dev will be used in the callbacks when urb transfer
967 * completes. See btusb_tx_complete() and btusb_isoc_tx_complete() */
968 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 13, 0)
969 skb->dev = (void *)hdev;
970 #endif
971
972 switch (bt_cb(skb)->pkt_type) {
973 case HCI_COMMAND_PKT:
974 print_command(skb);
975
976 #ifdef BTCOEX
977 rtk_btcoex_parse_cmd(skb->data, skb->len);
978 #endif
979 urb = usb_alloc_urb(0, GFP_ATOMIC);
980 if (!urb)
981 return -ENOMEM;
982
983 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
984 if (!dr) {
985 usb_free_urb(urb);
986 return -ENOMEM;
987 }
988
989 dr->bRequestType = data->cmdreq_type;
990 dr->bRequest = 0;
991 dr->wIndex = 0;
992 dr->wValue = 0;
993 dr->wLength = __cpu_to_le16(skb->len);
994
995 pipe = usb_sndctrlpipe(data->udev, 0x00);
996
997 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
998 skb->data, skb->len, btusb_tx_complete,
999 skb);
1000
1001 hdev->stat.cmd_tx++;
1002 break;
1003
1004 case HCI_ACLDATA_PKT:
1005 print_acl(skb, 1);
1006 #ifdef BTCOEX
1007 rtk_btcoex_parse_l2cap_data_tx(skb->data, skb->len);
1008 #endif
1009 if (!data->bulk_tx_ep)
1010 return -ENODEV;
1011
1012 urb = usb_alloc_urb(0, GFP_ATOMIC);
1013 if (!urb)
1014 return -ENOMEM;
1015
1016 pipe = usb_sndbulkpipe(data->udev,
1017 data->bulk_tx_ep->bEndpointAddress);
1018
1019 usb_fill_bulk_urb(urb, data->udev, pipe,
1020 skb->data, skb->len, btusb_tx_complete, skb);
1021
1022 hdev->stat.acl_tx++;
1023 break;
1024
1025 case HCI_SCODATA_PKT:
1026 if (!data->isoc_tx_ep || SCO_NUM < 1)
1027 return -ENODEV;
1028
1029 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
1030 if (!urb)
1031 return -ENOMEM;
1032
1033 pipe = usb_sndisocpipe(data->udev,
1034 data->isoc_tx_ep->bEndpointAddress);
1035
1036 usb_fill_int_urb(urb, data->udev, pipe,
1037 skb->data, skb->len, btusb_isoc_tx_complete,
1038 skb, data->isoc_tx_ep->bInterval);
1039
1040 urb->transfer_flags = URB_ISO_ASAP;
1041
1042 __fill_isoc_descriptor(urb, skb->len,
1043 le16_to_cpu(data->isoc_tx_ep->
1044 wMaxPacketSize));
1045
1046 hdev->stat.sco_tx++;
1047 goto skip_waking;
1048
1049 default:
1050 return -EILSEQ;
1051 }
1052
1053 err = inc_tx(data);
1054 if (err) {
1055 usb_anchor_urb(urb, &data->deferred);
1056 schedule_work(&data->waker);
1057 err = 0;
1058 goto done;
1059 }
1060
1061 skip_waking:
1062 usb_anchor_urb(urb, &data->tx_anchor);
1063 err = usb_submit_urb(urb, GFP_ATOMIC);
1064 if (err < 0) {
1065 RTKBT_ERR("%s %s urb %p submission for %s failed, err %d",
1066 __func__, hdev->name, urb,
1067 pkt_ind[bt_cb(skb)->pkt_type], err);
1068 kfree(urb->setup_packet);
1069 usb_unanchor_urb(urb);
1070 } else {
1071 usb_mark_last_busy(data->udev);
1072 }
1073 usb_free_urb(urb);
1074
1075 done:
1076 return err;
1077 }
1078
1079 #if HCI_VERSION_CODE < KERNEL_VERSION(3, 4, 0)
1080 static void btusb_destruct(struct hci_dev *hdev)
1081 {
1082 RTKBT_DBG("btusb_destruct %s", hdev->name);
1083 hci_free_dev(hdev);
1084 }
1085 #endif
1086
1087 static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
1088 {
1089 struct btusb_data *data = GET_DRV_DATA(hdev);
1090
1091 RTKBT_DBG("%s: %s evt %d", __func__, hdev->name, evt);
1092
1093 if (SCO_NUM != data->sco_num) {
1094 data->sco_num = SCO_NUM;
1095 RTKBT_DBG("%s: Update sco num %d", __func__, data->sco_num);
1096 schedule_work(&data->work);
1097 }
1098 }
1099
1100 static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
1101 {
1102 struct btusb_data *data = GET_DRV_DATA(hdev);
1103 struct usb_interface *intf = data->isoc;
1104 struct usb_endpoint_descriptor *ep_desc;
1105 int i, err;
1106
1107 if (!data->isoc)
1108 return -ENODEV;
1109
1110 RTKBT_INFO("set isoc interface: alt %d", altsetting);
1111
1112 err = usb_set_interface(data->udev, 1, altsetting);
1113 if (err < 0) {
1114 RTKBT_ERR("%s setting interface failed (%d)", hdev->name, -err);
1115 return err;
1116 }
1117
1118 data->isoc_altsetting = altsetting;
1119
1120 data->isoc_tx_ep = NULL;
1121 data->isoc_rx_ep = NULL;
1122
1123 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
1124 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
1125
1126 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
1127 data->isoc_tx_ep = ep_desc;
1128 continue;
1129 }
1130
1131 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
1132 data->isoc_rx_ep = ep_desc;
1133 continue;
1134 }
1135 }
1136
1137 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
1138 RTKBT_ERR("%s invalid SCO descriptors", hdev->name);
1139 return -ENODEV;
1140 }
1141
1142 return 0;
1143 }
1144
1145 static void btusb_work(struct work_struct *work)
1146 {
1147 struct btusb_data *data = container_of(work, struct btusb_data, work);
1148 struct hci_dev *hdev = data->hdev;
1149 int err;
1150 int new_alts;
1151
1152 RTKBT_DBG("%s: sco num %d", __func__, data->sco_num);
1153 if (data->sco_num > 0) {
1154 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
1155 err =
1156 usb_autopm_get_interface(data->isoc ? data->
1157 isoc : data->intf);
1158 if (err < 0) {
1159 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1160 mdelay(URB_CANCELING_DELAY_MS);
1161 usb_kill_anchored_urbs(&data->isoc_anchor);
1162 return;
1163 }
1164
1165 set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
1166 }
1167 #if HCI_VERSION_CODE > KERNEL_VERSION(3, 7, 1)
1168 if (hdev->voice_setting & 0x0020) {
1169 static const int alts[3] = { 2, 4, 5 };
1170 new_alts = alts[data->sco_num - 1];
1171 } else {
1172 new_alts = data->sco_num;
1173 }
1174 if (data->isoc_altsetting != new_alts) {
1175 #else
1176 if (data->isoc_altsetting != 2) {
1177 new_alts = 2;
1178 #endif
1179
1180 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1181 mdelay(URB_CANCELING_DELAY_MS);
1182 usb_kill_anchored_urbs(&data->isoc_anchor);
1183
1184 if (__set_isoc_interface(hdev, new_alts) < 0)
1185 return;
1186 }
1187
1188 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1189 RTKBT_INFO("submit SCO RX urb.");
1190 if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
1191 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1192 else
1193 btusb_submit_isoc_urb(hdev, GFP_KERNEL);
1194 }
1195 } else {
1196 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1197 mdelay(URB_CANCELING_DELAY_MS);
1198 usb_kill_anchored_urbs(&data->isoc_anchor);
1199
1200 __set_isoc_interface(hdev, 0);
1201 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
1202 usb_autopm_put_interface(data->isoc ? data->
1203 isoc : data->intf);
1204 }
1205 }
1206
1207 static void btusb_waker(struct work_struct *work)
1208 {
1209 struct btusb_data *data = container_of(work, struct btusb_data, waker);
1210 int err;
1211
1212 err = usb_autopm_get_interface(data->intf);
1213 RTKBT_DBG("%s start", __FUNCTION__);
1214 if (err < 0)
1215 return;
1216
1217 usb_autopm_put_interface(data->intf);
1218 RTKBT_DBG("%s end", __FUNCTION__);
1219 }
1220
1221 #ifdef RTKBT_TV_POWERON_WHITELIST
1222 static int rtkbt_lookup_le_device_poweron_whitelist(struct hci_dev *hdev,
1223 struct usb_device *udev)
1224 {
1225 struct hci_conn_params *p;
1226 u8 *cmd;
1227 int result = 0;
1228
1229 hci_dev_lock(hdev);
1230 list_for_each_entry(p, &hdev->le_conn_params, list) {
1231 #if 0 // for debug message
1232 RTKBT_DBG("%s(): auto_connect = %d", __FUNCTION__, p->auto_connect);
1233 RTKBT_DBG("%s(): addr_type = 0x%02x", __FUNCTION__, p->addr_type);
1234 RTKBT_DBG("%s(): addr=%02x:%02x:%02x:%02x:%02x:%02x", __FUNCTION__,
1235 p->addr.b[5], p->addr.b[4], p->addr.b[3],
1236 p->addr.b[2], p->addr.b[1], p->addr.b[0]);
1237 #endif
1238 if ( p->auto_connect == HCI_AUTO_CONN_ALWAYS &&
1239 p->addr_type == ADDR_LE_DEV_PUBLIC ) {
1240
1241 RTKBT_DBG("%s(): Set RTKBT LE Power-on Whitelist for "
1242 "%02x:%02x:%02x:%02x:%02x:%02x", __FUNCTION__,
1243 p->addr.b[5], p->addr.b[4], p->addr.b[3],
1244 p->addr.b[2], p->addr.b[1], p->addr.b[0]);
1245
1246 cmd = kzalloc(16, GFP_ATOMIC);
1247 if (!cmd) {
1248 RTKBT_ERR("Can't allocate memory for cmd");
1249 return -ENOMEM;
1250 }
1251 cmd[0] = 0x7b;
1252 cmd[1] = 0xfc;
1253 cmd[2] = 0x07;
1254 cmd[3] = 0x00;
1255 cmd[4] = p->addr.b[0];
1256 cmd[5] = p->addr.b[1];
1257 cmd[6] = p->addr.b[2];
1258 cmd[7] = p->addr.b[3];
1259 cmd[8] = p->addr.b[4];
1260 cmd[9] = p->addr.b[5];
1261
1262 result = __rtk_send_hci_cmd(udev, cmd, 10);
1263 kfree(cmd);
1264 }
1265 }
1266 hci_dev_unlock(hdev);
1267
1268 return result;
1269 }
1270 #endif
1271
1272 int rtkbt_pm_notify(struct notifier_block *notifier,
1273 ulong pm_event, void *unused)
1274 {
1275 struct btusb_data *data;
1276 struct usb_device *udev;
1277 struct usb_interface *intf;
1278 struct hci_dev *hdev;
1279 /* int err; */
1280 #if defined RTKBT_SWITCH_PATCH || defined RTKBT_TV_POWERON_WHITELIST
1281 int result = 0;
1282 #endif
1283 #ifdef RTKBT_SWITCH_PATCH
1284 u8 *cmd;
1285 static u8 hci_state = 0;
1286 struct api_context ctx;
1287 #endif
1288
1289 data = container_of(notifier, struct btusb_data, pm_notifier);
1290 udev = data->udev;
1291 intf = data->intf;
1292 hdev = data->hdev;
1293
1294 RTKBT_DBG("%s: pm_event %ld", __func__, pm_event);
1295 switch (pm_event) {
1296 case PM_SUSPEND_PREPARE:
1297 case PM_HIBERNATION_PREPARE:
1298 /* No need to load firmware because the download firmware
1299 * process is deprecated in resume.
1300 * We use rebind after resume instead */
1301 /* err = usb_autopm_get_interface(data->intf);
1302 * if (err < 0)
1303 * return err;
1304 * patch_entry->fw_len =
1305 * load_firmware(dev_entry, &patch_entry->fw_cache);
1306 * usb_autopm_put_interface(data->intf);
1307 * if (patch_entry->fw_len <= 0) {
1308 * RTKBT_DBG("rtkbt_pm_notify return NOTIFY_BAD");
1309 * return NOTIFY_BAD;
1310 * } */
1311
1312 RTKBT_DBG("%s: suspend prepare", __func__);
1313
1314 if (!device_may_wakeup(&udev->dev)) {
1315 #ifdef CONFIG_NEEDS_BINDING
1316 intf->needs_binding = 1;
1317 RTKBT_DBG("Remote wakeup not support, set "
1318 "intf->needs_binding = 1");
1319 #else
1320 RTKBT_DBG("Remote wakeup not support, no needs binding");
1321 #endif
1322 }
1323
1324 #ifdef RTKBT_SWITCH_PATCH
1325 if (test_bit(HCI_UP, &hdev->flags)) {
1326 unsigned long expire;
1327
1328 init_completion(&ctx.done);
1329 hci_state = 1;
1330
1331 down(&switch_sem);
1332 data->context = &ctx;
1333 ctx.flags = RTLBT_CLOSE;
1334 queue_work(hdev->req_workqueue, &hdev->power_off.work);
1335 up(&switch_sem);
1336
1337 expire = msecs_to_jiffies(1000);
1338 if (!wait_for_completion_timeout(&ctx.done, expire))
1339 RTKBT_ERR("hdev close timeout");
1340
1341 down(&switch_sem);
1342 data->context = NULL;
1343 up(&switch_sem);
1344 }
1345
1346 cmd = kzalloc(16, GFP_ATOMIC);
1347 if (!cmd) {
1348 RTKBT_ERR("Can't allocate memory for cmd");
1349 return -ENOMEM;
1350 }
1351
1352 /* Clear patch */
1353 cmd[0] = 0x66;
1354 cmd[1] = 0xfc;
1355 cmd[2] = 0x00;
1356
1357 result = __rtk_send_hci_cmd(udev, cmd, 3);
1358 kfree(cmd);
1359 msleep(100); /* From FW colleague's recommendation */
1360 result = download_lps_patch(intf);
1361
1362 /* Tell the controller to wake up host if received special
1363 * advertising packet
1364 */
1365 set_scan(intf);
1366
1367 /* Send special vendor commands */
1368 #endif
1369
1370 #ifdef RTKBT_TV_POWERON_WHITELIST
1371 result = rtkbt_lookup_le_device_poweron_whitelist(hdev, udev);
1372 if (result < 0) {
1373 RTKBT_ERR("rtkbt_lookup_le_device_poweron_whitelist error: %d", result);
1374 }
1375 #endif
1376 break;
1377
1378 case PM_POST_SUSPEND:
1379 case PM_POST_HIBERNATION:
1380 case PM_POST_RESTORE:
1381 /* if (patch_entry->fw_len > 0) {
1382 * kfree(patch_entry->fw_cache);
1383 * patch_entry->fw_cache = NULL;
1384 * patch_entry->fw_len = 0;
1385 * } */
1386
1387 #ifdef RTKBT_SWITCH_PATCH
1388 cmd = kzalloc(16, GFP_ATOMIC);
1389 if (!cmd) {
1390 RTKBT_ERR("Can't allocate memory for cmd");
1391 return -ENOMEM;
1392 }
1393
1394 /* Clear patch */
1395 cmd[0] = 0x66;
1396 cmd[1] = 0xfc;
1397 cmd[2] = 0x00;
1398
1399 result = __rtk_send_hci_cmd(udev, cmd, 3);
1400 kfree(cmd);
1401 msleep(100); /* From FW colleague's recommendation */
1402 result = download_patch(intf);
1403 if (hci_state) {
1404 hci_state = 0;
1405 queue_work(hdev->req_workqueue, &hdev->power_on);
1406 }
1407 #endif
1408
1409 #if BTUSB_RPM
1410 RTKBT_DBG("%s: Re-enable autosuspend", __func__);
1411 /* pm_runtime_use_autosuspend(&udev->dev);
1412 * pm_runtime_set_autosuspend_delay(&udev->dev, 2000);
1413 * pm_runtime_set_active(&udev->dev);
1414 * pm_runtime_allow(&udev->dev);
1415 * pm_runtime_mark_last_busy(&udev->dev);
1416 * pm_runtime_autosuspend(&udev->dev);
1417 * pm_runtime_put_autosuspend(&udev->dev);
1418 * usb_disable_autosuspend(udev); */
1419 /* FIXME: usb_enable_autosuspend(udev) is useless here.
1420 * Because it is always enabled after enabled in btusb_probe()
1421 */
1422 usb_enable_autosuspend(udev);
1423 pm_runtime_mark_last_busy(&udev->dev);
1424 #endif
1425 break;
1426
1427 default:
1428 break;
1429 }
1430
1431 return NOTIFY_DONE;
1432 }
1433
1434
1435 static int btusb_probe(struct usb_interface *intf,
1436 const struct usb_device_id *id)
1437 {
1438 struct usb_endpoint_descriptor *ep_desc;
1439 struct btusb_data *data;
1440 struct hci_dev *hdev;
1441 int i, err, flag1, flag2;
1442 struct usb_device *udev;
1443 udev = interface_to_usbdev(intf);
1444
1445 RTKBT_DBG("btusb_probe intf->cur_altsetting->desc.bInterfaceNumber %d",
1446 intf->cur_altsetting->desc.bInterfaceNumber);
1447
1448 /* interface numbers are hardcoded in the spec */
1449 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
1450 return -ENODEV;
1451
1452 /*******************************/
1453 flag1 = device_can_wakeup(&udev->dev);
1454 flag2 = device_may_wakeup(&udev->dev);
1455 RTKBT_DBG("btusb_probe can_wakeup %x, may wakeup %x", flag1, flag2);
1456 #if BTUSB_WAKEUP_HOST
1457 device_wakeup_enable(&udev->dev);
1458 #endif
1459 //device_wakeup_enable(&udev->dev);
1460 /*device_wakeup_disable(&udev->dev);
1461 flag1=device_can_wakeup(&udev->dev);
1462 flag2=device_may_wakeup(&udev->dev);
1463 RTKBT_DBG("btusb_probe can_wakeup=%x flag2=%x",flag1,flag2);
1464 */
1465 err = patch_add(intf);
1466 if (err < 0)
1467 return -1;
1468 /*******************************/
1469
1470 data = rtk_alloc(intf);
1471 if (!data)
1472 return -ENOMEM;
1473
1474 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
1475 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
1476
1477 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
1478 data->intr_ep = ep_desc;
1479 continue;
1480 }
1481
1482 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
1483 data->bulk_tx_ep = ep_desc;
1484 continue;
1485 }
1486
1487 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
1488 data->bulk_rx_ep = ep_desc;
1489 continue;
1490 }
1491 }
1492
1493 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {
1494 rtk_free(data);
1495 return -ENODEV;
1496 }
1497
1498 data->cmdreq_type = USB_TYPE_CLASS;
1499
1500 data->udev = interface_to_usbdev(intf);
1501 data->intf = intf;
1502
1503 spin_lock_init(&data->lock);
1504
1505 INIT_WORK(&data->work, btusb_work);
1506 INIT_WORK(&data->waker, btusb_waker);
1507 spin_lock_init(&data->txlock);
1508
1509 init_usb_anchor(&data->tx_anchor);
1510 init_usb_anchor(&data->intr_anchor);
1511 init_usb_anchor(&data->bulk_anchor);
1512 init_usb_anchor(&data->isoc_anchor);
1513 init_usb_anchor(&data->deferred);
1514
1515 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0)
1516 spin_lock_init(&data->rxlock);
1517 data->recv_bulk = btusb_recv_bulk;
1518 #endif
1519
1520 hdev = hci_alloc_dev();
1521 if (!hdev) {
1522 rtk_free(data);
1523 return -ENOMEM;
1524 }
1525
1526 HDEV_BUS = HCI_USB;
1527
1528 data->hdev = hdev;
1529
1530 SET_HCIDEV_DEV(hdev, &intf->dev);
1531
1532 hdev->open = btusb_open;
1533 hdev->close = btusb_close;
1534 hdev->flush = btusb_flush;
1535 hdev->send = btusb_send_frame;
1536 hdev->notify = btusb_notify;
1537
1538 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 4, 0)
1539 hci_set_drvdata(hdev, data);
1540 #else
1541 hdev->driver_data = data;
1542 hdev->destruct = btusb_destruct;
1543 hdev->owner = THIS_MODULE;
1544 #endif
1545
1546 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 7, 1)
1547 if (!reset)
1548 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
1549 RTKBT_DBG("set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);");
1550 #endif
1551
1552 /* Interface numbers are hardcoded in the specification */
1553 data->isoc = usb_ifnum_to_if(data->udev, 1);
1554
1555 if (data->isoc) {
1556 err = usb_driver_claim_interface(&btusb_driver,
1557 data->isoc, data);
1558 if (err < 0) {
1559 hci_free_dev(hdev);
1560 rtk_free(data);
1561 return err;
1562 }
1563 }
1564
1565 #if HCI_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
1566 set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
1567 #endif
1568
1569 err = hci_register_dev(hdev);
1570 if (err < 0) {
1571 hci_free_dev(hdev);
1572 rtk_free(data);
1573 return err;
1574 }
1575
1576 usb_set_intfdata(intf, data);
1577
1578 /* Register PM notifier */
1579 data->pm_notifier.notifier_call = rtkbt_pm_notify;
1580 register_pm_notifier(&data->pm_notifier);
1581
1582 #ifdef BTCOEX
1583 rtk_btcoex_probe(hdev);
1584 #endif
1585
1586 RTKBT_DBG("%s: done", __func__);
1587
1588 return 0;
1589 }
1590
1591 static void btusb_disconnect(struct usb_interface *intf)
1592 {
1593 struct btusb_data *data = usb_get_intfdata(intf);
1594 struct hci_dev *hdev;
1595 struct usb_device *udev;
1596 udev = interface_to_usbdev(intf);
1597
1598 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
1599 return;
1600
1601 if (!data)
1602 return;
1603
1604 RTKBT_DBG("btusb_disconnect");
1605
1606 /* Un-register PM notifier */
1607 unregister_pm_notifier(&data->pm_notifier);
1608
1609 /*******************************/
1610 patch_remove(intf);
1611 /*******************************/
1612
1613 hdev = data->hdev;
1614
1615 #if HCI_VERSION_CODE < KERNEL_VERSION(3, 4, 0)
1616 __hci_dev_hold(hdev);
1617 #endif
1618
1619 usb_set_intfdata(data->intf, NULL);
1620
1621 if (data->isoc)
1622 usb_set_intfdata(data->isoc, NULL);
1623
1624 hci_unregister_dev(hdev);
1625
1626 if (intf == data->isoc)
1627 usb_driver_release_interface(&btusb_driver, data->intf);
1628 else if (data->isoc)
1629 usb_driver_release_interface(&btusb_driver, data->isoc);
1630
1631 #if HCI_VERSION_CODE < KERNEL_VERSION(3, 4, 0)
1632 __hci_dev_put(hdev);
1633 #endif
1634
1635 #if HCI_VERSION_CODE >= KERNEL_VERSION(3, 18, 0)
1636 btusb_free_frags(data);
1637 #endif
1638
1639 hci_free_dev(hdev);
1640 rtk_free(data);
1641 }
1642
1643 #ifdef CONFIG_PM
1644 static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
1645 {
1646 struct btusb_data *data = usb_get_intfdata(intf);
1647
1648 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
1649 return 0;
1650
1651 /*******************************/
1652 RTKBT_DBG("btusb_suspend message.event 0x%x, data->suspend_count %d",
1653 message.event, data->suspend_count);
1654 if (!test_bit(HCI_RUNNING, &data->hdev->flags)) {
1655 RTKBT_INFO("%s: hdev is not HCI_RUNNING", __func__);
1656 /* set_scan(data->intf); */
1657 }
1658 /*******************************/
1659
1660 if (data->suspend_count++)
1661 return 0;
1662
1663 spin_lock_irq(&data->txlock);
1664 if (!((message.event & PM_EVENT_AUTO) && data->tx_in_flight)) {
1665 set_bit(BTUSB_SUSPENDING, &data->flags);
1666 spin_unlock_irq(&data->txlock);
1667 RTKBT_INFO("%s: suspending...", __func__);
1668 } else {
1669 spin_unlock_irq(&data->txlock);
1670 data->suspend_count--;
1671 return -EBUSY;
1672 }
1673
1674 cancel_work_sync(&data->work);
1675
1676 btusb_stop_traffic(data);
1677 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
1678 usb_kill_anchored_urbs(&data->tx_anchor);
1679
1680 return 0;
1681 }
1682
1683 static void play_deferred(struct btusb_data *data)
1684 {
1685 struct urb *urb;
1686 int err;
1687
1688 while ((urb = usb_get_from_anchor(&data->deferred))) {
1689 /************************************/
1690 usb_anchor_urb(urb, &data->tx_anchor);
1691 err = usb_submit_urb(urb, GFP_ATOMIC);
1692 if (err < 0) {
1693 RTKBT_ERR("play_deferred urb %p submission failed",
1694 urb);
1695 kfree(urb->setup_packet);
1696 usb_unanchor_urb(urb);
1697 } else {
1698 usb_mark_last_busy(data->udev);
1699 }
1700 usb_free_urb(urb);
1701 /************************************/
1702 data->tx_in_flight++;
1703 }
1704 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
1705 usb_scuttle_anchored_urbs(&data->deferred);
1706 }
1707
1708 static int btusb_resume(struct usb_interface *intf)
1709 {
1710 struct btusb_data *data = usb_get_intfdata(intf);
1711 struct hci_dev *hdev = data->hdev;
1712 int err = 0;
1713
1714 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
1715 return 0;
1716
1717 /*******************************/
1718 RTKBT_DBG("%s: data->suspend_count %d", __func__, data->suspend_count);
1719
1720 /* if intf->needs_binding is set, driver will be rebind.
1721 * The probe will be called instead of resume */
1722 /* if (!test_bit(HCI_RUNNING, &hdev->flags)) {
1723 * RTKBT_DBG("btusb_resume-----bt is off,download patch");
1724 * download_patch(intf);
1725 * } else
1726 * RTKBT_DBG("btusb_resume,----bt is on");
1727 */
1728 /*******************************/
1729 if (--data->suspend_count)
1730 return 0;
1731
1732 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
1733 err = btusb_submit_intr_urb(hdev, GFP_NOIO);
1734 if (err < 0) {
1735 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1736 goto failed;
1737 }
1738 }
1739
1740 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
1741 err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
1742 if (err < 0) {
1743 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
1744 goto failed;
1745 }
1746
1747 btusb_submit_bulk_urb(hdev, GFP_NOIO);
1748 }
1749
1750 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1751 if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
1752 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1753 else
1754 btusb_submit_isoc_urb(hdev, GFP_NOIO);
1755 }
1756
1757 spin_lock_irq(&data->txlock);
1758 play_deferred(data);
1759 clear_bit(BTUSB_SUSPENDING, &data->flags);
1760 spin_unlock_irq(&data->txlock);
1761 schedule_work(&data->work);
1762
1763 RTKBT_DBG("%s: data->suspend_count %d, done", __func__,
1764 data->suspend_count);
1765
1766 return 0;
1767
1768 failed:
1769 mdelay(URB_CANCELING_DELAY_MS); // Added by Realtek
1770 usb_scuttle_anchored_urbs(&data->deferred);
1771 //done:
1772 spin_lock_irq(&data->txlock);
1773 clear_bit(BTUSB_SUSPENDING, &data->flags);
1774 spin_unlock_irq(&data->txlock);
1775 RTKBT_DBG("%s: data->suspend_count %d, fail", __func__,
1776 data->suspend_count);
1777
1778 return err;
1779 }
1780 #endif
1781
1782 static struct usb_driver btusb_driver = {
1783 .name = "rtk_btusb",
1784 .probe = btusb_probe,
1785 .disconnect = btusb_disconnect,
1786 #ifdef CONFIG_PM
1787 .suspend = btusb_suspend,
1788 .resume = btusb_resume,
1789 #ifdef RTKBT_SWITCH_PATCH
1790 .reset_resume = btusb_resume,
1791 #endif
1792 #endif
1793 .id_table = btusb_table,
1794 .supports_autosuspend = 1,
1795 #if LINUX_VERSION_CODE > KERNEL_VERSION(3, 7, 1)
1796 .disable_hub_initiated_lpm = 1,
1797 #endif
1798 };
1799
1800 static int __init btusb_init(void)
1801 {
1802 RTKBT_DBG("Realtek Bluetooth USB driver ver %s", VERSION);
1803 #ifdef BTCOEX
1804 rtk_btcoex_init();
1805 #endif
1806 return usb_register(&btusb_driver);
1807 }
1808
1809 static void __exit btusb_exit(void)
1810 {
1811 RTKBT_DBG("rtk_btusb: btusb_exit");
1812 usb_deregister(&btusb_driver);
1813
1814 #ifdef BTCOEX
1815 rtk_btcoex_exit();
1816 #endif
1817 }
1818
1819 module_init(btusb_init);
1820 module_exit(btusb_exit);
1821
1822 MODULE_AUTHOR("");
1823 MODULE_DESCRIPTION("Realtek Bluetooth USB driver ver " VERSION);
1824 MODULE_VERSION(VERSION);
1825 MODULE_LICENSE("GPL");
1826 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0))
1827 MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
1828 #endif
1829