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>
32 * $Id: hci_usb.c,v 1.8 2002/07/18 17:23:09 maxk Exp $
36 #include <linux/config.h>
37 #include <linux/module.h>
39 #include <linux/kernel.h>
40 #include <linux/init.h>
41 #include <linux/sched.h>
42 #include <linux/unistd.h>
43 #include <linux/types.h>
44 #include <linux/interrupt.h>
46 #include <linux/slab.h>
47 #include <linux/errno.h>
48 #include <linux/string.h>
49 #include <linux/skbuff.h>
51 #include <linux/usb.h>
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/hci_core.h>
58 #ifndef CONFIG_BT_HCIUSB_DEBUG
60 #define BT_DBG( A... )
62 #define BT_DMP( A... )
65 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
66 #undef URB_ZERO_PACKET
67 #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 { } /* Terminating entry */
106 struct _urb *_urb_alloc(int isoc, int gfp)
108 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
109 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
111 memset(_urb, 0, sizeof(*_urb));
112 usb_init_urb(&_urb->urb);
117 struct _urb *_urb_dequeue(struct _urb_queue *q)
119 struct _urb *_urb = NULL;
121 spin_lock_irqsave(&q->lock, flags);
123 struct list_head *head = &q->head;
124 struct list_head *next = head->next;
126 _urb = list_entry(next, struct _urb, list);
127 list_del(next); _urb->queue = NULL;
130 spin_unlock_irqrestore(&q->lock, flags);
134 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
135 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
137 #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
138 #define __pending_q(husb, type) (&husb->pending_q[type-1])
139 #define __completed_q(husb, type) (&husb->completed_q[type-1])
140 #define __transmit_q(husb, type) (&husb->transmit_q[type-1])
141 #define __reassembly(husb, type) (husb->reassembly[type-1])
143 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
145 return _urb_dequeue(__completed_q(husb, type));
148 #ifdef CONFIG_BT_HCIUSB_SCO
149 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
153 BT_DBG("len %d mtu %d", len, mtu);
155 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
156 urb->iso_frame_desc[i].offset = offset;
157 urb->iso_frame_desc[i].length = mtu;
158 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
160 if (len && i < HCI_MAX_ISOC_FRAMES) {
161 urb->iso_frame_desc[i].offset = offset;
162 urb->iso_frame_desc[i].length = len;
163 BT_DBG("desc %d offset %d len %d", i, offset, len);
166 urb->number_of_packets = i;
170 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
174 int err, pipe, interval, size;
177 BT_DBG("%s", husb->hdev->name);
179 size = husb->intr_in_ep->desc.wMaxPacketSize;
181 buf = kmalloc(size, GFP_ATOMIC);
185 _urb = _urb_alloc(0, GFP_ATOMIC);
190 _urb->type = HCI_EVENT_PKT;
191 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
194 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
195 interval = husb->intr_in_ep->desc.bInterval;
196 usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
198 err = usb_submit_urb(urb, GFP_ATOMIC);
200 BT_ERR("%s intr rx submit failed urb %p err %d",
201 husb->hdev->name, urb, err);
209 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
213 int err, pipe, size = HCI_MAX_FRAME_SIZE;
216 buf = kmalloc(size, GFP_ATOMIC);
220 _urb = _urb_alloc(0, GFP_ATOMIC);
225 _urb->type = HCI_ACLDATA_PKT;
226 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
229 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
230 usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
231 urb->transfer_flags = 0;
233 BT_DBG("%s urb %p", husb->hdev->name, urb);
235 err = usb_submit_urb(urb, GFP_ATOMIC);
237 BT_ERR("%s bulk rx submit failed urb %p err %d",
238 husb->hdev->name, urb, err);
246 #ifdef CONFIG_BT_HCIUSB_SCO
247 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
254 mtu = husb->isoc_in_ep->desc.wMaxPacketSize;
255 size = mtu * HCI_MAX_ISOC_FRAMES;
257 buf = kmalloc(size, GFP_ATOMIC);
261 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
266 _urb->type = HCI_SCODATA_PKT;
267 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
272 urb->dev = husb->udev;
273 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
274 urb->complete = hci_usb_rx_complete;
276 urb->interval = husb->isoc_in_ep->desc.bInterval;
278 urb->transfer_buffer_length = size;
279 urb->transfer_buffer = buf;
280 urb->transfer_flags = URB_ISO_ASAP;
282 __fill_isoc_desc(urb, size, mtu);
284 BT_DBG("%s urb %p", husb->hdev->name, urb);
286 err = usb_submit_urb(urb, GFP_ATOMIC);
288 BT_ERR("%s isoc rx submit failed urb %p err %d",
289 husb->hdev->name, urb, err);
298 /* Initialize device */
299 static int hci_usb_open(struct hci_dev *hdev)
301 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
305 BT_DBG("%s", hdev->name);
307 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
310 write_lock_irqsave(&husb->completion_lock, flags);
312 err = hci_usb_intr_rx_submit(husb);
314 for (i = 0; i < HCI_MAX_BULK_RX; i++)
315 hci_usb_bulk_rx_submit(husb);
317 #ifdef CONFIG_BT_HCIUSB_SCO
318 if (husb->isoc_iface)
319 for (i = 0; i < HCI_MAX_ISOC_RX; i++)
320 hci_usb_isoc_rx_submit(husb);
323 clear_bit(HCI_RUNNING, &hdev->flags);
326 write_unlock_irqrestore(&husb->completion_lock, flags);
331 static int hci_usb_flush(struct hci_dev *hdev)
333 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
336 BT_DBG("%s", hdev->name);
338 for (i=0; i < 4; i++)
339 skb_queue_purge(&husb->transmit_q[i]);
343 static inline void hci_usb_wait_for_urb(struct urb *urb)
345 while (atomic_read(&urb->count) > 1) {
346 current->state = TASK_UNINTERRUPTIBLE;
347 schedule_timeout((5 * HZ + 999) / 1000);
351 static void hci_usb_unlink_urbs(struct hci_usb *husb)
355 BT_DBG("%s", husb->hdev->name);
357 for (i=0; i < 4; i++) {
361 /* Kill pending requests */
362 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
364 BT_DBG("%s unlinking _urb %p type %d urb %p",
365 husb->hdev->name, _urb, _urb->type, urb);
367 hci_usb_wait_for_urb(urb);
368 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
371 /* Release completed requests */
372 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
374 BT_DBG("%s freeing _urb %p type %d urb %p",
375 husb->hdev->name, _urb, _urb->type, urb);
376 if (urb->setup_packet)
377 kfree(urb->setup_packet);
378 if (urb->transfer_buffer)
379 kfree(urb->transfer_buffer);
383 /* Release reassembly buffers */
384 if (husb->reassembly[i]) {
385 kfree_skb(husb->reassembly[i]);
386 husb->reassembly[i] = NULL;
392 static int hci_usb_close(struct hci_dev *hdev)
394 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
397 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
400 BT_DBG("%s", hdev->name);
402 /* Synchronize with completion handlers */
403 write_lock_irqsave(&husb->completion_lock, flags);
404 write_unlock_irqrestore(&husb->completion_lock, flags);
406 hci_usb_unlink_urbs(husb);
411 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
413 struct urb *urb = &_urb->urb;
416 BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
418 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
419 err = usb_submit_urb(urb, GFP_ATOMIC);
421 BT_ERR("%s tx submit failed urb %p type %d err %d",
422 husb->hdev->name, urb, _urb->type, err);
424 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
426 atomic_inc(__pending_tx(husb, _urb->type));
431 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
433 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
434 struct usb_ctrlrequest *dr;
438 _urb = _urb_alloc(0, GFP_ATOMIC);
441 _urb->type = skb->pkt_type;
443 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
449 dr = (void *) _urb->urb.setup_packet;
451 dr->bRequestType = husb->ctrl_req;
455 dr->wLength = __cpu_to_le16(skb->len);
458 usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
459 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
461 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
464 return __tx_submit(husb, _urb);
467 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
469 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
474 _urb = _urb_alloc(0, GFP_ATOMIC);
477 _urb->type = skb->pkt_type;
481 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
482 usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
483 hci_usb_tx_complete, husb);
484 urb->transfer_flags = URB_ZERO_PACKET;
486 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
489 return __tx_submit(husb, _urb);
492 #ifdef CONFIG_BT_HCIUSB_SCO
493 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
495 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
499 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
502 _urb->type = skb->pkt_type;
505 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
510 urb->dev = husb->udev;
511 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
512 urb->complete = hci_usb_tx_complete;
513 urb->transfer_flags = URB_ISO_ASAP;
515 urb->interval = husb->isoc_out_ep->desc.bInterval;
517 urb->transfer_buffer = skb->data;
518 urb->transfer_buffer_length = skb->len;
520 __fill_isoc_desc(urb, skb->len, husb->isoc_out_ep->desc.wMaxPacketSize);
523 return __tx_submit(husb, _urb);
527 static void hci_usb_tx_process(struct hci_usb *husb)
529 struct sk_buff_head *q;
532 BT_DBG("%s", husb->hdev->name);
535 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
537 /* Process command queue */
538 q = __transmit_q(husb, HCI_COMMAND_PKT);
539 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
540 (skb = skb_dequeue(q))) {
541 if (hci_usb_send_ctrl(husb, skb) < 0)
542 skb_queue_head(q, skb);
545 #ifdef CONFIG_BT_HCIUSB_SCO
546 /* Process SCO queue */
547 q = __transmit_q(husb, HCI_SCODATA_PKT);
548 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
549 (skb = skb_dequeue(q))) {
550 if (hci_usb_send_isoc(husb, skb) < 0)
551 skb_queue_head(q, skb);
555 /* Process ACL queue */
556 q = __transmit_q(husb, HCI_ACLDATA_PKT);
557 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
558 (skb = skb_dequeue(q))) {
559 if (hci_usb_send_bulk(husb, skb) < 0) {
560 skb_queue_head(q, skb);
564 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
567 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
569 /* Serialize TX queue processing to avoid data reordering */
570 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
571 hci_usb_tx_process(husb);
572 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
574 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
577 /* Send frames from HCI layer */
578 static int hci_usb_send_frame(struct sk_buff *skb)
580 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
581 struct hci_usb *husb;
584 BT_ERR("frame for uknown device (hdev=NULL)");
588 if (!test_bit(HCI_RUNNING, &hdev->flags))
591 BT_DBG("%s type %d len %d", hdev->name, skb->pkt_type, skb->len);
593 husb = (struct hci_usb *) hdev->driver_data;
595 switch (skb->pkt_type) {
596 case HCI_COMMAND_PKT:
600 case HCI_ACLDATA_PKT:
604 #ifdef CONFIG_BT_HCIUSB_SCO
605 case HCI_SCODATA_PKT:
615 read_lock(&husb->completion_lock);
617 skb_queue_tail(__transmit_q(husb, skb->pkt_type), skb);
618 hci_usb_tx_wakeup(husb);
620 read_unlock(&husb->completion_lock);
624 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
626 BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
628 husb->hdev->stat.byte_rx += count;
631 struct sk_buff *skb = __reassembly(husb, type);
632 struct { int expect; } *scb;
636 /* Start of the frame */
640 if (count >= HCI_EVENT_HDR_SIZE) {
641 struct hci_event_hdr *h = data;
642 len = HCI_EVENT_HDR_SIZE + h->plen;
647 case HCI_ACLDATA_PKT:
648 if (count >= HCI_ACL_HDR_SIZE) {
649 struct hci_acl_hdr *h = data;
650 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
654 #ifdef CONFIG_BT_HCIUSB_SCO
655 case HCI_SCODATA_PKT:
656 if (count >= HCI_SCO_HDR_SIZE) {
657 struct hci_sco_hdr *h = data;
658 len = HCI_SCO_HDR_SIZE + h->dlen;
664 BT_DBG("new packet len %d", len);
666 skb = bt_skb_alloc(len, GFP_ATOMIC);
668 BT_ERR("%s no memory for the packet", husb->hdev->name);
671 skb->dev = (void *) husb->hdev;
672 skb->pkt_type = type;
674 __reassembly(husb, type) = skb;
676 scb = (void *) skb->cb;
680 scb = (void *) skb->cb;
684 len = min(len, count);
686 memcpy(skb_put(skb, len), data, len);
691 __reassembly(husb, type) = NULL;
695 count -= len; data += len;
700 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
702 struct _urb *_urb = container_of(urb, struct _urb, urb);
703 struct hci_usb *husb = (void *) urb->context;
704 struct hci_dev *hdev = husb->hdev;
705 int err, count = urb->actual_length;
707 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
708 _urb->type, urb->status, count, urb->transfer_flags);
710 read_lock(&husb->completion_lock);
712 if (!test_bit(HCI_RUNNING, &hdev->flags))
715 if (urb->status || !count)
718 if (_urb->type == HCI_SCODATA_PKT) {
719 #ifdef CONFIG_BT_HCIUSB_SCO
721 for (i=0; i < urb->number_of_packets; i++) {
722 BT_DBG("desc %d status %d offset %d len %d", i,
723 urb->iso_frame_desc[i].status,
724 urb->iso_frame_desc[i].offset,
725 urb->iso_frame_desc[i].actual_length);
727 if (!urb->iso_frame_desc[i].status)
728 __recv_frame(husb, _urb->type,
729 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
730 urb->iso_frame_desc[i].actual_length);
736 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
738 BT_ERR("%s corrupted packet: type %d count %d",
739 husb->hdev->name, _urb->type, count);
745 urb->dev = husb->udev;
746 err = usb_submit_urb(urb, GFP_ATOMIC);
747 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
751 read_unlock(&husb->completion_lock);
754 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
756 struct _urb *_urb = container_of(urb, struct _urb, urb);
757 struct hci_usb *husb = (void *) urb->context;
758 struct hci_dev *hdev = husb->hdev;
760 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
761 urb->status, urb->transfer_flags);
763 atomic_dec(__pending_tx(husb, _urb->type));
765 urb->transfer_buffer = NULL;
766 kfree_skb((struct sk_buff *) _urb->priv);
768 if (!test_bit(HCI_RUNNING, &hdev->flags))
772 hdev->stat.byte_tx += urb->transfer_buffer_length;
776 read_lock(&husb->completion_lock);
779 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
781 hci_usb_tx_wakeup(husb);
783 read_unlock(&husb->completion_lock);
786 static void hci_usb_destruct(struct hci_dev *hdev)
788 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
790 BT_DBG("%s", hdev->name);
795 int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
797 struct usb_device *udev = interface_to_usbdev(intf);
798 struct usb_host_endpoint *bulk_out_ep[HCI_MAX_IFACE_NUM];
799 struct usb_host_endpoint *isoc_out_ep[HCI_MAX_IFACE_NUM];
800 struct usb_host_endpoint *bulk_in_ep[HCI_MAX_IFACE_NUM];
801 struct usb_host_endpoint *isoc_in_ep[HCI_MAX_IFACE_NUM];
802 struct usb_host_endpoint *intr_in_ep[HCI_MAX_IFACE_NUM];
803 struct usb_host_endpoint *ep;
804 struct usb_host_interface *uif;
805 struct usb_interface *iface, *isoc_iface;
806 struct hci_usb *husb;
807 struct hci_dev *hdev;
808 int i, a, e, size, ifn, isoc_ifnum, isoc_alts;
810 BT_DBG("udev %p intf %p", udev, intf);
812 if (!id->driver_info) {
813 const struct usb_device_id *match;
814 match = usb_match_id(intf, blacklist_ids);
819 iface = udev->actconfig->interface[0];
821 if (id->driver_info & HCI_IGNORE)
824 if (intf->altsetting->desc.bInterfaceNumber > 0)
827 /* Check number of endpoints */
828 if (intf->altsetting[0].desc.bNumEndpoints < 3)
831 memset(bulk_out_ep, 0, sizeof(bulk_out_ep));
832 memset(isoc_out_ep, 0, sizeof(isoc_out_ep));
833 memset(bulk_in_ep, 0, sizeof(bulk_in_ep));
834 memset(isoc_in_ep, 0, sizeof(isoc_in_ep));
835 memset(intr_in_ep, 0, sizeof(intr_in_ep));
839 isoc_alts = isoc_ifnum = 0;
841 /* Find endpoints that we need */
843 ifn = min_t(unsigned int, udev->actconfig->desc.bNumInterfaces, HCI_MAX_IFACE_NUM);
844 for (i = 0; i < ifn; i++) {
845 iface = udev->actconfig->interface[i];
846 for (a = 0; a < iface->num_altsetting; a++) {
847 uif = &iface->altsetting[a];
848 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
849 ep = &uif->endpoint[e];
851 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
852 case USB_ENDPOINT_XFER_INT:
853 if (ep->desc.bEndpointAddress & USB_DIR_IN)
857 case USB_ENDPOINT_XFER_BULK:
858 if (ep->desc.bEndpointAddress & USB_DIR_IN)
864 #ifdef CONFIG_BT_HCIUSB_SCO
865 case USB_ENDPOINT_XFER_ISOC:
866 if (ep->desc.wMaxPacketSize < size || a > 2)
868 size = ep->desc.wMaxPacketSize;
874 if (ep->desc.bEndpointAddress & USB_DIR_IN)
885 if (!bulk_in_ep[0] || !bulk_out_ep[0] || !intr_in_ep[0]) {
886 BT_DBG("Bulk endpoints not found");
890 #ifdef CONFIG_BT_HCIUSB_SCO
891 if (!isoc_in_ep[1] || !isoc_out_ep[1]) {
892 BT_DBG("Isoc endpoints not found");
897 if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
898 BT_ERR("Can't allocate: control structure");
902 memset(husb, 0, sizeof(struct hci_usb));
905 husb->bulk_out_ep = bulk_out_ep[0];
906 husb->bulk_in_ep = bulk_in_ep[0];
907 husb->intr_in_ep = intr_in_ep[0];
909 if (id->driver_info & HCI_DIGIANSWER)
910 husb->ctrl_req = HCI_DIGI_REQ;
912 husb->ctrl_req = HCI_CTRL_REQ;
914 #ifdef CONFIG_BT_HCIUSB_SCO
916 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
917 if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
918 BT_ERR("Can't set isoc interface settings");
921 usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb);
922 husb->isoc_iface = isoc_iface;
923 husb->isoc_in_ep = isoc_in_ep[isoc_ifnum];
924 husb->isoc_out_ep = isoc_out_ep[isoc_ifnum];
928 husb->completion_lock = RW_LOCK_UNLOCKED;
930 for (i = 0; i < 4; i++) {
931 skb_queue_head_init(&husb->transmit_q[i]);
932 _urb_queue_init(&husb->pending_q[i]);
933 _urb_queue_init(&husb->completed_q[i]);
936 /* Initialize and register HCI device */
937 hdev = hci_alloc_dev();
939 BT_ERR("Can't allocate HCI device");
945 hdev->type = HCI_USB;
946 hdev->driver_data = husb;
947 SET_HCIDEV_DEV(hdev, &intf->dev);
949 hdev->open = hci_usb_open;
950 hdev->close = hci_usb_close;
951 hdev->flush = hci_usb_flush;
952 hdev->send = hci_usb_send_frame;
953 hdev->destruct = hci_usb_destruct;
955 hdev->owner = THIS_MODULE;
957 if (id->driver_info & HCI_RESET)
958 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
960 if (hci_register_dev(hdev) < 0) {
961 BT_ERR("Can't register HCI device");
966 usb_set_intfdata(intf, husb);
976 static void hci_usb_disconnect(struct usb_interface *intf)
978 struct hci_usb *husb = usb_get_intfdata(intf);
979 struct hci_dev *hdev = husb->hdev;
983 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");