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/config.h>
35 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/init.h>
39 #include <linux/sched.h>
40 #include <linux/unistd.h>
41 #include <linux/types.h>
42 #include <linux/interrupt.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
63 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
64 #undef URB_ZERO_PACKET
65 #define URB_ZERO_PACKET 0
70 static struct usb_driver hci_usb_driver;
72 static struct usb_device_id bluetooth_ids[] = {
73 /* Generic Bluetooth USB device */
74 { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
76 /* AVM BlueFRITZ! USB v2.0 */
77 { USB_DEVICE(0x057c, 0x3800) },
79 /* Bluetooth Ultraport Module from IBM */
80 { USB_DEVICE(0x04bf, 0x030a) },
82 /* ALPS Modules with non-standard id */
83 { USB_DEVICE(0x044e, 0x3001) },
84 { USB_DEVICE(0x044e, 0x3002) },
86 /* Ericsson with non-standard id */
87 { USB_DEVICE(0x0bdb, 0x1002) },
89 { } /* Terminating entry */
92 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
94 static struct usb_device_id blacklist_ids[] = {
95 /* Broadcom BCM2033 without firmware */
96 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
98 /* Broadcom BCM2035 */
99 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET },
101 /* ISSC Bluetooth Adapter v3.1 */
102 { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
104 /* Digianswer device */
105 { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
107 /* RTX Telecom based adapter with buggy SCO support */
108 { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
110 { } /* Terminating entry */
113 struct _urb *_urb_alloc(int isoc, int gfp)
115 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
116 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
118 memset(_urb, 0, sizeof(*_urb));
119 usb_init_urb(&_urb->urb);
124 struct _urb *_urb_dequeue(struct _urb_queue *q)
126 struct _urb *_urb = NULL;
128 spin_lock_irqsave(&q->lock, flags);
130 struct list_head *head = &q->head;
131 struct list_head *next = head->next;
133 _urb = list_entry(next, struct _urb, list);
134 list_del(next); _urb->queue = NULL;
137 spin_unlock_irqrestore(&q->lock, flags);
141 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
142 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
144 #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
145 #define __pending_q(husb, type) (&husb->pending_q[type-1])
146 #define __completed_q(husb, type) (&husb->completed_q[type-1])
147 #define __transmit_q(husb, type) (&husb->transmit_q[type-1])
148 #define __reassembly(husb, type) (husb->reassembly[type-1])
150 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
152 return _urb_dequeue(__completed_q(husb, type));
155 #ifdef CONFIG_BT_HCIUSB_SCO
156 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
160 BT_DBG("len %d mtu %d", len, mtu);
162 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
163 urb->iso_frame_desc[i].offset = offset;
164 urb->iso_frame_desc[i].length = mtu;
165 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
167 if (len && i < HCI_MAX_ISOC_FRAMES) {
168 urb->iso_frame_desc[i].offset = offset;
169 urb->iso_frame_desc[i].length = len;
170 BT_DBG("desc %d offset %d len %d", i, offset, len);
173 urb->number_of_packets = i;
177 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
181 int err, pipe, interval, size;
184 BT_DBG("%s", husb->hdev->name);
186 size = husb->intr_in_ep->desc.wMaxPacketSize;
188 buf = kmalloc(size, GFP_ATOMIC);
192 _urb = _urb_alloc(0, GFP_ATOMIC);
197 _urb->type = HCI_EVENT_PKT;
198 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
201 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
202 interval = husb->intr_in_ep->desc.bInterval;
203 usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
205 err = usb_submit_urb(urb, GFP_ATOMIC);
207 BT_ERR("%s intr rx submit failed urb %p err %d",
208 husb->hdev->name, urb, err);
216 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
220 int err, pipe, size = HCI_MAX_FRAME_SIZE;
223 buf = kmalloc(size, GFP_ATOMIC);
227 _urb = _urb_alloc(0, GFP_ATOMIC);
232 _urb->type = HCI_ACLDATA_PKT;
233 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
236 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
237 usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
238 urb->transfer_flags = 0;
240 BT_DBG("%s urb %p", husb->hdev->name, urb);
242 err = usb_submit_urb(urb, GFP_ATOMIC);
244 BT_ERR("%s bulk rx submit failed urb %p err %d",
245 husb->hdev->name, urb, err);
253 #ifdef CONFIG_BT_HCIUSB_SCO
254 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
261 mtu = husb->isoc_in_ep->desc.wMaxPacketSize;
262 size = mtu * HCI_MAX_ISOC_FRAMES;
264 buf = kmalloc(size, GFP_ATOMIC);
268 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
273 _urb->type = HCI_SCODATA_PKT;
274 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
279 urb->dev = husb->udev;
280 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
281 urb->complete = hci_usb_rx_complete;
283 urb->interval = husb->isoc_in_ep->desc.bInterval;
285 urb->transfer_buffer_length = size;
286 urb->transfer_buffer = buf;
287 urb->transfer_flags = URB_ISO_ASAP;
289 __fill_isoc_desc(urb, size, mtu);
291 BT_DBG("%s urb %p", husb->hdev->name, urb);
293 err = usb_submit_urb(urb, GFP_ATOMIC);
295 BT_ERR("%s isoc rx submit failed urb %p err %d",
296 husb->hdev->name, urb, err);
305 /* Initialize device */
306 static int hci_usb_open(struct hci_dev *hdev)
308 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
312 BT_DBG("%s", hdev->name);
314 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
317 write_lock_irqsave(&husb->completion_lock, flags);
319 err = hci_usb_intr_rx_submit(husb);
321 for (i = 0; i < HCI_MAX_BULK_RX; i++)
322 hci_usb_bulk_rx_submit(husb);
324 #ifdef CONFIG_BT_HCIUSB_SCO
325 if (husb->isoc_iface)
326 for (i = 0; i < HCI_MAX_ISOC_RX; i++)
327 hci_usb_isoc_rx_submit(husb);
330 clear_bit(HCI_RUNNING, &hdev->flags);
333 write_unlock_irqrestore(&husb->completion_lock, flags);
338 static int hci_usb_flush(struct hci_dev *hdev)
340 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
343 BT_DBG("%s", hdev->name);
345 for (i = 0; i < 4; i++)
346 skb_queue_purge(&husb->transmit_q[i]);
350 static void hci_usb_unlink_urbs(struct hci_usb *husb)
354 BT_DBG("%s", husb->hdev->name);
356 for (i = 0; i < 4; i++) {
360 /* Kill pending requests */
361 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
363 BT_DBG("%s unlinking _urb %p type %d urb %p",
364 husb->hdev->name, _urb, _urb->type, urb);
366 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
369 /* Release completed requests */
370 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
372 BT_DBG("%s freeing _urb %p type %d urb %p",
373 husb->hdev->name, _urb, _urb->type, urb);
374 if (urb->setup_packet)
375 kfree(urb->setup_packet);
376 if (urb->transfer_buffer)
377 kfree(urb->transfer_buffer);
381 /* Release reassembly buffers */
382 if (husb->reassembly[i]) {
383 kfree_skb(husb->reassembly[i]);
384 husb->reassembly[i] = NULL;
390 static int hci_usb_close(struct hci_dev *hdev)
392 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
395 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
398 BT_DBG("%s", hdev->name);
400 /* Synchronize with completion handlers */
401 write_lock_irqsave(&husb->completion_lock, flags);
402 write_unlock_irqrestore(&husb->completion_lock, flags);
404 hci_usb_unlink_urbs(husb);
409 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
411 struct urb *urb = &_urb->urb;
414 BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
416 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
417 err = usb_submit_urb(urb, GFP_ATOMIC);
419 BT_ERR("%s tx submit failed urb %p type %d err %d",
420 husb->hdev->name, urb, _urb->type, err);
422 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
424 atomic_inc(__pending_tx(husb, _urb->type));
429 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
431 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
432 struct usb_ctrlrequest *dr;
436 _urb = _urb_alloc(0, GFP_ATOMIC);
439 _urb->type = skb->pkt_type;
441 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
447 dr = (void *) _urb->urb.setup_packet;
449 dr->bRequestType = husb->ctrl_req;
453 dr->wLength = __cpu_to_le16(skb->len);
456 usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
457 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
459 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
462 return __tx_submit(husb, _urb);
465 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
467 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
472 _urb = _urb_alloc(0, GFP_ATOMIC);
475 _urb->type = skb->pkt_type;
479 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
480 usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
481 hci_usb_tx_complete, husb);
482 urb->transfer_flags = URB_ZERO_PACKET;
484 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
487 return __tx_submit(husb, _urb);
490 #ifdef CONFIG_BT_HCIUSB_SCO
491 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
493 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
497 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
500 _urb->type = skb->pkt_type;
503 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
508 urb->dev = husb->udev;
509 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
510 urb->complete = hci_usb_tx_complete;
511 urb->transfer_flags = URB_ISO_ASAP;
513 urb->interval = husb->isoc_out_ep->desc.bInterval;
515 urb->transfer_buffer = skb->data;
516 urb->transfer_buffer_length = skb->len;
518 __fill_isoc_desc(urb, skb->len, husb->isoc_out_ep->desc.wMaxPacketSize);
521 return __tx_submit(husb, _urb);
525 static void hci_usb_tx_process(struct hci_usb *husb)
527 struct sk_buff_head *q;
530 BT_DBG("%s", husb->hdev->name);
533 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
535 /* Process command queue */
536 q = __transmit_q(husb, HCI_COMMAND_PKT);
537 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
538 (skb = skb_dequeue(q))) {
539 if (hci_usb_send_ctrl(husb, skb) < 0)
540 skb_queue_head(q, skb);
543 #ifdef CONFIG_BT_HCIUSB_SCO
544 /* Process SCO queue */
545 q = __transmit_q(husb, HCI_SCODATA_PKT);
546 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
547 (skb = skb_dequeue(q))) {
548 if (hci_usb_send_isoc(husb, skb) < 0)
549 skb_queue_head(q, skb);
553 /* Process ACL queue */
554 q = __transmit_q(husb, HCI_ACLDATA_PKT);
555 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
556 (skb = skb_dequeue(q))) {
557 if (hci_usb_send_bulk(husb, skb) < 0) {
558 skb_queue_head(q, skb);
562 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
565 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
567 /* Serialize TX queue processing to avoid data reordering */
568 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
569 hci_usb_tx_process(husb);
570 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
572 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
575 /* Send frames from HCI layer */
576 static int hci_usb_send_frame(struct sk_buff *skb)
578 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
579 struct hci_usb *husb;
582 BT_ERR("frame for uknown device (hdev=NULL)");
586 if (!test_bit(HCI_RUNNING, &hdev->flags))
589 BT_DBG("%s type %d len %d", hdev->name, skb->pkt_type, skb->len);
591 husb = (struct hci_usb *) hdev->driver_data;
593 switch (skb->pkt_type) {
594 case HCI_COMMAND_PKT:
598 case HCI_ACLDATA_PKT:
602 #ifdef CONFIG_BT_HCIUSB_SCO
603 case HCI_SCODATA_PKT:
613 read_lock(&husb->completion_lock);
615 skb_queue_tail(__transmit_q(husb, skb->pkt_type), skb);
616 hci_usb_tx_wakeup(husb);
618 read_unlock(&husb->completion_lock);
622 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
624 BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
626 husb->hdev->stat.byte_rx += count;
629 struct sk_buff *skb = __reassembly(husb, type);
630 struct { int expect; } *scb;
634 /* Start of the frame */
638 if (count >= HCI_EVENT_HDR_SIZE) {
639 struct hci_event_hdr *h = data;
640 len = HCI_EVENT_HDR_SIZE + h->plen;
645 case HCI_ACLDATA_PKT:
646 if (count >= HCI_ACL_HDR_SIZE) {
647 struct hci_acl_hdr *h = data;
648 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
652 #ifdef CONFIG_BT_HCIUSB_SCO
653 case HCI_SCODATA_PKT:
654 if (count >= HCI_SCO_HDR_SIZE) {
655 struct hci_sco_hdr *h = data;
656 len = HCI_SCO_HDR_SIZE + h->dlen;
662 BT_DBG("new packet len %d", len);
664 skb = bt_skb_alloc(len, GFP_ATOMIC);
666 BT_ERR("%s no memory for the packet", husb->hdev->name);
669 skb->dev = (void *) husb->hdev;
670 skb->pkt_type = type;
672 __reassembly(husb, type) = skb;
674 scb = (void *) skb->cb;
678 scb = (void *) skb->cb;
682 len = min(len, count);
684 memcpy(skb_put(skb, len), data, len);
689 __reassembly(husb, type) = NULL;
693 count -= len; data += len;
698 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
700 struct _urb *_urb = container_of(urb, struct _urb, urb);
701 struct hci_usb *husb = (void *) urb->context;
702 struct hci_dev *hdev = husb->hdev;
703 int err, count = urb->actual_length;
705 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
706 _urb->type, urb->status, count, urb->transfer_flags);
708 read_lock(&husb->completion_lock);
710 if (!test_bit(HCI_RUNNING, &hdev->flags))
713 if (urb->status || !count)
716 if (_urb->type == HCI_SCODATA_PKT) {
717 #ifdef CONFIG_BT_HCIUSB_SCO
719 for (i=0; i < urb->number_of_packets; i++) {
720 BT_DBG("desc %d status %d offset %d len %d", i,
721 urb->iso_frame_desc[i].status,
722 urb->iso_frame_desc[i].offset,
723 urb->iso_frame_desc[i].actual_length);
725 if (!urb->iso_frame_desc[i].status)
726 __recv_frame(husb, _urb->type,
727 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
728 urb->iso_frame_desc[i].actual_length);
734 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
736 BT_ERR("%s corrupted packet: type %d count %d",
737 husb->hdev->name, _urb->type, count);
743 urb->dev = husb->udev;
744 err = usb_submit_urb(urb, GFP_ATOMIC);
745 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
749 read_unlock(&husb->completion_lock);
752 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
754 struct _urb *_urb = container_of(urb, struct _urb, urb);
755 struct hci_usb *husb = (void *) urb->context;
756 struct hci_dev *hdev = husb->hdev;
758 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
759 urb->status, urb->transfer_flags);
761 atomic_dec(__pending_tx(husb, _urb->type));
763 urb->transfer_buffer = NULL;
764 kfree_skb((struct sk_buff *) _urb->priv);
766 if (!test_bit(HCI_RUNNING, &hdev->flags))
770 hdev->stat.byte_tx += urb->transfer_buffer_length;
774 read_lock(&husb->completion_lock);
777 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
779 hci_usb_tx_wakeup(husb);
781 read_unlock(&husb->completion_lock);
784 static void hci_usb_destruct(struct hci_dev *hdev)
786 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
788 BT_DBG("%s", hdev->name);
793 int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
795 struct usb_device *udev = interface_to_usbdev(intf);
796 struct usb_host_endpoint *bulk_out_ep = NULL;
797 struct usb_host_endpoint *bulk_in_ep = NULL;
798 struct usb_host_endpoint *intr_in_ep = NULL;
799 struct usb_host_endpoint *ep;
800 struct usb_host_interface *uif;
801 struct usb_interface *isoc_iface;
802 struct hci_usb *husb;
803 struct hci_dev *hdev;
804 int i, e, size, isoc_ifnum, isoc_alts;
806 BT_DBG("udev %p intf %p", udev, intf);
808 if (!id->driver_info) {
809 const struct usb_device_id *match;
810 match = usb_match_id(intf, blacklist_ids);
815 if (id->driver_info & HCI_IGNORE)
818 if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
821 /* Find endpoints that we need */
822 uif = intf->cur_altsetting;
823 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
824 ep = &uif->endpoint[e];
826 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
827 case USB_ENDPOINT_XFER_INT:
828 if (ep->desc.bEndpointAddress & USB_DIR_IN)
832 case USB_ENDPOINT_XFER_BULK:
833 if (ep->desc.bEndpointAddress & USB_DIR_IN)
841 if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
842 BT_DBG("Bulk endpoints not found");
846 if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
847 BT_ERR("Can't allocate: control structure");
851 memset(husb, 0, sizeof(struct hci_usb));
854 husb->bulk_out_ep = bulk_out_ep;
855 husb->bulk_in_ep = bulk_in_ep;
856 husb->intr_in_ep = intr_in_ep;
858 if (id->driver_info & HCI_DIGIANSWER)
859 husb->ctrl_req = HCI_DIGI_REQ;
861 husb->ctrl_req = HCI_CTRL_REQ;
863 /* Find isochronous endpoints that we can use */
869 #ifdef CONFIG_BT_HCIUSB_SCO
870 if (!(id->driver_info & HCI_BROKEN_ISOC))
871 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
875 struct usb_host_endpoint *isoc_out_ep = NULL;
876 struct usb_host_endpoint *isoc_in_ep = NULL;
878 for (a = 0; a < isoc_iface->num_altsetting; a++) {
879 uif = &isoc_iface->altsetting[a];
880 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
881 ep = &uif->endpoint[e];
883 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
884 case USB_ENDPOINT_XFER_ISOC:
885 if (ep->desc.wMaxPacketSize < size ||
886 uif->desc.bAlternateSetting > 2)
888 size = ep->desc.wMaxPacketSize;
890 isoc_alts = uif->desc.bAlternateSetting;
892 if (ep->desc.bEndpointAddress & USB_DIR_IN)
901 if (!isoc_in_ep || !isoc_out_ep)
902 BT_DBG("Isoc endpoints not found");
904 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
905 if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
906 BT_ERR("Can't claim isoc interface");
907 else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
908 BT_ERR("Can't set isoc interface settings");
909 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
911 husb->isoc_iface = isoc_iface;
912 husb->isoc_in_ep = isoc_in_ep;
913 husb->isoc_out_ep = isoc_out_ep;
919 husb->completion_lock = RW_LOCK_UNLOCKED;
921 for (i = 0; i < 4; i++) {
922 skb_queue_head_init(&husb->transmit_q[i]);
923 _urb_queue_init(&husb->pending_q[i]);
924 _urb_queue_init(&husb->completed_q[i]);
927 /* Initialize and register HCI device */
928 hdev = hci_alloc_dev();
930 BT_ERR("Can't allocate HCI device");
936 hdev->type = HCI_USB;
937 hdev->driver_data = husb;
938 SET_HCIDEV_DEV(hdev, &intf->dev);
940 hdev->open = hci_usb_open;
941 hdev->close = hci_usb_close;
942 hdev->flush = hci_usb_flush;
943 hdev->send = hci_usb_send_frame;
944 hdev->destruct = hci_usb_destruct;
946 hdev->owner = THIS_MODULE;
948 if (id->driver_info & HCI_RESET)
949 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
951 if (hci_register_dev(hdev) < 0) {
952 BT_ERR("Can't register HCI device");
957 usb_set_intfdata(intf, husb);
961 if (husb->isoc_iface)
962 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
969 static void hci_usb_disconnect(struct usb_interface *intf)
971 struct hci_usb *husb = usb_get_intfdata(intf);
972 struct hci_dev *hdev;
974 if (!husb || intf == husb->isoc_iface)
977 usb_set_intfdata(intf, NULL);
980 BT_DBG("%s", hdev->name);
984 if (husb->isoc_iface)
985 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
987 if (hci_unregister_dev(hdev) < 0)
988 BT_ERR("Can't unregister HCI device %s", hdev->name);
993 static struct usb_driver hci_usb_driver = {
994 .owner = THIS_MODULE,
996 .probe = hci_usb_probe,
997 .disconnect = hci_usb_disconnect,
998 .id_table = bluetooth_ids,
1001 static int __init hci_usb_init(void)
1005 BT_INFO("HCI USB driver ver %s", VERSION);
1007 if ((err = usb_register(&hci_usb_driver)) < 0)
1008 BT_ERR("Failed to register HCI USB driver");
1013 static void __exit hci_usb_exit(void)
1015 usb_deregister(&hci_usb_driver);
1018 module_init(hci_usb_init);
1019 module_exit(hci_usb_exit);
1021 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1022 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1023 MODULE_VERSION(VERSION);
1024 MODULE_LICENSE("GPL");