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;
72 #ifdef CONFIG_BT_HCIUSB_SCO
78 static struct usb_driver hci_usb_driver;
80 static struct usb_device_id bluetooth_ids[] = {
81 /* Generic Bluetooth USB device */
82 { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
84 /* AVM BlueFRITZ! USB v2.0 */
85 { USB_DEVICE(0x057c, 0x3800) },
87 /* Bluetooth Ultraport Module from IBM */
88 { USB_DEVICE(0x04bf, 0x030a) },
90 /* ALPS Modules with non-standard id */
91 { USB_DEVICE(0x044e, 0x3001) },
92 { USB_DEVICE(0x044e, 0x3002) },
94 /* Ericsson with non-standard id */
95 { USB_DEVICE(0x0bdb, 0x1002) },
97 { } /* Terminating entry */
100 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
102 static struct usb_device_id blacklist_ids[] = {
103 /* CSR BlueCore devices */
104 { USB_DEVICE(0x0a12, 0x0001), .driver_info = HCI_CSR },
106 /* Broadcom BCM2033 without firmware */
107 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
109 /* Broadcom BCM2035 */
110 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET | HCI_BROKEN_ISOC },
111 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = HCI_BCM92035 },
113 /* Microsoft Wireless Transceiver for Bluetooth 2.0 */
114 { USB_DEVICE(0x045e, 0x009c), .driver_info = HCI_RESET },
116 /* Kensington Bluetooth USB adapter */
117 { USB_DEVICE(0x047d, 0x105d), .driver_info = HCI_RESET },
119 /* ISSC Bluetooth Adapter v3.1 */
120 { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
122 /* RTX Telecom based adapter with buggy SCO support */
123 { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
125 /* Digianswer devices */
126 { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
127 { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
129 /* CSR BlueCore Bluetooth Sniffer */
130 { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
132 /* Frontline ComProbe Bluetooth Sniffer */
133 { USB_DEVICE(0x16d3, 0x0002), .driver_info = HCI_SNIFFER },
135 { } /* Terminating entry */
138 static struct _urb *_urb_alloc(int isoc, gfp_t gfp)
140 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
141 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
143 memset(_urb, 0, sizeof(*_urb));
144 usb_init_urb(&_urb->urb);
149 static struct _urb *_urb_dequeue(struct _urb_queue *q)
151 struct _urb *_urb = NULL;
153 spin_lock_irqsave(&q->lock, flags);
155 struct list_head *head = &q->head;
156 struct list_head *next = head->next;
158 _urb = list_entry(next, struct _urb, list);
159 list_del(next); _urb->queue = NULL;
162 spin_unlock_irqrestore(&q->lock, flags);
166 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
167 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
169 #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
170 #define __pending_q(husb, type) (&husb->pending_q[type-1])
171 #define __completed_q(husb, type) (&husb->completed_q[type-1])
172 #define __transmit_q(husb, type) (&husb->transmit_q[type-1])
173 #define __reassembly(husb, type) (husb->reassembly[type-1])
175 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
177 return _urb_dequeue(__completed_q(husb, type));
180 #ifdef CONFIG_BT_HCIUSB_SCO
181 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
185 BT_DBG("len %d mtu %d", len, mtu);
187 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
188 urb->iso_frame_desc[i].offset = offset;
189 urb->iso_frame_desc[i].length = mtu;
190 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
192 if (len && i < HCI_MAX_ISOC_FRAMES) {
193 urb->iso_frame_desc[i].offset = offset;
194 urb->iso_frame_desc[i].length = len;
195 BT_DBG("desc %d offset %d len %d", i, offset, len);
198 urb->number_of_packets = i;
202 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
206 int err, pipe, interval, size;
209 BT_DBG("%s", husb->hdev->name);
211 size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
213 buf = kmalloc(size, GFP_ATOMIC);
217 _urb = _urb_alloc(0, GFP_ATOMIC);
222 _urb->type = HCI_EVENT_PKT;
223 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
226 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
227 interval = husb->intr_in_ep->desc.bInterval;
228 usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
230 err = usb_submit_urb(urb, GFP_ATOMIC);
232 BT_ERR("%s intr rx submit failed urb %p err %d",
233 husb->hdev->name, urb, err);
241 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
245 int err, pipe, size = HCI_MAX_FRAME_SIZE;
248 buf = kmalloc(size, GFP_ATOMIC);
252 _urb = _urb_alloc(0, GFP_ATOMIC);
257 _urb->type = HCI_ACLDATA_PKT;
258 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
261 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
262 usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
263 urb->transfer_flags = 0;
265 BT_DBG("%s urb %p", husb->hdev->name, urb);
267 err = usb_submit_urb(urb, GFP_ATOMIC);
269 BT_ERR("%s bulk rx submit failed urb %p err %d",
270 husb->hdev->name, urb, err);
278 #ifdef CONFIG_BT_HCIUSB_SCO
279 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
286 mtu = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
287 size = mtu * HCI_MAX_ISOC_FRAMES;
289 buf = kmalloc(size, GFP_ATOMIC);
293 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
298 _urb->type = HCI_SCODATA_PKT;
299 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
304 urb->dev = husb->udev;
305 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
306 urb->complete = hci_usb_rx_complete;
308 urb->interval = husb->isoc_in_ep->desc.bInterval;
310 urb->transfer_buffer_length = size;
311 urb->transfer_buffer = buf;
312 urb->transfer_flags = URB_ISO_ASAP;
314 __fill_isoc_desc(urb, size, mtu);
316 BT_DBG("%s urb %p", husb->hdev->name, urb);
318 err = usb_submit_urb(urb, GFP_ATOMIC);
320 BT_ERR("%s isoc rx submit failed urb %p err %d",
321 husb->hdev->name, urb, err);
330 /* Initialize device */
331 static int hci_usb_open(struct hci_dev *hdev)
333 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
337 BT_DBG("%s", hdev->name);
339 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
342 write_lock_irqsave(&husb->completion_lock, flags);
344 err = hci_usb_intr_rx_submit(husb);
346 for (i = 0; i < HCI_MAX_BULK_RX; i++)
347 hci_usb_bulk_rx_submit(husb);
349 #ifdef CONFIG_BT_HCIUSB_SCO
350 if (husb->isoc_iface)
351 for (i = 0; i < HCI_MAX_ISOC_RX; i++)
352 hci_usb_isoc_rx_submit(husb);
355 clear_bit(HCI_RUNNING, &hdev->flags);
358 write_unlock_irqrestore(&husb->completion_lock, flags);
363 static int hci_usb_flush(struct hci_dev *hdev)
365 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
368 BT_DBG("%s", hdev->name);
370 for (i = 0; i < 4; i++)
371 skb_queue_purge(&husb->transmit_q[i]);
375 static void hci_usb_unlink_urbs(struct hci_usb *husb)
379 BT_DBG("%s", husb->hdev->name);
381 for (i = 0; i < 4; i++) {
385 /* Kill pending requests */
386 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
388 BT_DBG("%s unlinking _urb %p type %d urb %p",
389 husb->hdev->name, _urb, _urb->type, urb);
391 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
394 /* Release completed requests */
395 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
397 BT_DBG("%s freeing _urb %p type %d urb %p",
398 husb->hdev->name, _urb, _urb->type, urb);
399 kfree(urb->setup_packet);
400 kfree(urb->transfer_buffer);
404 /* Release reassembly buffers */
405 if (husb->reassembly[i]) {
406 kfree_skb(husb->reassembly[i]);
407 husb->reassembly[i] = NULL;
413 static int hci_usb_close(struct hci_dev *hdev)
415 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
418 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
421 BT_DBG("%s", hdev->name);
423 /* Synchronize with completion handlers */
424 write_lock_irqsave(&husb->completion_lock, flags);
425 write_unlock_irqrestore(&husb->completion_lock, flags);
427 hci_usb_unlink_urbs(husb);
432 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
434 struct urb *urb = &_urb->urb;
437 BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
439 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
440 err = usb_submit_urb(urb, GFP_ATOMIC);
442 BT_ERR("%s tx submit failed urb %p type %d err %d",
443 husb->hdev->name, urb, _urb->type, err);
445 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
447 atomic_inc(__pending_tx(husb, _urb->type));
452 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
454 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
455 struct usb_ctrlrequest *dr;
459 _urb = _urb_alloc(0, GFP_ATOMIC);
462 _urb->type = bt_cb(skb)->pkt_type;
464 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
470 dr = (void *) _urb->urb.setup_packet;
472 dr->bRequestType = husb->ctrl_req;
476 dr->wLength = __cpu_to_le16(skb->len);
479 usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
480 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
482 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
485 return __tx_submit(husb, _urb);
488 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
490 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
495 _urb = _urb_alloc(0, GFP_ATOMIC);
498 _urb->type = bt_cb(skb)->pkt_type;
502 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
503 usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
504 hci_usb_tx_complete, husb);
505 urb->transfer_flags = URB_ZERO_PACKET;
507 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
510 return __tx_submit(husb, _urb);
513 #ifdef CONFIG_BT_HCIUSB_SCO
514 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
516 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
520 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
523 _urb->type = bt_cb(skb)->pkt_type;
526 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
531 urb->dev = husb->udev;
532 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
533 urb->complete = hci_usb_tx_complete;
534 urb->transfer_flags = URB_ISO_ASAP;
536 urb->interval = husb->isoc_out_ep->desc.bInterval;
538 urb->transfer_buffer = skb->data;
539 urb->transfer_buffer_length = skb->len;
541 __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
544 return __tx_submit(husb, _urb);
548 static void hci_usb_tx_process(struct hci_usb *husb)
550 struct sk_buff_head *q;
553 BT_DBG("%s", husb->hdev->name);
556 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
558 /* Process command queue */
559 q = __transmit_q(husb, HCI_COMMAND_PKT);
560 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
561 (skb = skb_dequeue(q))) {
562 if (hci_usb_send_ctrl(husb, skb) < 0)
563 skb_queue_head(q, skb);
566 #ifdef CONFIG_BT_HCIUSB_SCO
567 /* Process SCO queue */
568 q = __transmit_q(husb, HCI_SCODATA_PKT);
569 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
570 (skb = skb_dequeue(q))) {
571 if (hci_usb_send_isoc(husb, skb) < 0)
572 skb_queue_head(q, skb);
576 /* Process ACL queue */
577 q = __transmit_q(husb, HCI_ACLDATA_PKT);
578 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
579 (skb = skb_dequeue(q))) {
580 if (hci_usb_send_bulk(husb, skb) < 0) {
581 skb_queue_head(q, skb);
585 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
588 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
590 /* Serialize TX queue processing to avoid data reordering */
591 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
592 hci_usb_tx_process(husb);
593 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
595 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
598 /* Send frames from HCI layer */
599 static int hci_usb_send_frame(struct sk_buff *skb)
601 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
602 struct hci_usb *husb;
605 BT_ERR("frame for uknown device (hdev=NULL)");
609 if (!test_bit(HCI_RUNNING, &hdev->flags))
612 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
614 husb = (struct hci_usb *) hdev->driver_data;
616 switch (bt_cb(skb)->pkt_type) {
617 case HCI_COMMAND_PKT:
621 case HCI_ACLDATA_PKT:
625 #ifdef CONFIG_BT_HCIUSB_SCO
626 case HCI_SCODATA_PKT:
636 read_lock(&husb->completion_lock);
638 skb_queue_tail(__transmit_q(husb, bt_cb(skb)->pkt_type), skb);
639 hci_usb_tx_wakeup(husb);
641 read_unlock(&husb->completion_lock);
645 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
647 BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
649 husb->hdev->stat.byte_rx += count;
652 struct sk_buff *skb = __reassembly(husb, type);
653 struct { int expect; } *scb;
657 /* Start of the frame */
661 if (count >= HCI_EVENT_HDR_SIZE) {
662 struct hci_event_hdr *h = data;
663 len = HCI_EVENT_HDR_SIZE + h->plen;
668 case HCI_ACLDATA_PKT:
669 if (count >= HCI_ACL_HDR_SIZE) {
670 struct hci_acl_hdr *h = data;
671 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
675 #ifdef CONFIG_BT_HCIUSB_SCO
676 case HCI_SCODATA_PKT:
677 if (count >= HCI_SCO_HDR_SIZE) {
678 struct hci_sco_hdr *h = data;
679 len = HCI_SCO_HDR_SIZE + h->dlen;
685 BT_DBG("new packet len %d", len);
687 skb = bt_skb_alloc(len, GFP_ATOMIC);
689 BT_ERR("%s no memory for the packet", husb->hdev->name);
692 skb->dev = (void *) husb->hdev;
693 bt_cb(skb)->pkt_type = type;
695 __reassembly(husb, type) = skb;
697 scb = (void *) skb->cb;
701 scb = (void *) skb->cb;
705 len = min(len, count);
707 memcpy(skb_put(skb, len), data, len);
712 __reassembly(husb, type) = NULL;
713 bt_cb(skb)->pkt_type = type;
717 count -= len; data += len;
722 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
724 struct _urb *_urb = container_of(urb, struct _urb, urb);
725 struct hci_usb *husb = (void *) urb->context;
726 struct hci_dev *hdev = husb->hdev;
727 int err, count = urb->actual_length;
729 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
730 _urb->type, urb->status, count, urb->transfer_flags);
732 read_lock(&husb->completion_lock);
734 if (!test_bit(HCI_RUNNING, &hdev->flags))
737 if (urb->status || !count)
740 if (_urb->type == HCI_SCODATA_PKT) {
741 #ifdef CONFIG_BT_HCIUSB_SCO
743 for (i=0; i < urb->number_of_packets; i++) {
744 BT_DBG("desc %d status %d offset %d len %d", i,
745 urb->iso_frame_desc[i].status,
746 urb->iso_frame_desc[i].offset,
747 urb->iso_frame_desc[i].actual_length);
749 if (!urb->iso_frame_desc[i].status)
750 __recv_frame(husb, _urb->type,
751 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
752 urb->iso_frame_desc[i].actual_length);
758 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
760 BT_ERR("%s corrupted packet: type %d count %d",
761 husb->hdev->name, _urb->type, count);
767 urb->dev = husb->udev;
768 err = usb_submit_urb(urb, GFP_ATOMIC);
769 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
773 read_unlock(&husb->completion_lock);
776 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
778 struct _urb *_urb = container_of(urb, struct _urb, urb);
779 struct hci_usb *husb = (void *) urb->context;
780 struct hci_dev *hdev = husb->hdev;
782 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
783 urb->status, urb->transfer_flags);
785 atomic_dec(__pending_tx(husb, _urb->type));
787 urb->transfer_buffer = NULL;
788 kfree_skb((struct sk_buff *) _urb->priv);
790 if (!test_bit(HCI_RUNNING, &hdev->flags))
794 hdev->stat.byte_tx += urb->transfer_buffer_length;
798 read_lock(&husb->completion_lock);
801 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
803 hci_usb_tx_wakeup(husb);
805 read_unlock(&husb->completion_lock);
808 static void hci_usb_destruct(struct hci_dev *hdev)
810 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
812 BT_DBG("%s", hdev->name);
817 static void hci_usb_notify(struct hci_dev *hdev, unsigned int evt)
819 BT_DBG("%s evt %d", hdev->name, evt);
822 static int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
824 struct usb_device *udev = interface_to_usbdev(intf);
825 struct usb_host_endpoint *bulk_out_ep = NULL;
826 struct usb_host_endpoint *bulk_in_ep = NULL;
827 struct usb_host_endpoint *intr_in_ep = NULL;
828 struct usb_host_endpoint *ep;
829 struct usb_host_interface *uif;
830 struct usb_interface *isoc_iface;
831 struct hci_usb *husb;
832 struct hci_dev *hdev;
833 int i, e, size, isoc_ifnum, isoc_alts;
835 BT_DBG("udev %p intf %p", udev, intf);
837 if (!id->driver_info) {
838 const struct usb_device_id *match;
839 match = usb_match_id(intf, blacklist_ids);
844 if (ignore || id->driver_info & HCI_IGNORE)
847 if (ignore_dga && id->driver_info & HCI_DIGIANSWER)
850 if (ignore_csr && id->driver_info & HCI_CSR)
853 if (ignore_sniffer && id->driver_info & HCI_SNIFFER)
856 if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
859 /* Find endpoints that we need */
860 uif = intf->cur_altsetting;
861 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
862 ep = &uif->endpoint[e];
864 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
865 case USB_ENDPOINT_XFER_INT:
866 if (ep->desc.bEndpointAddress & USB_DIR_IN)
870 case USB_ENDPOINT_XFER_BULK:
871 if (ep->desc.bEndpointAddress & USB_DIR_IN)
879 if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
880 BT_DBG("Bulk endpoints not found");
884 if (!(husb = kzalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
885 BT_ERR("Can't allocate: control structure");
890 husb->bulk_out_ep = bulk_out_ep;
891 husb->bulk_in_ep = bulk_in_ep;
892 husb->intr_in_ep = intr_in_ep;
894 if (id->driver_info & HCI_DIGIANSWER)
895 husb->ctrl_req = USB_TYPE_VENDOR;
897 husb->ctrl_req = USB_TYPE_CLASS;
899 /* Find isochronous endpoints that we can use */
905 #ifdef CONFIG_BT_HCIUSB_SCO
906 if (isoc && !(id->driver_info & (HCI_BROKEN_ISOC | HCI_SNIFFER)))
907 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
911 struct usb_host_endpoint *isoc_out_ep = NULL;
912 struct usb_host_endpoint *isoc_in_ep = NULL;
914 for (a = 0; a < isoc_iface->num_altsetting; a++) {
915 uif = &isoc_iface->altsetting[a];
916 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
917 ep = &uif->endpoint[e];
919 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
920 case USB_ENDPOINT_XFER_ISOC:
921 if (le16_to_cpu(ep->desc.wMaxPacketSize) < size ||
922 uif->desc.bAlternateSetting != isoc)
924 size = le16_to_cpu(ep->desc.wMaxPacketSize);
926 isoc_alts = uif->desc.bAlternateSetting;
928 if (ep->desc.bEndpointAddress & USB_DIR_IN)
937 if (!isoc_in_ep || !isoc_out_ep)
938 BT_DBG("Isoc endpoints not found");
940 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
941 if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
942 BT_ERR("Can't claim isoc interface");
943 else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
944 BT_ERR("Can't set isoc interface settings");
945 husb->isoc_iface = isoc_iface;
946 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
947 husb->isoc_iface = NULL;
949 husb->isoc_iface = isoc_iface;
950 husb->isoc_in_ep = isoc_in_ep;
951 husb->isoc_out_ep = isoc_out_ep;
957 rwlock_init(&husb->completion_lock);
959 for (i = 0; i < 4; i++) {
960 skb_queue_head_init(&husb->transmit_q[i]);
961 _urb_queue_init(&husb->pending_q[i]);
962 _urb_queue_init(&husb->completed_q[i]);
965 /* Initialize and register HCI device */
966 hdev = hci_alloc_dev();
968 BT_ERR("Can't allocate HCI device");
974 hdev->type = HCI_USB;
975 hdev->driver_data = husb;
976 SET_HCIDEV_DEV(hdev, &intf->dev);
978 hdev->open = hci_usb_open;
979 hdev->close = hci_usb_close;
980 hdev->flush = hci_usb_flush;
981 hdev->send = hci_usb_send_frame;
982 hdev->destruct = hci_usb_destruct;
983 hdev->notify = hci_usb_notify;
985 hdev->owner = THIS_MODULE;
987 if (reset || id->driver_info & HCI_RESET)
988 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
990 if (id->driver_info & HCI_SNIFFER) {
991 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
992 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
995 if (id->driver_info & HCI_BCM92035) {
996 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
999 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1001 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1002 skb_queue_tail(&hdev->driver_init, skb);
1006 if (hci_register_dev(hdev) < 0) {
1007 BT_ERR("Can't register HCI device");
1012 usb_set_intfdata(intf, husb);
1016 if (husb->isoc_iface)
1017 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1024 static void hci_usb_disconnect(struct usb_interface *intf)
1026 struct hci_usb *husb = usb_get_intfdata(intf);
1027 struct hci_dev *hdev;
1029 if (!husb || intf == husb->isoc_iface)
1032 usb_set_intfdata(intf, NULL);
1035 BT_DBG("%s", hdev->name);
1037 hci_usb_close(hdev);
1039 if (husb->isoc_iface)
1040 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1042 if (hci_unregister_dev(hdev) < 0)
1043 BT_ERR("Can't unregister HCI device %s", hdev->name);
1048 static int hci_usb_suspend(struct usb_interface *intf, pm_message_t message)
1050 struct hci_usb *husb = usb_get_intfdata(intf);
1051 struct list_head killed;
1052 unsigned long flags;
1055 if (!husb || intf == husb->isoc_iface)
1058 hci_suspend_dev(husb->hdev);
1060 INIT_LIST_HEAD(&killed);
1062 for (i = 0; i < 4; i++) {
1063 struct _urb_queue *q = &husb->pending_q[i];
1064 struct _urb *_urb, *_tmp;
1066 while ((_urb = _urb_dequeue(q))) {
1067 /* reset queue since _urb_dequeue sets it to NULL */
1069 usb_kill_urb(&_urb->urb);
1070 list_add(&_urb->list, &killed);
1073 spin_lock_irqsave(&q->lock, flags);
1075 list_for_each_entry_safe(_urb, _tmp, &killed, list) {
1076 list_move_tail(&_urb->list, &q->head);
1079 spin_unlock_irqrestore(&q->lock, flags);
1085 static int hci_usb_resume(struct usb_interface *intf)
1087 struct hci_usb *husb = usb_get_intfdata(intf);
1088 unsigned long flags;
1091 if (!husb || intf == husb->isoc_iface)
1094 for (i = 0; i < 4; i++) {
1095 struct _urb_queue *q = &husb->pending_q[i];
1098 spin_lock_irqsave(&q->lock, flags);
1100 list_for_each_entry(_urb, &q->head, list) {
1101 err = usb_submit_urb(&_urb->urb, GFP_ATOMIC);
1106 spin_unlock_irqrestore(&q->lock, flags);
1112 hci_resume_dev(husb->hdev);
1117 static struct usb_driver hci_usb_driver = {
1119 .probe = hci_usb_probe,
1120 .disconnect = hci_usb_disconnect,
1121 .suspend = hci_usb_suspend,
1122 .resume = hci_usb_resume,
1123 .id_table = bluetooth_ids,
1126 static int __init hci_usb_init(void)
1130 BT_INFO("HCI USB driver ver %s", VERSION);
1132 if ((err = usb_register(&hci_usb_driver)) < 0)
1133 BT_ERR("Failed to register HCI USB driver");
1138 static void __exit hci_usb_exit(void)
1140 usb_deregister(&hci_usb_driver);
1143 module_init(hci_usb_init);
1144 module_exit(hci_usb_exit);
1146 module_param(ignore, bool, 0644);
1147 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
1149 module_param(ignore_dga, bool, 0644);
1150 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1152 module_param(ignore_csr, bool, 0644);
1153 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1155 module_param(ignore_sniffer, bool, 0644);
1156 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1158 module_param(reset, bool, 0644);
1159 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1161 #ifdef CONFIG_BT_HCIUSB_SCO
1162 module_param(isoc, int, 0644);
1163 MODULE_PARM_DESC(isoc, "Set isochronous transfers for SCO over HCI support");
1166 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1167 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1168 MODULE_VERSION(VERSION);
1169 MODULE_LICENSE("GPL");