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 /* Ericsson with non-standard id */
80 { USB_DEVICE(0x0bdb, 0x1002) },
82 /* ALPS Module with non-standard id */
83 { USB_DEVICE(0x044e, 0x3002) },
85 /* Bluetooth Ultraport Module from IBM */
86 { USB_DEVICE(0x04bf, 0x030a) },
88 { } /* Terminating entry */
91 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
93 static struct usb_device_id blacklist_ids[] = {
94 /* Broadcom BCM2033 without firmware */
95 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
97 /* Broadcom BCM2035 */
98 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET },
100 /* Digianswer device */
101 { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
103 /* RTX Telecom based adapter with buggy SCO support */
104 { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
106 { } /* Terminating entry */
109 struct _urb *_urb_alloc(int isoc, int gfp)
111 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
112 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
114 memset(_urb, 0, sizeof(*_urb));
115 usb_init_urb(&_urb->urb);
120 struct _urb *_urb_dequeue(struct _urb_queue *q)
122 struct _urb *_urb = NULL;
124 spin_lock_irqsave(&q->lock, flags);
126 struct list_head *head = &q->head;
127 struct list_head *next = head->next;
129 _urb = list_entry(next, struct _urb, list);
130 list_del(next); _urb->queue = NULL;
133 spin_unlock_irqrestore(&q->lock, flags);
137 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
138 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
140 #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
141 #define __pending_q(husb, type) (&husb->pending_q[type-1])
142 #define __completed_q(husb, type) (&husb->completed_q[type-1])
143 #define __transmit_q(husb, type) (&husb->transmit_q[type-1])
144 #define __reassembly(husb, type) (husb->reassembly[type-1])
146 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
148 return _urb_dequeue(__completed_q(husb, type));
151 #ifdef CONFIG_BT_HCIUSB_SCO
152 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
156 BT_DBG("len %d mtu %d", len, mtu);
158 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
159 urb->iso_frame_desc[i].offset = offset;
160 urb->iso_frame_desc[i].length = mtu;
161 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
163 if (len && i < HCI_MAX_ISOC_FRAMES) {
164 urb->iso_frame_desc[i].offset = offset;
165 urb->iso_frame_desc[i].length = len;
166 BT_DBG("desc %d offset %d len %d", i, offset, len);
169 urb->number_of_packets = i;
173 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
177 int err, pipe, interval, size;
180 BT_DBG("%s", husb->hdev->name);
182 size = husb->intr_in_ep->desc.wMaxPacketSize;
184 buf = kmalloc(size, GFP_ATOMIC);
188 _urb = _urb_alloc(0, GFP_ATOMIC);
193 _urb->type = HCI_EVENT_PKT;
194 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
197 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
198 interval = husb->intr_in_ep->desc.bInterval;
199 usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
201 err = usb_submit_urb(urb, GFP_ATOMIC);
203 BT_ERR("%s intr rx submit failed urb %p err %d",
204 husb->hdev->name, urb, err);
212 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
216 int err, pipe, size = HCI_MAX_FRAME_SIZE;
219 buf = kmalloc(size, GFP_ATOMIC);
223 _urb = _urb_alloc(0, GFP_ATOMIC);
228 _urb->type = HCI_ACLDATA_PKT;
229 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
232 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
233 usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
234 urb->transfer_flags = 0;
236 BT_DBG("%s urb %p", husb->hdev->name, urb);
238 err = usb_submit_urb(urb, GFP_ATOMIC);
240 BT_ERR("%s bulk rx submit failed urb %p err %d",
241 husb->hdev->name, urb, err);
249 #ifdef CONFIG_BT_HCIUSB_SCO
250 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
257 mtu = husb->isoc_in_ep->desc.wMaxPacketSize;
258 size = mtu * HCI_MAX_ISOC_FRAMES;
260 buf = kmalloc(size, GFP_ATOMIC);
264 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
269 _urb->type = HCI_SCODATA_PKT;
270 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
275 urb->dev = husb->udev;
276 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
277 urb->complete = hci_usb_rx_complete;
279 urb->interval = husb->isoc_in_ep->desc.bInterval;
281 urb->transfer_buffer_length = size;
282 urb->transfer_buffer = buf;
283 urb->transfer_flags = URB_ISO_ASAP;
285 __fill_isoc_desc(urb, size, mtu);
287 BT_DBG("%s urb %p", husb->hdev->name, urb);
289 err = usb_submit_urb(urb, GFP_ATOMIC);
291 BT_ERR("%s isoc rx submit failed urb %p err %d",
292 husb->hdev->name, urb, err);
301 /* Initialize device */
302 static int hci_usb_open(struct hci_dev *hdev)
304 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
308 BT_DBG("%s", hdev->name);
310 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
313 write_lock_irqsave(&husb->completion_lock, flags);
315 err = hci_usb_intr_rx_submit(husb);
317 for (i = 0; i < HCI_MAX_BULK_RX; i++)
318 hci_usb_bulk_rx_submit(husb);
320 #ifdef CONFIG_BT_HCIUSB_SCO
321 if (husb->isoc_iface)
322 for (i = 0; i < HCI_MAX_ISOC_RX; i++)
323 hci_usb_isoc_rx_submit(husb);
326 clear_bit(HCI_RUNNING, &hdev->flags);
329 write_unlock_irqrestore(&husb->completion_lock, flags);
334 static int hci_usb_flush(struct hci_dev *hdev)
336 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
339 BT_DBG("%s", hdev->name);
341 for (i=0; i < 4; i++)
342 skb_queue_purge(&husb->transmit_q[i]);
346 static inline void hci_usb_wait_for_urb(struct urb *urb)
348 while (atomic_read(&urb->kref.refcount) > 1) {
349 current->state = TASK_UNINTERRUPTIBLE;
350 schedule_timeout((5 * HZ + 999) / 1000);
354 static void hci_usb_unlink_urbs(struct hci_usb *husb)
358 BT_DBG("%s", husb->hdev->name);
360 for (i=0; i < 4; i++) {
364 /* Kill pending requests */
365 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
367 BT_DBG("%s unlinking _urb %p type %d urb %p",
368 husb->hdev->name, _urb, _urb->type, urb);
370 hci_usb_wait_for_urb(urb);
371 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
374 /* Release completed requests */
375 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
377 BT_DBG("%s freeing _urb %p type %d urb %p",
378 husb->hdev->name, _urb, _urb->type, urb);
379 if (urb->setup_packet)
380 kfree(urb->setup_packet);
381 if (urb->transfer_buffer)
382 kfree(urb->transfer_buffer);
386 /* Release reassembly buffers */
387 if (husb->reassembly[i]) {
388 kfree_skb(husb->reassembly[i]);
389 husb->reassembly[i] = NULL;
395 static int hci_usb_close(struct hci_dev *hdev)
397 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
400 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
403 BT_DBG("%s", hdev->name);
405 /* Synchronize with completion handlers */
406 write_lock_irqsave(&husb->completion_lock, flags);
407 write_unlock_irqrestore(&husb->completion_lock, flags);
409 hci_usb_unlink_urbs(husb);
414 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
416 struct urb *urb = &_urb->urb;
419 BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
421 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
422 err = usb_submit_urb(urb, GFP_ATOMIC);
424 BT_ERR("%s tx submit failed urb %p type %d err %d",
425 husb->hdev->name, urb, _urb->type, err);
427 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
429 atomic_inc(__pending_tx(husb, _urb->type));
434 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
436 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
437 struct usb_ctrlrequest *dr;
441 _urb = _urb_alloc(0, GFP_ATOMIC);
444 _urb->type = skb->pkt_type;
446 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
452 dr = (void *) _urb->urb.setup_packet;
454 dr->bRequestType = husb->ctrl_req;
458 dr->wLength = __cpu_to_le16(skb->len);
461 usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
462 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
464 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
467 return __tx_submit(husb, _urb);
470 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
472 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
477 _urb = _urb_alloc(0, GFP_ATOMIC);
480 _urb->type = skb->pkt_type;
484 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
485 usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
486 hci_usb_tx_complete, husb);
487 urb->transfer_flags = URB_ZERO_PACKET;
489 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
492 return __tx_submit(husb, _urb);
495 #ifdef CONFIG_BT_HCIUSB_SCO
496 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
498 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
502 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
505 _urb->type = skb->pkt_type;
508 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
513 urb->dev = husb->udev;
514 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
515 urb->complete = hci_usb_tx_complete;
516 urb->transfer_flags = URB_ISO_ASAP;
518 urb->interval = husb->isoc_out_ep->desc.bInterval;
520 urb->transfer_buffer = skb->data;
521 urb->transfer_buffer_length = skb->len;
523 __fill_isoc_desc(urb, skb->len, husb->isoc_out_ep->desc.wMaxPacketSize);
526 return __tx_submit(husb, _urb);
530 static void hci_usb_tx_process(struct hci_usb *husb)
532 struct sk_buff_head *q;
535 BT_DBG("%s", husb->hdev->name);
538 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
540 /* Process command queue */
541 q = __transmit_q(husb, HCI_COMMAND_PKT);
542 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
543 (skb = skb_dequeue(q))) {
544 if (hci_usb_send_ctrl(husb, skb) < 0)
545 skb_queue_head(q, skb);
548 #ifdef CONFIG_BT_HCIUSB_SCO
549 /* Process SCO queue */
550 q = __transmit_q(husb, HCI_SCODATA_PKT);
551 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
552 (skb = skb_dequeue(q))) {
553 if (hci_usb_send_isoc(husb, skb) < 0)
554 skb_queue_head(q, skb);
558 /* Process ACL queue */
559 q = __transmit_q(husb, HCI_ACLDATA_PKT);
560 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
561 (skb = skb_dequeue(q))) {
562 if (hci_usb_send_bulk(husb, skb) < 0) {
563 skb_queue_head(q, skb);
567 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
570 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
572 /* Serialize TX queue processing to avoid data reordering */
573 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
574 hci_usb_tx_process(husb);
575 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
577 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
580 /* Send frames from HCI layer */
581 static int hci_usb_send_frame(struct sk_buff *skb)
583 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
584 struct hci_usb *husb;
587 BT_ERR("frame for uknown device (hdev=NULL)");
591 if (!test_bit(HCI_RUNNING, &hdev->flags))
594 BT_DBG("%s type %d len %d", hdev->name, skb->pkt_type, skb->len);
596 husb = (struct hci_usb *) hdev->driver_data;
598 switch (skb->pkt_type) {
599 case HCI_COMMAND_PKT:
603 case HCI_ACLDATA_PKT:
607 #ifdef CONFIG_BT_HCIUSB_SCO
608 case HCI_SCODATA_PKT:
618 read_lock(&husb->completion_lock);
620 skb_queue_tail(__transmit_q(husb, skb->pkt_type), skb);
621 hci_usb_tx_wakeup(husb);
623 read_unlock(&husb->completion_lock);
627 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
629 BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
631 husb->hdev->stat.byte_rx += count;
634 struct sk_buff *skb = __reassembly(husb, type);
635 struct { int expect; } *scb;
639 /* Start of the frame */
643 if (count >= HCI_EVENT_HDR_SIZE) {
644 struct hci_event_hdr *h = data;
645 len = HCI_EVENT_HDR_SIZE + h->plen;
650 case HCI_ACLDATA_PKT:
651 if (count >= HCI_ACL_HDR_SIZE) {
652 struct hci_acl_hdr *h = data;
653 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
657 #ifdef CONFIG_BT_HCIUSB_SCO
658 case HCI_SCODATA_PKT:
659 if (count >= HCI_SCO_HDR_SIZE) {
660 struct hci_sco_hdr *h = data;
661 len = HCI_SCO_HDR_SIZE + h->dlen;
667 BT_DBG("new packet len %d", len);
669 skb = bt_skb_alloc(len, GFP_ATOMIC);
671 BT_ERR("%s no memory for the packet", husb->hdev->name);
674 skb->dev = (void *) husb->hdev;
675 skb->pkt_type = type;
677 __reassembly(husb, type) = skb;
679 scb = (void *) skb->cb;
683 scb = (void *) skb->cb;
687 len = min(len, count);
689 memcpy(skb_put(skb, len), data, len);
694 __reassembly(husb, type) = NULL;
698 count -= len; data += len;
703 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
705 struct _urb *_urb = container_of(urb, struct _urb, urb);
706 struct hci_usb *husb = (void *) urb->context;
707 struct hci_dev *hdev = husb->hdev;
708 int err, count = urb->actual_length;
710 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
711 _urb->type, urb->status, count, urb->transfer_flags);
713 read_lock(&husb->completion_lock);
715 if (!test_bit(HCI_RUNNING, &hdev->flags))
718 if (urb->status || !count)
721 if (_urb->type == HCI_SCODATA_PKT) {
722 #ifdef CONFIG_BT_HCIUSB_SCO
724 for (i=0; i < urb->number_of_packets; i++) {
725 BT_DBG("desc %d status %d offset %d len %d", i,
726 urb->iso_frame_desc[i].status,
727 urb->iso_frame_desc[i].offset,
728 urb->iso_frame_desc[i].actual_length);
730 if (!urb->iso_frame_desc[i].status)
731 __recv_frame(husb, _urb->type,
732 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
733 urb->iso_frame_desc[i].actual_length);
739 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
741 BT_ERR("%s corrupted packet: type %d count %d",
742 husb->hdev->name, _urb->type, count);
748 urb->dev = husb->udev;
749 err = usb_submit_urb(urb, GFP_ATOMIC);
750 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
754 read_unlock(&husb->completion_lock);
757 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
759 struct _urb *_urb = container_of(urb, struct _urb, urb);
760 struct hci_usb *husb = (void *) urb->context;
761 struct hci_dev *hdev = husb->hdev;
763 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
764 urb->status, urb->transfer_flags);
766 atomic_dec(__pending_tx(husb, _urb->type));
768 urb->transfer_buffer = NULL;
769 kfree_skb((struct sk_buff *) _urb->priv);
771 if (!test_bit(HCI_RUNNING, &hdev->flags))
775 hdev->stat.byte_tx += urb->transfer_buffer_length;
779 read_lock(&husb->completion_lock);
782 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
784 hci_usb_tx_wakeup(husb);
786 read_unlock(&husb->completion_lock);
789 static void hci_usb_destruct(struct hci_dev *hdev)
791 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
793 BT_DBG("%s", hdev->name);
798 int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
800 struct usb_device *udev = interface_to_usbdev(intf);
801 struct usb_host_endpoint *bulk_out_ep = NULL;
802 struct usb_host_endpoint *bulk_in_ep = NULL;
803 struct usb_host_endpoint *intr_in_ep = NULL;
804 struct usb_host_endpoint *ep;
805 struct usb_host_interface *uif;
806 struct usb_interface *isoc_iface;
807 struct hci_usb *husb;
808 struct hci_dev *hdev;
809 int i, e, size, isoc_ifnum, isoc_alts;
811 BT_DBG("udev %p intf %p", udev, intf);
813 if (!id->driver_info) {
814 const struct usb_device_id *match;
815 match = usb_match_id(intf, blacklist_ids);
820 if (id->driver_info & HCI_IGNORE)
823 if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
826 /* Find endpoints that we need */
827 uif = intf->cur_altsetting;
828 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
829 ep = &uif->endpoint[e];
831 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
832 case USB_ENDPOINT_XFER_INT:
833 if (ep->desc.bEndpointAddress & USB_DIR_IN)
837 case USB_ENDPOINT_XFER_BULK:
838 if (ep->desc.bEndpointAddress & USB_DIR_IN)
846 if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
847 BT_DBG("Bulk endpoints not found");
851 if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
852 BT_ERR("Can't allocate: control structure");
856 memset(husb, 0, sizeof(struct hci_usb));
859 husb->bulk_out_ep = bulk_out_ep;
860 husb->bulk_in_ep = bulk_in_ep;
861 husb->intr_in_ep = intr_in_ep;
863 if (id->driver_info & HCI_DIGIANSWER)
864 husb->ctrl_req = HCI_DIGI_REQ;
866 husb->ctrl_req = HCI_CTRL_REQ;
868 /* Find isochronous endpoints that we can use */
874 #ifdef CONFIG_BT_HCIUSB_SCO
875 if (!(id->driver_info & HCI_BROKEN_ISOC))
876 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
880 struct usb_host_endpoint *isoc_out_ep = NULL;
881 struct usb_host_endpoint *isoc_in_ep = NULL;
883 for (a = 0; a < isoc_iface->num_altsetting; a++) {
884 uif = &isoc_iface->altsetting[a];
885 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
886 ep = &uif->endpoint[e];
888 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
889 case USB_ENDPOINT_XFER_ISOC:
890 if (ep->desc.wMaxPacketSize < size ||
891 uif->desc.bAlternateSetting > 2)
893 size = ep->desc.wMaxPacketSize;
895 isoc_alts = uif->desc.bAlternateSetting;
897 if (ep->desc.bEndpointAddress & USB_DIR_IN)
906 if (!isoc_in_ep || !isoc_out_ep)
907 BT_DBG("Isoc endpoints not found");
909 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
910 if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
911 BT_ERR("Can't claim isoc interface");
912 else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
913 BT_ERR("Can't set isoc interface settings");
914 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
916 husb->isoc_iface = isoc_iface;
917 husb->isoc_in_ep = isoc_in_ep;
918 husb->isoc_out_ep = isoc_out_ep;
924 husb->completion_lock = RW_LOCK_UNLOCKED;
926 for (i = 0; i < 4; i++) {
927 skb_queue_head_init(&husb->transmit_q[i]);
928 _urb_queue_init(&husb->pending_q[i]);
929 _urb_queue_init(&husb->completed_q[i]);
932 /* Initialize and register HCI device */
933 hdev = hci_alloc_dev();
935 BT_ERR("Can't allocate HCI device");
941 hdev->type = HCI_USB;
942 hdev->driver_data = husb;
943 SET_HCIDEV_DEV(hdev, &intf->dev);
945 hdev->open = hci_usb_open;
946 hdev->close = hci_usb_close;
947 hdev->flush = hci_usb_flush;
948 hdev->send = hci_usb_send_frame;
949 hdev->destruct = hci_usb_destruct;
951 hdev->owner = THIS_MODULE;
953 if (id->driver_info & HCI_RESET)
954 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
956 if (hci_register_dev(hdev) < 0) {
957 BT_ERR("Can't register HCI device");
962 usb_set_intfdata(intf, husb);
966 if (husb->isoc_iface)
967 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
974 static void hci_usb_disconnect(struct usb_interface *intf)
976 struct hci_usb *husb = usb_get_intfdata(intf);
977 struct hci_dev *hdev;
979 if (!husb || intf == husb->isoc_iface)
982 usb_set_intfdata(intf, NULL);
985 BT_DBG("%s", hdev->name);
989 if (husb->isoc_iface)
990 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
992 if (hci_unregister_dev(hdev) < 0)
993 BT_ERR("Can't unregister HCI device %s", hdev->name);
998 static struct usb_driver hci_usb_driver = {
999 .owner = THIS_MODULE,
1001 .probe = hci_usb_probe,
1002 .disconnect = hci_usb_disconnect,
1003 .id_table = bluetooth_ids,
1006 static int __init hci_usb_init(void)
1010 BT_INFO("HCI USB driver ver %s", VERSION);
1012 if ((err = usb_register(&hci_usb_driver)) < 0)
1013 BT_ERR("Failed to register HCI USB driver");
1018 static void __exit hci_usb_exit(void)
1020 usb_deregister(&hci_usb_driver);
1023 module_init(hci_usb_init);
1024 module_exit(hci_usb_exit);
1026 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1027 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1028 MODULE_VERSION(VERSION);
1029 MODULE_LICENSE("GPL");