Merge branch 'block-dir' of git://brick.kernel.dk/data/git/linux-2.6-block
[linux-2.6] / drivers / bluetooth / hci_usb.c
1 /* 
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>
5
6    Copyright (C) 2003 Maxim Krasnyansky <maxk@qualcomm.com>
7
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;
11
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.
20
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.
24 */
25
26 /*
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>
31  *
32  */
33
34 #include <linux/config.h>
35 #include <linux/module.h>
36
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>
43 #include <linux/moduleparam.h>
44
45 #include <linux/slab.h>
46 #include <linux/errno.h>
47 #include <linux/string.h>
48 #include <linux/skbuff.h>
49
50 #include <linux/usb.h>
51
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
54
55 #include "hci_usb.h"
56
57 #ifndef CONFIG_BT_HCIUSB_DEBUG
58 #undef  BT_DBG
59 #define BT_DBG(D...)
60 #endif
61
62 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
63 #undef  URB_ZERO_PACKET
64 #define URB_ZERO_PACKET 0
65 #endif
66
67 static int ignore = 0;
68 static int ignore_csr = 0;
69 static int ignore_sniffer = 0;
70 static int reset = 0;
71
72 #ifdef CONFIG_BT_HCIUSB_SCO
73 static int isoc = 2;
74 #endif
75
76 #define VERSION "2.9"
77
78 static struct usb_driver hci_usb_driver; 
79
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) },
83
84         /* AVM BlueFRITZ! USB v2.0 */
85         { USB_DEVICE(0x057c, 0x3800) },
86
87         /* Bluetooth Ultraport Module from IBM */
88         { USB_DEVICE(0x04bf, 0x030a) },
89
90         /* ALPS Modules with non-standard id */
91         { USB_DEVICE(0x044e, 0x3001) },
92         { USB_DEVICE(0x044e, 0x3002) },
93
94         /* Ericsson with non-standard id */
95         { USB_DEVICE(0x0bdb, 0x1002) },
96
97         { }     /* Terminating entry */
98 };
99
100 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
101
102 static struct usb_device_id blacklist_ids[] = {
103         /* CSR BlueCore devices */
104         { USB_DEVICE(0x0a12, 0x0001), .driver_info = HCI_CSR },
105
106         /* Broadcom BCM2033 without firmware */
107         { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
108
109         /* Broadcom BCM2035 */
110         { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET | HCI_BROKEN_ISOC },
111         { USB_DEVICE(0x0a5c, 0x2009), .driver_info = HCI_BCM92035 },
112
113         /* Microsoft Wireless Transceiver for Bluetooth 2.0 */
114         { USB_DEVICE(0x045e, 0x009c), .driver_info = HCI_RESET },
115
116         /* Kensington Bluetooth USB adapter */
117         { USB_DEVICE(0x047d, 0x105d), .driver_info = HCI_RESET },
118
119         /* ISSC Bluetooth Adapter v3.1 */
120         { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
121
122         /* RTX Telecom based adapter with buggy SCO support */
123         { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
124
125         /* Digianswer devices */
126         { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
127         { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
128
129         /* CSR BlueCore Bluetooth Sniffer */
130         { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
131
132         { }     /* Terminating entry */
133 };
134
135 static struct _urb *_urb_alloc(int isoc, gfp_t gfp)
136 {
137         struct _urb *_urb = kmalloc(sizeof(struct _urb) +
138                                 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
139         if (_urb) {
140                 memset(_urb, 0, sizeof(*_urb));
141                 usb_init_urb(&_urb->urb);
142         }
143         return _urb;
144 }
145
146 static struct _urb *_urb_dequeue(struct _urb_queue *q)
147 {
148         struct _urb *_urb = NULL;
149         unsigned long flags;
150         spin_lock_irqsave(&q->lock, flags);
151         {
152                 struct list_head *head = &q->head;
153                 struct list_head *next = head->next;
154                 if (next != head) {
155                         _urb = list_entry(next, struct _urb, list);
156                         list_del(next); _urb->queue = NULL;
157                 }
158         }
159         spin_unlock_irqrestore(&q->lock, flags);
160         return _urb;
161 }
162
163 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
164 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
165
166 #define __pending_tx(husb, type)  (&husb->pending_tx[type-1])
167 #define __pending_q(husb, type)   (&husb->pending_q[type-1])
168 #define __completed_q(husb, type) (&husb->completed_q[type-1])
169 #define __transmit_q(husb, type)  (&husb->transmit_q[type-1])
170 #define __reassembly(husb, type)  (husb->reassembly[type-1])
171
172 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
173 {
174         return _urb_dequeue(__completed_q(husb, type)); 
175 }
176
177 #ifdef CONFIG_BT_HCIUSB_SCO
178 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
179 {
180         int offset = 0, i;
181
182         BT_DBG("len %d mtu %d", len, mtu);
183
184         for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
185                 urb->iso_frame_desc[i].offset = offset;
186                 urb->iso_frame_desc[i].length = mtu;
187                 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
188         }
189         if (len && i < HCI_MAX_ISOC_FRAMES) {
190                 urb->iso_frame_desc[i].offset = offset;
191                 urb->iso_frame_desc[i].length = len;
192                 BT_DBG("desc %d offset %d len %d", i, offset, len);
193                 i++;
194         }
195         urb->number_of_packets = i;
196 }
197 #endif
198
199 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
200 {
201         struct _urb *_urb;
202         struct urb *urb;
203         int err, pipe, interval, size;
204         void *buf;
205
206         BT_DBG("%s", husb->hdev->name);
207
208         size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
209
210         buf = kmalloc(size, GFP_ATOMIC);
211         if (!buf)
212                 return -ENOMEM;
213
214         _urb = _urb_alloc(0, GFP_ATOMIC);
215         if (!_urb) {
216                 kfree(buf);
217                 return -ENOMEM;
218         }
219         _urb->type = HCI_EVENT_PKT;
220         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
221
222         urb = &_urb->urb;
223         pipe     = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
224         interval = husb->intr_in_ep->desc.bInterval;
225         usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
226         
227         err = usb_submit_urb(urb, GFP_ATOMIC);
228         if (err) {
229                 BT_ERR("%s intr rx submit failed urb %p err %d",
230                                 husb->hdev->name, urb, err);
231                 _urb_unlink(_urb);
232                 _urb_free(_urb);
233                 kfree(buf);
234         }
235         return err;
236 }
237
238 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
239 {
240         struct _urb *_urb;
241         struct urb *urb;
242         int err, pipe, size = HCI_MAX_FRAME_SIZE;
243         void *buf;
244
245         buf = kmalloc(size, GFP_ATOMIC);
246         if (!buf)
247                 return -ENOMEM;
248
249         _urb = _urb_alloc(0, GFP_ATOMIC);
250         if (!_urb) {
251                 kfree(buf);
252                 return -ENOMEM;
253         }
254         _urb->type = HCI_ACLDATA_PKT;
255         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
256
257         urb  = &_urb->urb;
258         pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
259         usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
260         urb->transfer_flags = 0;
261
262         BT_DBG("%s urb %p", husb->hdev->name, urb);
263
264         err = usb_submit_urb(urb, GFP_ATOMIC);
265         if (err) {
266                 BT_ERR("%s bulk rx submit failed urb %p err %d",
267                                 husb->hdev->name, urb, err);
268                 _urb_unlink(_urb);
269                 _urb_free(_urb);
270                 kfree(buf);
271         }
272         return err;
273 }
274
275 #ifdef CONFIG_BT_HCIUSB_SCO
276 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
277 {
278         struct _urb *_urb;
279         struct urb *urb;
280         int err, mtu, size;
281         void *buf;
282
283         mtu  = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
284         size = mtu * HCI_MAX_ISOC_FRAMES;
285
286         buf = kmalloc(size, GFP_ATOMIC);
287         if (!buf)
288                 return -ENOMEM;
289
290         _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
291         if (!_urb) {
292                 kfree(buf);
293                 return -ENOMEM;
294         }
295         _urb->type = HCI_SCODATA_PKT;
296         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
297
298         urb = &_urb->urb;
299
300         urb->context  = husb;
301         urb->dev      = husb->udev;
302         urb->pipe     = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
303         urb->complete = hci_usb_rx_complete;
304
305         urb->interval = husb->isoc_in_ep->desc.bInterval;
306
307         urb->transfer_buffer_length = size;
308         urb->transfer_buffer = buf;
309         urb->transfer_flags  = URB_ISO_ASAP;
310
311         __fill_isoc_desc(urb, size, mtu);
312
313         BT_DBG("%s urb %p", husb->hdev->name, urb);
314
315         err = usb_submit_urb(urb, GFP_ATOMIC);
316         if (err) {
317                 BT_ERR("%s isoc rx submit failed urb %p err %d",
318                                 husb->hdev->name, urb, err);
319                 _urb_unlink(_urb);
320                 _urb_free(_urb);
321                 kfree(buf);
322         }
323         return err;
324 }
325 #endif
326
327 /* Initialize device */
328 static int hci_usb_open(struct hci_dev *hdev)
329 {
330         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
331         int i, err;
332         unsigned long flags;
333
334         BT_DBG("%s", hdev->name);
335
336         if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
337                 return 0;
338
339         write_lock_irqsave(&husb->completion_lock, flags);
340
341         err = hci_usb_intr_rx_submit(husb);
342         if (!err) {
343                 for (i = 0; i < HCI_MAX_BULK_RX; i++)
344                         hci_usb_bulk_rx_submit(husb);
345
346 #ifdef CONFIG_BT_HCIUSB_SCO
347                 if (husb->isoc_iface)
348                         for (i = 0; i < HCI_MAX_ISOC_RX; i++)
349                                 hci_usb_isoc_rx_submit(husb);
350 #endif
351         } else {
352                 clear_bit(HCI_RUNNING, &hdev->flags);
353         }
354
355         write_unlock_irqrestore(&husb->completion_lock, flags);
356         return err;
357 }
358
359 /* Reset device */
360 static int hci_usb_flush(struct hci_dev *hdev)
361 {
362         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
363         int i;
364
365         BT_DBG("%s", hdev->name);
366
367         for (i = 0; i < 4; i++)
368                 skb_queue_purge(&husb->transmit_q[i]);
369         return 0;
370 }
371
372 static void hci_usb_unlink_urbs(struct hci_usb *husb)
373 {
374         int i;
375
376         BT_DBG("%s", husb->hdev->name);
377
378         for (i = 0; i < 4; i++) {
379                 struct _urb *_urb;
380                 struct urb *urb;
381
382                 /* Kill pending requests */
383                 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
384                         urb = &_urb->urb;
385                         BT_DBG("%s unlinking _urb %p type %d urb %p", 
386                                         husb->hdev->name, _urb, _urb->type, urb);
387                         usb_kill_urb(urb);
388                         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
389                 }
390
391                 /* Release completed requests */
392                 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
393                         urb = &_urb->urb;
394                         BT_DBG("%s freeing _urb %p type %d urb %p",
395                                         husb->hdev->name, _urb, _urb->type, urb);
396                         kfree(urb->setup_packet);
397                         kfree(urb->transfer_buffer);
398                         _urb_free(_urb);
399                 }
400
401                 /* Release reassembly buffers */
402                 if (husb->reassembly[i]) {
403                         kfree_skb(husb->reassembly[i]);
404                         husb->reassembly[i] = NULL;
405                 }
406         }
407 }
408
409 /* Close device */
410 static int hci_usb_close(struct hci_dev *hdev)
411 {
412         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
413         unsigned long flags;
414
415         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
416                 return 0;
417
418         BT_DBG("%s", hdev->name);
419
420         /* Synchronize with completion handlers */
421         write_lock_irqsave(&husb->completion_lock, flags);
422         write_unlock_irqrestore(&husb->completion_lock, flags);
423
424         hci_usb_unlink_urbs(husb);
425         hci_usb_flush(hdev);
426         return 0;
427 }
428
429 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
430 {
431         struct urb *urb = &_urb->urb;
432         int err;
433
434         BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
435
436         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
437         err = usb_submit_urb(urb, GFP_ATOMIC);
438         if (err) {
439                 BT_ERR("%s tx submit failed urb %p type %d err %d",
440                                 husb->hdev->name, urb, _urb->type, err);
441                 _urb_unlink(_urb);
442                 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
443         } else
444                 atomic_inc(__pending_tx(husb, _urb->type));
445
446         return err;
447 }
448
449 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
450 {
451         struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
452         struct usb_ctrlrequest *dr;
453         struct urb *urb;
454
455         if (!_urb) {
456                 _urb = _urb_alloc(0, GFP_ATOMIC);
457                 if (!_urb)
458                         return -ENOMEM;
459                 _urb->type = bt_cb(skb)->pkt_type;
460
461                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
462                 if (!dr) {
463                         _urb_free(_urb);
464                         return -ENOMEM;
465                 }
466         } else
467                 dr = (void *) _urb->urb.setup_packet;
468
469         dr->bRequestType = husb->ctrl_req;
470         dr->bRequest = 0;
471         dr->wIndex   = 0;
472         dr->wValue   = 0;
473         dr->wLength  = __cpu_to_le16(skb->len);
474
475         urb = &_urb->urb;
476         usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
477                 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
478
479         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
480         
481         _urb->priv = skb;
482         return __tx_submit(husb, _urb);
483 }
484
485 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
486 {
487         struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
488         struct urb *urb;
489         int pipe;
490
491         if (!_urb) {
492                 _urb = _urb_alloc(0, GFP_ATOMIC);
493                 if (!_urb)
494                         return -ENOMEM;
495                 _urb->type = bt_cb(skb)->pkt_type;
496         }
497
498         urb  = &_urb->urb;
499         pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
500         usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len, 
501                         hci_usb_tx_complete, husb);
502         urb->transfer_flags = URB_ZERO_PACKET;
503
504         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
505
506         _urb->priv = skb;
507         return __tx_submit(husb, _urb);
508 }
509
510 #ifdef CONFIG_BT_HCIUSB_SCO
511 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
512 {
513         struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
514         struct urb *urb;
515
516         if (!_urb) {
517                 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
518                 if (!_urb)
519                         return -ENOMEM;
520                 _urb->type = bt_cb(skb)->pkt_type;
521         }
522
523         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
524
525         urb = &_urb->urb;
526
527         urb->context  = husb;
528         urb->dev      = husb->udev;
529         urb->pipe     = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
530         urb->complete = hci_usb_tx_complete;
531         urb->transfer_flags = URB_ISO_ASAP;
532
533         urb->interval = husb->isoc_out_ep->desc.bInterval;
534
535         urb->transfer_buffer = skb->data;
536         urb->transfer_buffer_length = skb->len;
537
538         __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
539
540         _urb->priv = skb;
541         return __tx_submit(husb, _urb);
542 }
543 #endif
544
545 static void hci_usb_tx_process(struct hci_usb *husb)
546 {
547         struct sk_buff_head *q;
548         struct sk_buff *skb;
549
550         BT_DBG("%s", husb->hdev->name);
551
552         do {
553                 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
554
555                 /* Process command queue */
556                 q = __transmit_q(husb, HCI_COMMAND_PKT);
557                 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
558                                 (skb = skb_dequeue(q))) {
559                         if (hci_usb_send_ctrl(husb, skb) < 0)
560                                 skb_queue_head(q, skb);
561                 }
562
563 #ifdef CONFIG_BT_HCIUSB_SCO
564                 /* Process SCO queue */
565                 q = __transmit_q(husb, HCI_SCODATA_PKT);
566                 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
567                                 (skb = skb_dequeue(q))) {
568                         if (hci_usb_send_isoc(husb, skb) < 0)
569                                 skb_queue_head(q, skb);
570                 }
571 #endif
572
573                 /* Process ACL queue */
574                 q = __transmit_q(husb, HCI_ACLDATA_PKT);
575                 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
576                                 (skb = skb_dequeue(q))) {
577                         if (hci_usb_send_bulk(husb, skb) < 0) {
578                                 skb_queue_head(q, skb);
579                                 break;
580                         }
581                 }
582         } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
583 }
584
585 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
586 {
587         /* Serialize TX queue processing to avoid data reordering */
588         if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
589                 hci_usb_tx_process(husb);
590                 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
591         } else
592                 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
593 }
594
595 /* Send frames from HCI layer */
596 static int hci_usb_send_frame(struct sk_buff *skb)
597 {
598         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
599         struct hci_usb *husb;
600
601         if (!hdev) {
602                 BT_ERR("frame for uknown device (hdev=NULL)");
603                 return -ENODEV;
604         }
605
606         if (!test_bit(HCI_RUNNING, &hdev->flags))
607                 return -EBUSY;
608
609         BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
610
611         husb = (struct hci_usb *) hdev->driver_data;
612
613         switch (bt_cb(skb)->pkt_type) {
614         case HCI_COMMAND_PKT:
615                 hdev->stat.cmd_tx++;
616                 break;
617
618         case HCI_ACLDATA_PKT:
619                 hdev->stat.acl_tx++;
620                 break;
621
622 #ifdef CONFIG_BT_HCIUSB_SCO
623         case HCI_SCODATA_PKT:
624                 hdev->stat.sco_tx++;
625                 break;
626 #endif
627
628         default:
629                 kfree_skb(skb);
630                 return 0;
631         }
632
633         read_lock(&husb->completion_lock);
634
635         skb_queue_tail(__transmit_q(husb, bt_cb(skb)->pkt_type), skb);
636         hci_usb_tx_wakeup(husb);
637
638         read_unlock(&husb->completion_lock);
639         return 0;
640 }
641
642 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
643 {
644         BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
645
646         husb->hdev->stat.byte_rx += count;
647
648         while (count) {
649                 struct sk_buff *skb = __reassembly(husb, type);
650                 struct { int expect; } *scb;
651                 int len = 0;
652         
653                 if (!skb) {
654                         /* Start of the frame */
655
656                         switch (type) {
657                         case HCI_EVENT_PKT:
658                                 if (count >= HCI_EVENT_HDR_SIZE) {
659                                         struct hci_event_hdr *h = data;
660                                         len = HCI_EVENT_HDR_SIZE + h->plen;
661                                 } else
662                                         return -EILSEQ;
663                                 break;
664
665                         case HCI_ACLDATA_PKT:
666                                 if (count >= HCI_ACL_HDR_SIZE) {
667                                         struct hci_acl_hdr *h = data;
668                                         len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
669                                 } else
670                                         return -EILSEQ;
671                                 break;
672 #ifdef CONFIG_BT_HCIUSB_SCO
673                         case HCI_SCODATA_PKT:
674                                 if (count >= HCI_SCO_HDR_SIZE) {
675                                         struct hci_sco_hdr *h = data;
676                                         len = HCI_SCO_HDR_SIZE + h->dlen;
677                                 } else
678                                         return -EILSEQ;
679                                 break;
680 #endif
681                         }
682                         BT_DBG("new packet len %d", len);
683
684                         skb = bt_skb_alloc(len, GFP_ATOMIC);
685                         if (!skb) {
686                                 BT_ERR("%s no memory for the packet", husb->hdev->name);
687                                 return -ENOMEM;
688                         }
689                         skb->dev = (void *) husb->hdev;
690                         bt_cb(skb)->pkt_type = type;
691         
692                         __reassembly(husb, type) = skb;
693
694                         scb = (void *) skb->cb;
695                         scb->expect = len;
696                 } else {
697                         /* Continuation */
698                         scb = (void *) skb->cb;
699                         len = scb->expect;
700                 }
701
702                 len = min(len, count);
703                 
704                 memcpy(skb_put(skb, len), data, len);
705
706                 scb->expect -= len;
707                 if (!scb->expect) {
708                         /* Complete frame */
709                         __reassembly(husb, type) = NULL;
710                         bt_cb(skb)->pkt_type = type;
711                         hci_recv_frame(skb);
712                 }
713
714                 count -= len; data += len;
715         }
716         return 0;
717 }
718
719 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
720 {
721         struct _urb *_urb = container_of(urb, struct _urb, urb);
722         struct hci_usb *husb = (void *) urb->context;
723         struct hci_dev *hdev = husb->hdev;
724         int err, count = urb->actual_length;
725
726         BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
727                         _urb->type, urb->status, count, urb->transfer_flags);
728
729         read_lock(&husb->completion_lock);
730
731         if (!test_bit(HCI_RUNNING, &hdev->flags))
732                 goto unlock;
733
734         if (urb->status || !count)
735                 goto resubmit;
736
737         if (_urb->type == HCI_SCODATA_PKT) {
738 #ifdef CONFIG_BT_HCIUSB_SCO
739                 int i;
740                 for (i=0; i < urb->number_of_packets; i++) {
741                         BT_DBG("desc %d status %d offset %d len %d", i,
742                                         urb->iso_frame_desc[i].status,
743                                         urb->iso_frame_desc[i].offset,
744                                         urb->iso_frame_desc[i].actual_length);
745         
746                         if (!urb->iso_frame_desc[i].status)
747                                 __recv_frame(husb, _urb->type, 
748                                         urb->transfer_buffer + urb->iso_frame_desc[i].offset,
749                                         urb->iso_frame_desc[i].actual_length);
750                 }
751 #else
752                 ;
753 #endif
754         } else {
755                 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
756                 if (err < 0) { 
757                         BT_ERR("%s corrupted packet: type %d count %d",
758                                         husb->hdev->name, _urb->type, count);
759                         hdev->stat.err_rx++;
760                 }
761         }
762
763 resubmit:
764         urb->dev = husb->udev;
765         err = usb_submit_urb(urb, GFP_ATOMIC);
766         BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
767                         _urb->type, err);
768
769 unlock:
770         read_unlock(&husb->completion_lock);
771 }
772
773 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
774 {
775         struct _urb *_urb = container_of(urb, struct _urb, urb);
776         struct hci_usb *husb = (void *) urb->context;
777         struct hci_dev *hdev = husb->hdev;
778
779         BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
780                         urb->status, urb->transfer_flags);
781
782         atomic_dec(__pending_tx(husb, _urb->type));
783
784         urb->transfer_buffer = NULL;
785         kfree_skb((struct sk_buff *) _urb->priv);
786
787         if (!test_bit(HCI_RUNNING, &hdev->flags))
788                 return;
789
790         if (!urb->status)
791                 hdev->stat.byte_tx += urb->transfer_buffer_length;
792         else
793                 hdev->stat.err_tx++;
794
795         read_lock(&husb->completion_lock);
796
797         _urb_unlink(_urb);
798         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
799
800         hci_usb_tx_wakeup(husb);
801
802         read_unlock(&husb->completion_lock);
803 }
804
805 static void hci_usb_destruct(struct hci_dev *hdev)
806 {
807         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
808
809         BT_DBG("%s", hdev->name);
810
811         kfree(husb);
812 }
813
814 static void hci_usb_notify(struct hci_dev *hdev, unsigned int evt)
815 {
816         BT_DBG("%s evt %d", hdev->name, evt);
817 }
818
819 static int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
820 {
821         struct usb_device *udev = interface_to_usbdev(intf);
822         struct usb_host_endpoint *bulk_out_ep = NULL;
823         struct usb_host_endpoint *bulk_in_ep = NULL;
824         struct usb_host_endpoint *intr_in_ep = NULL;
825         struct usb_host_endpoint  *ep;
826         struct usb_host_interface *uif;
827         struct usb_interface *isoc_iface;
828         struct hci_usb *husb;
829         struct hci_dev *hdev;
830         int i, e, size, isoc_ifnum, isoc_alts;
831
832         BT_DBG("udev %p intf %p", udev, intf);
833
834         if (!id->driver_info) {
835                 const struct usb_device_id *match;
836                 match = usb_match_id(intf, blacklist_ids);
837                 if (match)
838                         id = match;
839         }
840
841         if (ignore || id->driver_info & HCI_IGNORE)
842                 return -ENODEV;
843
844         if (ignore_csr && id->driver_info & HCI_CSR)
845                 return -ENODEV;
846
847         if (ignore_sniffer && id->driver_info & HCI_SNIFFER)
848                 return -ENODEV;
849
850         if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
851                 return -ENODEV;
852
853         /* Find endpoints that we need */
854         uif = intf->cur_altsetting;
855         for (e = 0; e < uif->desc.bNumEndpoints; e++) {
856                 ep = &uif->endpoint[e];
857
858                 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
859                 case USB_ENDPOINT_XFER_INT:
860                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
861                                 intr_in_ep = ep;
862                         break;
863
864                 case USB_ENDPOINT_XFER_BULK:
865                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
866                                 bulk_in_ep  = ep;
867                         else
868                                 bulk_out_ep = ep;
869                         break;
870                 }
871         }
872
873         if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
874                 BT_DBG("Bulk endpoints not found");
875                 goto done;
876         }
877
878         if (!(husb = kzalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
879                 BT_ERR("Can't allocate: control structure");
880                 goto done;
881         }
882
883         husb->udev = udev;
884         husb->bulk_out_ep = bulk_out_ep;
885         husb->bulk_in_ep  = bulk_in_ep;
886         husb->intr_in_ep  = intr_in_ep;
887
888         if (id->driver_info & HCI_DIGIANSWER)
889                 husb->ctrl_req = USB_TYPE_VENDOR;
890         else
891                 husb->ctrl_req = USB_TYPE_CLASS;
892
893         /* Find isochronous endpoints that we can use */
894         size = 0; 
895         isoc_iface = NULL;
896         isoc_alts  = 0;
897         isoc_ifnum = 1;
898
899 #ifdef CONFIG_BT_HCIUSB_SCO
900         if (isoc && !(id->driver_info & (HCI_BROKEN_ISOC | HCI_SNIFFER)))
901                 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
902
903         if (isoc_iface) {
904                 int a;
905                 struct usb_host_endpoint *isoc_out_ep = NULL;
906                 struct usb_host_endpoint *isoc_in_ep = NULL;
907
908                 for (a = 0; a < isoc_iface->num_altsetting; a++) {
909                         uif = &isoc_iface->altsetting[a];
910                         for (e = 0; e < uif->desc.bNumEndpoints; e++) {
911                                 ep = &uif->endpoint[e];
912
913                                 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
914                                 case USB_ENDPOINT_XFER_ISOC:
915                                         if (le16_to_cpu(ep->desc.wMaxPacketSize) < size ||
916                                                         uif->desc.bAlternateSetting != isoc)
917                                                 break;
918                                         size = le16_to_cpu(ep->desc.wMaxPacketSize);
919
920                                         isoc_alts = uif->desc.bAlternateSetting;
921
922                                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
923                                                 isoc_in_ep  = ep;
924                                         else
925                                                 isoc_out_ep = ep;
926                                         break;
927                                 }
928                         }
929                 }
930
931                 if (!isoc_in_ep || !isoc_out_ep)
932                         BT_DBG("Isoc endpoints not found");
933                 else {
934                         BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
935                         if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
936                                 BT_ERR("Can't claim isoc interface");
937                         else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
938                                 BT_ERR("Can't set isoc interface settings");
939                                 husb->isoc_iface = isoc_iface;
940                                 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
941                                 husb->isoc_iface = NULL;
942                         } else {
943                                 husb->isoc_iface  = isoc_iface;
944                                 husb->isoc_in_ep  = isoc_in_ep;
945                                 husb->isoc_out_ep = isoc_out_ep;
946                         }
947                 }
948         }
949 #endif
950
951         rwlock_init(&husb->completion_lock);
952
953         for (i = 0; i < 4; i++) {
954                 skb_queue_head_init(&husb->transmit_q[i]);
955                 _urb_queue_init(&husb->pending_q[i]);
956                 _urb_queue_init(&husb->completed_q[i]);
957         }
958
959         /* Initialize and register HCI device */
960         hdev = hci_alloc_dev();
961         if (!hdev) {
962                 BT_ERR("Can't allocate HCI device");
963                 goto probe_error;
964         }
965
966         husb->hdev = hdev;
967
968         hdev->type = HCI_USB;
969         hdev->driver_data = husb;
970         SET_HCIDEV_DEV(hdev, &intf->dev);
971
972         hdev->open     = hci_usb_open;
973         hdev->close    = hci_usb_close;
974         hdev->flush    = hci_usb_flush;
975         hdev->send     = hci_usb_send_frame;
976         hdev->destruct = hci_usb_destruct;
977         hdev->notify   = hci_usb_notify;
978
979         hdev->owner = THIS_MODULE;
980
981         if (reset || id->driver_info & HCI_RESET)
982                 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
983
984         if (id->driver_info & HCI_SNIFFER) {
985                 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
986                         set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
987         }
988
989         if (id->driver_info & HCI_BCM92035) {
990                 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
991                 struct sk_buff *skb;
992
993                 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
994                 if (skb) {
995                         memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
996                         skb_queue_tail(&hdev->driver_init, skb);
997                 }
998         }
999
1000         if (hci_register_dev(hdev) < 0) {
1001                 BT_ERR("Can't register HCI device");
1002                 hci_free_dev(hdev);
1003                 goto probe_error;
1004         }
1005
1006         usb_set_intfdata(intf, husb);
1007         return 0;
1008
1009 probe_error:
1010         if (husb->isoc_iface)
1011                 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1012         kfree(husb);
1013
1014 done:
1015         return -EIO;
1016 }
1017
1018 static void hci_usb_disconnect(struct usb_interface *intf)
1019 {
1020         struct hci_usb *husb = usb_get_intfdata(intf);
1021         struct hci_dev *hdev;
1022
1023         if (!husb || intf == husb->isoc_iface)
1024                 return;
1025
1026         usb_set_intfdata(intf, NULL);
1027         hdev = husb->hdev;
1028
1029         BT_DBG("%s", hdev->name);
1030
1031         hci_usb_close(hdev);
1032
1033         if (husb->isoc_iface)
1034                 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1035
1036         if (hci_unregister_dev(hdev) < 0)
1037                 BT_ERR("Can't unregister HCI device %s", hdev->name);
1038
1039         hci_free_dev(hdev);
1040 }
1041
1042 static struct usb_driver hci_usb_driver = {
1043         .owner          = THIS_MODULE,
1044         .name           = "hci_usb",
1045         .probe          = hci_usb_probe,
1046         .disconnect     = hci_usb_disconnect,
1047         .id_table       = bluetooth_ids,
1048 };
1049
1050 static int __init hci_usb_init(void)
1051 {
1052         int err;
1053
1054         BT_INFO("HCI USB driver ver %s", VERSION);
1055
1056         if ((err = usb_register(&hci_usb_driver)) < 0)
1057                 BT_ERR("Failed to register HCI USB driver");
1058
1059         return err;
1060 }
1061
1062 static void __exit hci_usb_exit(void)
1063 {
1064         usb_deregister(&hci_usb_driver);
1065 }
1066
1067 module_init(hci_usb_init);
1068 module_exit(hci_usb_exit);
1069
1070 module_param(ignore, bool, 0644);
1071 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
1072
1073 module_param(ignore_csr, bool, 0644);
1074 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1075
1076 module_param(ignore_sniffer, bool, 0644);
1077 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1078
1079 module_param(reset, bool, 0644);
1080 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1081
1082 #ifdef CONFIG_BT_HCIUSB_SCO
1083 module_param(isoc, int, 0644);
1084 MODULE_PARM_DESC(isoc, "Set isochronous transfers for SCO over HCI support");
1085 #endif
1086
1087 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1088 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1089 MODULE_VERSION(VERSION);
1090 MODULE_LICENSE("GPL");