2 HCI USB driver for Linux Bluetooth protocol stack (BlueZ)
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6 Copyright (C) 2003 Maxim Krasnyansky <maxk@qualcomm.com>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation;
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
15 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
16 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
17 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
22 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
23 SOFTWARE IS DISCLAIMED.
27 * Bluetooth HCI USB driver.
28 * Based on original USB Bluetooth driver for Linux kernel
29 * Copyright (c) 2000 Greg Kroah-Hartman <greg@kroah.com>
30 * Copyright (c) 2000 Mark Douglas Corner <mcorner@umich.edu>
34 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/init.h>
38 #include <linux/sched.h>
39 #include <linux/unistd.h>
40 #include <linux/types.h>
41 #include <linux/interrupt.h>
42 #include <linux/moduleparam.h>
44 #include <linux/slab.h>
45 #include <linux/errno.h>
46 #include <linux/string.h>
47 #include <linux/skbuff.h>
49 #include <linux/usb.h>
51 #include <net/bluetooth/bluetooth.h>
52 #include <net/bluetooth/hci_core.h>
56 #ifndef CONFIG_BT_HCIUSB_DEBUG
61 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
62 #undef URB_ZERO_PACKET
63 #define URB_ZERO_PACKET 0
66 static int ignore = 0;
67 static int ignore_dga = 0;
68 static int ignore_csr = 0;
69 static int ignore_sniffer = 0;
70 static int disable_scofix = 0;
71 static int force_scofix = 0;
74 #ifdef CONFIG_BT_HCIUSB_SCO
80 static struct usb_driver hci_usb_driver;
82 static struct usb_device_id bluetooth_ids[] = {
83 /* Generic Bluetooth USB device */
84 { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
86 /* AVM BlueFRITZ! USB v2.0 */
87 { USB_DEVICE(0x057c, 0x3800) },
89 /* Bluetooth Ultraport Module from IBM */
90 { USB_DEVICE(0x04bf, 0x030a) },
92 /* ALPS Modules with non-standard id */
93 { USB_DEVICE(0x044e, 0x3001) },
94 { USB_DEVICE(0x044e, 0x3002) },
96 /* Ericsson with non-standard id */
97 { USB_DEVICE(0x0bdb, 0x1002) },
99 /* Canyon CN-BTU1 with HID interfaces */
100 { USB_DEVICE(0x0c10, 0x0000), .driver_info = HCI_RESET },
102 { } /* Terminating entry */
105 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
107 static struct usb_device_id blacklist_ids[] = {
108 /* CSR BlueCore devices */
109 { USB_DEVICE(0x0a12, 0x0001), .driver_info = HCI_CSR },
111 /* Broadcom BCM2033 without firmware */
112 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
114 /* Broadcom BCM2035 */
115 { USB_DEVICE(0x0a5c, 0x2035), .driver_info = HCI_RESET | HCI_WRONG_SCO_MTU },
116 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET | HCI_WRONG_SCO_MTU },
117 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = HCI_BCM92035 },
119 /* IBM/Lenovo ThinkPad with Broadcom chip */
120 { USB_DEVICE(0x0a5c, 0x201e), .driver_info = HCI_WRONG_SCO_MTU },
121 { USB_DEVICE(0x0a5c, 0x2110), .driver_info = HCI_WRONG_SCO_MTU },
123 /* ANYCOM Bluetooth USB-200 and USB-250 */
124 { USB_DEVICE(0x0a5c, 0x2111), .driver_info = HCI_RESET },
126 /* HP laptop with Broadcom chip */
127 { USB_DEVICE(0x03f0, 0x171d), .driver_info = HCI_WRONG_SCO_MTU },
129 /* Dell laptop with Broadcom chip */
130 { USB_DEVICE(0x413c, 0x8126), .driver_info = HCI_WRONG_SCO_MTU },
132 /* Microsoft Wireless Transceiver for Bluetooth 2.0 */
133 { USB_DEVICE(0x045e, 0x009c), .driver_info = HCI_RESET },
135 /* Kensington Bluetooth USB adapter */
136 { USB_DEVICE(0x047d, 0x105d), .driver_info = HCI_RESET },
137 { USB_DEVICE(0x047d, 0x105e), .driver_info = HCI_WRONG_SCO_MTU },
139 /* ISSC Bluetooth Adapter v3.1 */
140 { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
142 /* RTX Telecom based adapters with buggy SCO support */
143 { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
144 { USB_DEVICE(0x0400, 0x080a), .driver_info = HCI_BROKEN_ISOC },
146 /* Belkin F8T012 and F8T013 devices */
147 { USB_DEVICE(0x050d, 0x0012), .driver_info = HCI_WRONG_SCO_MTU },
148 { USB_DEVICE(0x050d, 0x0013), .driver_info = HCI_WRONG_SCO_MTU },
150 /* Digianswer devices */
151 { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
152 { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
154 /* CSR BlueCore Bluetooth Sniffer */
155 { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
157 /* Frontline ComProbe Bluetooth Sniffer */
158 { USB_DEVICE(0x16d3, 0x0002), .driver_info = HCI_SNIFFER },
160 { } /* Terminating entry */
163 static struct _urb *_urb_alloc(int isoc, gfp_t gfp)
165 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
166 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
168 memset(_urb, 0, sizeof(*_urb));
169 usb_init_urb(&_urb->urb);
174 static struct _urb *_urb_dequeue(struct _urb_queue *q)
176 struct _urb *_urb = NULL;
178 spin_lock_irqsave(&q->lock, flags);
180 struct list_head *head = &q->head;
181 struct list_head *next = head->next;
183 _urb = list_entry(next, struct _urb, list);
184 list_del(next); _urb->queue = NULL;
187 spin_unlock_irqrestore(&q->lock, flags);
191 static void hci_usb_rx_complete(struct urb *urb);
192 static void hci_usb_tx_complete(struct urb *urb);
194 #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
195 #define __pending_q(husb, type) (&husb->pending_q[type-1])
196 #define __completed_q(husb, type) (&husb->completed_q[type-1])
197 #define __transmit_q(husb, type) (&husb->transmit_q[type-1])
198 #define __reassembly(husb, type) (husb->reassembly[type-1])
200 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
202 return _urb_dequeue(__completed_q(husb, type));
205 #ifdef CONFIG_BT_HCIUSB_SCO
206 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
210 BT_DBG("len %d mtu %d", len, mtu);
212 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
213 urb->iso_frame_desc[i].offset = offset;
214 urb->iso_frame_desc[i].length = mtu;
215 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
217 if (len && i < HCI_MAX_ISOC_FRAMES) {
218 urb->iso_frame_desc[i].offset = offset;
219 urb->iso_frame_desc[i].length = len;
220 BT_DBG("desc %d offset %d len %d", i, offset, len);
223 urb->number_of_packets = i;
227 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
231 int err, pipe, interval, size;
234 BT_DBG("%s", husb->hdev->name);
236 size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
238 buf = kmalloc(size, GFP_ATOMIC);
242 _urb = _urb_alloc(0, GFP_ATOMIC);
247 _urb->type = HCI_EVENT_PKT;
248 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
251 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
252 interval = husb->intr_in_ep->desc.bInterval;
253 usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
255 err = usb_submit_urb(urb, GFP_ATOMIC);
257 BT_ERR("%s intr rx submit failed urb %p err %d",
258 husb->hdev->name, urb, err);
266 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
270 int err, pipe, size = HCI_MAX_FRAME_SIZE;
273 buf = kmalloc(size, GFP_ATOMIC);
277 _urb = _urb_alloc(0, GFP_ATOMIC);
282 _urb->type = HCI_ACLDATA_PKT;
283 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
286 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
287 usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
288 urb->transfer_flags = 0;
290 BT_DBG("%s urb %p", husb->hdev->name, urb);
292 err = usb_submit_urb(urb, GFP_ATOMIC);
294 BT_ERR("%s bulk rx submit failed urb %p err %d",
295 husb->hdev->name, urb, err);
303 #ifdef CONFIG_BT_HCIUSB_SCO
304 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
311 mtu = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
312 size = mtu * HCI_MAX_ISOC_FRAMES;
314 buf = kmalloc(size, GFP_ATOMIC);
318 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
323 _urb->type = HCI_SCODATA_PKT;
324 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
329 urb->dev = husb->udev;
330 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
331 urb->complete = hci_usb_rx_complete;
333 urb->interval = husb->isoc_in_ep->desc.bInterval;
335 urb->transfer_buffer_length = size;
336 urb->transfer_buffer = buf;
337 urb->transfer_flags = URB_ISO_ASAP;
339 __fill_isoc_desc(urb, size, mtu);
341 BT_DBG("%s urb %p", husb->hdev->name, urb);
343 err = usb_submit_urb(urb, GFP_ATOMIC);
345 BT_ERR("%s isoc rx submit failed urb %p err %d",
346 husb->hdev->name, urb, err);
355 /* Initialize device */
356 static int hci_usb_open(struct hci_dev *hdev)
358 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
362 BT_DBG("%s", hdev->name);
364 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
367 write_lock_irqsave(&husb->completion_lock, flags);
369 err = hci_usb_intr_rx_submit(husb);
371 for (i = 0; i < HCI_MAX_BULK_RX; i++)
372 hci_usb_bulk_rx_submit(husb);
374 #ifdef CONFIG_BT_HCIUSB_SCO
375 if (husb->isoc_iface)
376 for (i = 0; i < HCI_MAX_ISOC_RX; i++)
377 hci_usb_isoc_rx_submit(husb);
380 clear_bit(HCI_RUNNING, &hdev->flags);
383 write_unlock_irqrestore(&husb->completion_lock, flags);
388 static int hci_usb_flush(struct hci_dev *hdev)
390 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
393 BT_DBG("%s", hdev->name);
395 for (i = 0; i < 4; i++)
396 skb_queue_purge(&husb->transmit_q[i]);
400 static void hci_usb_unlink_urbs(struct hci_usb *husb)
404 BT_DBG("%s", husb->hdev->name);
406 for (i = 0; i < 4; i++) {
410 /* Kill pending requests */
411 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
413 BT_DBG("%s unlinking _urb %p type %d urb %p",
414 husb->hdev->name, _urb, _urb->type, urb);
416 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
419 /* Release completed requests */
420 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
422 BT_DBG("%s freeing _urb %p type %d urb %p",
423 husb->hdev->name, _urb, _urb->type, urb);
424 kfree(urb->setup_packet);
425 kfree(urb->transfer_buffer);
429 /* Release reassembly buffers */
430 if (husb->reassembly[i]) {
431 kfree_skb(husb->reassembly[i]);
432 husb->reassembly[i] = NULL;
438 static int hci_usb_close(struct hci_dev *hdev)
440 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
443 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
446 BT_DBG("%s", hdev->name);
448 /* Synchronize with completion handlers */
449 write_lock_irqsave(&husb->completion_lock, flags);
450 write_unlock_irqrestore(&husb->completion_lock, flags);
452 hci_usb_unlink_urbs(husb);
457 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
459 struct urb *urb = &_urb->urb;
462 BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
464 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
465 err = usb_submit_urb(urb, GFP_ATOMIC);
467 BT_ERR("%s tx submit failed urb %p type %d err %d",
468 husb->hdev->name, urb, _urb->type, err);
470 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
472 atomic_inc(__pending_tx(husb, _urb->type));
477 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
479 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
480 struct usb_ctrlrequest *dr;
484 _urb = _urb_alloc(0, GFP_ATOMIC);
487 _urb->type = bt_cb(skb)->pkt_type;
489 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
495 dr = (void *) _urb->urb.setup_packet;
497 dr->bRequestType = husb->ctrl_req;
501 dr->wLength = __cpu_to_le16(skb->len);
504 usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
505 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
507 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
510 return __tx_submit(husb, _urb);
513 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
515 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
520 _urb = _urb_alloc(0, GFP_ATOMIC);
523 _urb->type = bt_cb(skb)->pkt_type;
527 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
528 usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
529 hci_usb_tx_complete, husb);
530 urb->transfer_flags = URB_ZERO_PACKET;
532 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
535 return __tx_submit(husb, _urb);
538 #ifdef CONFIG_BT_HCIUSB_SCO
539 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
541 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
545 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
548 _urb->type = bt_cb(skb)->pkt_type;
551 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
556 urb->dev = husb->udev;
557 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
558 urb->complete = hci_usb_tx_complete;
559 urb->transfer_flags = URB_ISO_ASAP;
561 urb->interval = husb->isoc_out_ep->desc.bInterval;
563 urb->transfer_buffer = skb->data;
564 urb->transfer_buffer_length = skb->len;
566 __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
569 return __tx_submit(husb, _urb);
573 static void hci_usb_tx_process(struct hci_usb *husb)
575 struct sk_buff_head *q;
578 BT_DBG("%s", husb->hdev->name);
581 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
583 /* Process command queue */
584 q = __transmit_q(husb, HCI_COMMAND_PKT);
585 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
586 (skb = skb_dequeue(q))) {
587 if (hci_usb_send_ctrl(husb, skb) < 0)
588 skb_queue_head(q, skb);
591 #ifdef CONFIG_BT_HCIUSB_SCO
592 /* Process SCO queue */
593 q = __transmit_q(husb, HCI_SCODATA_PKT);
594 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
595 (skb = skb_dequeue(q))) {
596 if (hci_usb_send_isoc(husb, skb) < 0)
597 skb_queue_head(q, skb);
601 /* Process ACL queue */
602 q = __transmit_q(husb, HCI_ACLDATA_PKT);
603 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
604 (skb = skb_dequeue(q))) {
605 if (hci_usb_send_bulk(husb, skb) < 0) {
606 skb_queue_head(q, skb);
610 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
613 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
615 /* Serialize TX queue processing to avoid data reordering */
616 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
617 hci_usb_tx_process(husb);
618 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
620 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
623 /* Send frames from HCI layer */
624 static int hci_usb_send_frame(struct sk_buff *skb)
626 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
627 struct hci_usb *husb;
630 BT_ERR("frame for uknown device (hdev=NULL)");
634 if (!test_bit(HCI_RUNNING, &hdev->flags))
637 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
639 husb = (struct hci_usb *) hdev->driver_data;
641 switch (bt_cb(skb)->pkt_type) {
642 case HCI_COMMAND_PKT:
646 case HCI_ACLDATA_PKT:
650 #ifdef CONFIG_BT_HCIUSB_SCO
651 case HCI_SCODATA_PKT:
661 read_lock(&husb->completion_lock);
663 skb_queue_tail(__transmit_q(husb, bt_cb(skb)->pkt_type), skb);
664 hci_usb_tx_wakeup(husb);
666 read_unlock(&husb->completion_lock);
670 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
672 BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
674 husb->hdev->stat.byte_rx += count;
677 struct sk_buff *skb = __reassembly(husb, type);
678 struct { int expect; } *scb;
682 /* Start of the frame */
686 if (count >= HCI_EVENT_HDR_SIZE) {
687 struct hci_event_hdr *h = data;
688 len = HCI_EVENT_HDR_SIZE + h->plen;
693 case HCI_ACLDATA_PKT:
694 if (count >= HCI_ACL_HDR_SIZE) {
695 struct hci_acl_hdr *h = data;
696 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
700 #ifdef CONFIG_BT_HCIUSB_SCO
701 case HCI_SCODATA_PKT:
702 if (count >= HCI_SCO_HDR_SIZE) {
703 struct hci_sco_hdr *h = data;
704 len = HCI_SCO_HDR_SIZE + h->dlen;
710 BT_DBG("new packet len %d", len);
712 skb = bt_skb_alloc(len, GFP_ATOMIC);
714 BT_ERR("%s no memory for the packet", husb->hdev->name);
717 skb->dev = (void *) husb->hdev;
718 bt_cb(skb)->pkt_type = type;
720 __reassembly(husb, type) = skb;
722 scb = (void *) skb->cb;
726 scb = (void *) skb->cb;
730 len = min(len, count);
732 memcpy(skb_put(skb, len), data, len);
737 __reassembly(husb, type) = NULL;
738 bt_cb(skb)->pkt_type = type;
742 count -= len; data += len;
747 static void hci_usb_rx_complete(struct urb *urb)
749 struct _urb *_urb = container_of(urb, struct _urb, urb);
750 struct hci_usb *husb = (void *) urb->context;
751 struct hci_dev *hdev = husb->hdev;
752 int err, count = urb->actual_length;
754 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
755 _urb->type, urb->status, count, urb->transfer_flags);
757 read_lock(&husb->completion_lock);
759 if (!test_bit(HCI_RUNNING, &hdev->flags))
762 if (urb->status || !count)
765 if (_urb->type == HCI_SCODATA_PKT) {
766 #ifdef CONFIG_BT_HCIUSB_SCO
768 for (i=0; i < urb->number_of_packets; i++) {
769 BT_DBG("desc %d status %d offset %d len %d", i,
770 urb->iso_frame_desc[i].status,
771 urb->iso_frame_desc[i].offset,
772 urb->iso_frame_desc[i].actual_length);
774 if (!urb->iso_frame_desc[i].status)
775 __recv_frame(husb, _urb->type,
776 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
777 urb->iso_frame_desc[i].actual_length);
783 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
785 BT_ERR("%s corrupted packet: type %d count %d",
786 husb->hdev->name, _urb->type, count);
792 urb->dev = husb->udev;
793 err = usb_submit_urb(urb, GFP_ATOMIC);
794 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
798 read_unlock(&husb->completion_lock);
801 static void hci_usb_tx_complete(struct urb *urb)
803 struct _urb *_urb = container_of(urb, struct _urb, urb);
804 struct hci_usb *husb = (void *) urb->context;
805 struct hci_dev *hdev = husb->hdev;
807 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
808 urb->status, urb->transfer_flags);
810 atomic_dec(__pending_tx(husb, _urb->type));
812 urb->transfer_buffer = NULL;
813 kfree_skb((struct sk_buff *) _urb->priv);
815 if (!test_bit(HCI_RUNNING, &hdev->flags))
819 hdev->stat.byte_tx += urb->transfer_buffer_length;
823 read_lock(&husb->completion_lock);
826 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
828 hci_usb_tx_wakeup(husb);
830 read_unlock(&husb->completion_lock);
833 static void hci_usb_destruct(struct hci_dev *hdev)
835 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
837 BT_DBG("%s", hdev->name);
842 static void hci_usb_notify(struct hci_dev *hdev, unsigned int evt)
844 BT_DBG("%s evt %d", hdev->name, evt);
847 static int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
849 struct usb_device *udev = interface_to_usbdev(intf);
850 struct usb_host_endpoint *bulk_out_ep = NULL;
851 struct usb_host_endpoint *bulk_in_ep = NULL;
852 struct usb_host_endpoint *intr_in_ep = NULL;
853 struct usb_host_endpoint *ep;
854 struct usb_host_interface *uif;
855 struct usb_interface *isoc_iface;
856 struct hci_usb *husb;
857 struct hci_dev *hdev;
858 int i, e, size, isoc_ifnum, isoc_alts;
860 BT_DBG("udev %p intf %p", udev, intf);
862 if (!id->driver_info) {
863 const struct usb_device_id *match;
864 match = usb_match_id(intf, blacklist_ids);
869 if (ignore || id->driver_info & HCI_IGNORE)
872 if (ignore_dga && id->driver_info & HCI_DIGIANSWER)
875 if (ignore_csr && id->driver_info & HCI_CSR)
878 if (ignore_sniffer && id->driver_info & HCI_SNIFFER)
881 if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
884 /* Find endpoints that we need */
885 uif = intf->cur_altsetting;
886 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
887 ep = &uif->endpoint[e];
889 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
890 case USB_ENDPOINT_XFER_INT:
891 if (ep->desc.bEndpointAddress & USB_DIR_IN)
895 case USB_ENDPOINT_XFER_BULK:
896 if (ep->desc.bEndpointAddress & USB_DIR_IN)
904 if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
905 BT_DBG("Bulk endpoints not found");
909 if (!(husb = kzalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
910 BT_ERR("Can't allocate: control structure");
915 husb->bulk_out_ep = bulk_out_ep;
916 husb->bulk_in_ep = bulk_in_ep;
917 husb->intr_in_ep = intr_in_ep;
919 if (id->driver_info & HCI_DIGIANSWER)
920 husb->ctrl_req = USB_TYPE_VENDOR;
922 husb->ctrl_req = USB_TYPE_CLASS;
924 /* Find isochronous endpoints that we can use */
930 #ifdef CONFIG_BT_HCIUSB_SCO
931 if (isoc && !(id->driver_info & (HCI_BROKEN_ISOC | HCI_SNIFFER)))
932 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
936 struct usb_host_endpoint *isoc_out_ep = NULL;
937 struct usb_host_endpoint *isoc_in_ep = NULL;
939 for (a = 0; a < isoc_iface->num_altsetting; a++) {
940 uif = &isoc_iface->altsetting[a];
941 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
942 ep = &uif->endpoint[e];
944 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
945 case USB_ENDPOINT_XFER_ISOC:
946 if (le16_to_cpu(ep->desc.wMaxPacketSize) < size ||
947 uif->desc.bAlternateSetting != isoc)
949 size = le16_to_cpu(ep->desc.wMaxPacketSize);
951 isoc_alts = uif->desc.bAlternateSetting;
953 if (ep->desc.bEndpointAddress & USB_DIR_IN)
962 if (!isoc_in_ep || !isoc_out_ep)
963 BT_DBG("Isoc endpoints not found");
965 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
966 if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
967 BT_ERR("Can't claim isoc interface");
968 else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
969 BT_ERR("Can't set isoc interface settings");
970 husb->isoc_iface = isoc_iface;
971 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
972 husb->isoc_iface = NULL;
974 husb->isoc_iface = isoc_iface;
975 husb->isoc_in_ep = isoc_in_ep;
976 husb->isoc_out_ep = isoc_out_ep;
982 rwlock_init(&husb->completion_lock);
984 for (i = 0; i < 4; i++) {
985 skb_queue_head_init(&husb->transmit_q[i]);
986 _urb_queue_init(&husb->pending_q[i]);
987 _urb_queue_init(&husb->completed_q[i]);
990 /* Initialize and register HCI device */
991 hdev = hci_alloc_dev();
993 BT_ERR("Can't allocate HCI device");
999 hdev->type = HCI_USB;
1000 hdev->driver_data = husb;
1001 SET_HCIDEV_DEV(hdev, &intf->dev);
1003 hdev->open = hci_usb_open;
1004 hdev->close = hci_usb_close;
1005 hdev->flush = hci_usb_flush;
1006 hdev->send = hci_usb_send_frame;
1007 hdev->destruct = hci_usb_destruct;
1008 hdev->notify = hci_usb_notify;
1010 hdev->owner = THIS_MODULE;
1012 if (reset || id->driver_info & HCI_RESET)
1013 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
1015 if (force_scofix || id->driver_info & HCI_WRONG_SCO_MTU) {
1016 if (!disable_scofix)
1017 set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
1020 if (id->driver_info & HCI_SNIFFER) {
1021 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
1022 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
1025 if (id->driver_info & HCI_BCM92035) {
1026 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
1027 struct sk_buff *skb;
1029 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1031 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1032 skb_queue_tail(&hdev->driver_init, skb);
1036 if (hci_register_dev(hdev) < 0) {
1037 BT_ERR("Can't register HCI device");
1042 usb_set_intfdata(intf, husb);
1046 if (husb->isoc_iface)
1047 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1054 static void hci_usb_disconnect(struct usb_interface *intf)
1056 struct hci_usb *husb = usb_get_intfdata(intf);
1057 struct hci_dev *hdev;
1059 if (!husb || intf == husb->isoc_iface)
1062 usb_set_intfdata(intf, NULL);
1065 BT_DBG("%s", hdev->name);
1067 hci_usb_close(hdev);
1069 if (husb->isoc_iface)
1070 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1072 if (hci_unregister_dev(hdev) < 0)
1073 BT_ERR("Can't unregister HCI device %s", hdev->name);
1078 static int hci_usb_suspend(struct usb_interface *intf, pm_message_t message)
1080 struct hci_usb *husb = usb_get_intfdata(intf);
1081 struct list_head killed;
1082 unsigned long flags;
1085 if (!husb || intf == husb->isoc_iface)
1088 hci_suspend_dev(husb->hdev);
1090 INIT_LIST_HEAD(&killed);
1092 for (i = 0; i < 4; i++) {
1093 struct _urb_queue *q = &husb->pending_q[i];
1094 struct _urb *_urb, *_tmp;
1096 while ((_urb = _urb_dequeue(q))) {
1097 /* reset queue since _urb_dequeue sets it to NULL */
1099 usb_kill_urb(&_urb->urb);
1100 list_add(&_urb->list, &killed);
1103 spin_lock_irqsave(&q->lock, flags);
1105 list_for_each_entry_safe(_urb, _tmp, &killed, list) {
1106 list_move_tail(&_urb->list, &q->head);
1109 spin_unlock_irqrestore(&q->lock, flags);
1115 static int hci_usb_resume(struct usb_interface *intf)
1117 struct hci_usb *husb = usb_get_intfdata(intf);
1118 unsigned long flags;
1121 if (!husb || intf == husb->isoc_iface)
1124 for (i = 0; i < 4; i++) {
1125 struct _urb_queue *q = &husb->pending_q[i];
1128 spin_lock_irqsave(&q->lock, flags);
1130 list_for_each_entry(_urb, &q->head, list) {
1131 err = usb_submit_urb(&_urb->urb, GFP_ATOMIC);
1136 spin_unlock_irqrestore(&q->lock, flags);
1142 hci_resume_dev(husb->hdev);
1147 static struct usb_driver hci_usb_driver = {
1149 .probe = hci_usb_probe,
1150 .disconnect = hci_usb_disconnect,
1151 .suspend = hci_usb_suspend,
1152 .resume = hci_usb_resume,
1153 .id_table = bluetooth_ids,
1156 static int __init hci_usb_init(void)
1160 BT_INFO("HCI USB driver ver %s", VERSION);
1162 if ((err = usb_register(&hci_usb_driver)) < 0)
1163 BT_ERR("Failed to register HCI USB driver");
1168 static void __exit hci_usb_exit(void)
1170 usb_deregister(&hci_usb_driver);
1173 module_init(hci_usb_init);
1174 module_exit(hci_usb_exit);
1176 module_param(ignore, bool, 0644);
1177 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
1179 module_param(ignore_dga, bool, 0644);
1180 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1182 module_param(ignore_csr, bool, 0644);
1183 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1185 module_param(ignore_sniffer, bool, 0644);
1186 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1188 module_param(disable_scofix, bool, 0644);
1189 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
1191 module_param(force_scofix, bool, 0644);
1192 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
1194 module_param(reset, bool, 0644);
1195 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1197 #ifdef CONFIG_BT_HCIUSB_SCO
1198 module_param(isoc, int, 0644);
1199 MODULE_PARM_DESC(isoc, "Set isochronous transfers for SCO over HCI support");
1202 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1203 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1204 MODULE_VERSION(VERSION);
1205 MODULE_LICENSE("GPL");