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