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