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