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