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