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