?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
init from v2.6.32.60
[mach-moxart.git] / drivers / bluetooth / btusb.c
bloba562761ff19750bde184ffd5d1c3946199f5cedf
1 /*
2 *
3 * Generic Bluetooth USB driver
4 *
5 * Copyright (C) 2005-2008 Marcel Holtmann <marcel@holtmann.org>
6 *
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 as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/types.h>
29 #include <linux/sched.h>
30 #include <linux/errno.h>
31 #include <linux/skbuff.h>
32
33 #include <linux/usb.h>
34
35 #include <net/bluetooth/bluetooth.h>
36 #include <net/bluetooth/hci_core.h>
37
38 #define VERSION "0.6"
39
40 static int ignore_dga;
41 static int ignore_csr;
42 static int ignore_sniffer;
43 static int disable_scofix;
44 static int force_scofix;
45
46 static int reset = 1;
47
48 static struct usb_driver btusb_driver;
49
50 #define BTUSB_IGNORE 0x01
51 #define BTUSB_DIGIANSWER 0x02
52 #define BTUSB_CSR 0x04
53 #define BTUSB_SNIFFER 0x08
54 #define BTUSB_BCM92035 0x10
55 #define BTUSB_BROKEN_ISOC 0x20
56 #define BTUSB_WRONG_SCO_MTU 0x40
57
58 static struct usb_device_id btusb_table[] = {
59 /* Generic Bluetooth USB device */
60 { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
61
62 /* Apple MacBookPro 7,1 */
63 { USB_DEVICE(0x05ac, 0x8213) },
64
65 /* Apple iMac11,1 */
66 { USB_DEVICE(0x05ac, 0x8215) },
67
68 /* Apple MacBookPro6,2 */
69 { USB_DEVICE(0x05ac, 0x8218) },
70
71 /* Apple MacBookAir3,1, MacBookAir3,2 */
72 { USB_DEVICE(0x05ac, 0x821b) },
73
74 /* Apple MacBookPro8,2 */
75 { USB_DEVICE(0x05ac, 0x821a) },
76
77 /* AVM BlueFRITZ! USB v2.0 */
78 { USB_DEVICE(0x057c, 0x3800) },
79
80 /* Bluetooth Ultraport Module from IBM */
81 { USB_DEVICE(0x04bf, 0x030a) },
82
83 /* ALPS Modules with non-standard id */
84 { USB_DEVICE(0x044e, 0x3001) },
85 { USB_DEVICE(0x044e, 0x3002) },
86
87 /* Ericsson with non-standard id */
88 { USB_DEVICE(0x0bdb, 0x1002) },
89
90 /* Canyon CN-BTU1 with HID interfaces */
91 { USB_DEVICE(0x0c10, 0x0000) },
92
93 { } /* Terminating entry */
94 };
95
96 MODULE_DEVICE_TABLE(usb, btusb_table);
97
98 static struct usb_device_id blacklist_table[] = {
99 /* CSR BlueCore devices */
100 { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
101
102 /* Broadcom BCM2033 without firmware */
103 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
104
105 /* Broadcom BCM2035 */
106 { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
107 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
108 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
109
110 /* Broadcom BCM2045 */
111 { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
112 { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
113
114 /* IBM/Lenovo ThinkPad with Broadcom chip */
115 { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
116 { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
117
118 /* HP laptop with Broadcom chip */
119 { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
120
121 /* Dell laptop with Broadcom chip */
122 { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
123
124 /* Dell Wireless 370 and 410 devices */
125 { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
126 { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
127
128 /* Belkin F8T012 and F8T013 devices */
129 { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
130 { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
131
132 /* Asus WL-BTD202 device */
133 { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
134
135 /* Kensington Bluetooth USB adapter */
136 { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
137
138 /* RTX Telecom based adapters with buggy SCO support */
139 { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
140 { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
141
142 /* CONWISE Technology based adapters with buggy SCO support */
143 { USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },
144
145 /* Digianswer devices */
146 { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
147 { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
148
149 /* CSR BlueCore Bluetooth Sniffer */
150 { USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },
151
152 /* Frontline ComProbe Bluetooth Sniffer */
153 { USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },
154
155 { } /* Terminating entry */
156 };
157
158 #define BTUSB_MAX_ISOC_FRAMES 10
159
160 #define BTUSB_INTR_RUNNING 0
161 #define BTUSB_BULK_RUNNING 1
162 #define BTUSB_ISOC_RUNNING 2
163 #define BTUSB_SUSPENDING 3
164
165 struct btusb_data {
166 struct hci_dev *hdev;
167 struct usb_device *udev;
168 struct usb_interface *intf;
169 struct usb_interface *isoc;
170
171 spinlock_t lock;
172
173 unsigned long flags;
174
175 struct work_struct work;
176 struct work_struct waker;
177
178 struct usb_anchor tx_anchor;
179 struct usb_anchor intr_anchor;
180 struct usb_anchor bulk_anchor;
181 struct usb_anchor isoc_anchor;
182 struct usb_anchor deferred;
183 int tx_in_flight;
184 spinlock_t txlock;
185
186 struct usb_endpoint_descriptor *intr_ep;
187 struct usb_endpoint_descriptor *bulk_tx_ep;
188 struct usb_endpoint_descriptor *bulk_rx_ep;
189 struct usb_endpoint_descriptor *isoc_tx_ep;
190 struct usb_endpoint_descriptor *isoc_rx_ep;
191
192 __u8 cmdreq_type;
193
194 unsigned int sco_num;
195 int isoc_altsetting;
196 int suspend_count;
197 int did_iso_resume:1;
198 };
199
200 static int inc_tx(struct btusb_data *data)
201 {
202 unsigned long flags;
203 int rv;
204
205 spin_lock_irqsave(&data->txlock, flags);
206 rv = test_bit(BTUSB_SUSPENDING, &data->flags);
207 if (!rv)
208 data->tx_in_flight++;
209 spin_unlock_irqrestore(&data->txlock, flags);
210
211 return rv;
212 }
213
214 static void btusb_intr_complete(struct urb *urb)
215 {
216 struct hci_dev *hdev = urb->context;
217 struct btusb_data *data = hdev->driver_data;
218 int err;
219
220 BT_DBG("%s urb %p status %d count %d", hdev->name,
221 urb, urb->status, urb->actual_length);
222
223 if (!test_bit(HCI_RUNNING, &hdev->flags))
224 return;
225
226 if (urb->status == 0) {
227 hdev->stat.byte_rx += urb->actual_length;
228
229 if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
230 urb->transfer_buffer,
231 urb->actual_length) < 0) {
232 BT_ERR("%s corrupted event packet", hdev->name);
233 hdev->stat.err_rx++;
234 }
235 }
236
237 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
238 return;
239
240 usb_mark_last_busy(data->udev);
241 usb_anchor_urb(urb, &data->intr_anchor);
242
243 err = usb_submit_urb(urb, GFP_ATOMIC);
244 if (err < 0) {
245 BT_ERR("%s urb %p failed to resubmit (%d)",
246 hdev->name, urb, -err);
247 usb_unanchor_urb(urb);
248 }
249 }
250
251 static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
252 {
253 struct btusb_data *data = hdev->driver_data;
254 struct urb *urb;
255 unsigned char *buf;
256 unsigned int pipe;
257 int err, size;
258
259 BT_DBG("%s", hdev->name);
260
261 if (!data->intr_ep)
262 return -ENODEV;
263
264 urb = usb_alloc_urb(0, mem_flags);
265 if (!urb)
266 return -ENOMEM;
267
268 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
269
270 buf = kmalloc(size, mem_flags);
271 if (!buf) {
272 usb_free_urb(urb);
273 return -ENOMEM;
274 }
275
276 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
277
278 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
279 btusb_intr_complete, hdev,
280 data->intr_ep->bInterval);
281
282 urb->transfer_flags |= URB_FREE_BUFFER;
283
284 usb_anchor_urb(urb, &data->intr_anchor);
285
286 err = usb_submit_urb(urb, mem_flags);
287 if (err < 0) {
288 BT_ERR("%s urb %p submission failed (%d)",
289 hdev->name, urb, -err);
290 usb_unanchor_urb(urb);
291 }
292
293 usb_free_urb(urb);
294
295 return err;
296 }
297
298 static void btusb_bulk_complete(struct urb *urb)
299 {
300 struct hci_dev *hdev = urb->context;
301 struct btusb_data *data = hdev->driver_data;
302 int err;
303
304 BT_DBG("%s urb %p status %d count %d", hdev->name,
305 urb, urb->status, urb->actual_length);
306
307 if (!test_bit(HCI_RUNNING, &hdev->flags))
308 return;
309
310 if (urb->status == 0) {
311 hdev->stat.byte_rx += urb->actual_length;
312
313 if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
314 urb->transfer_buffer,
315 urb->actual_length) < 0) {
316 BT_ERR("%s corrupted ACL packet", hdev->name);
317 hdev->stat.err_rx++;
318 }
319 }
320
321 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
322 return;
323
324 usb_anchor_urb(urb, &data->bulk_anchor);
325 usb_mark_last_busy(data->udev);
326
327 err = usb_submit_urb(urb, GFP_ATOMIC);
328 if (err < 0) {
329 BT_ERR("%s urb %p failed to resubmit (%d)",
330 hdev->name, urb, -err);
331 usb_unanchor_urb(urb);
332 }
333 }
334
335 static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
336 {
337 struct btusb_data *data = hdev->driver_data;
338 struct urb *urb;
339 unsigned char *buf;
340 unsigned int pipe;
341 int err, size = HCI_MAX_FRAME_SIZE;
342
343 BT_DBG("%s", hdev->name);
344
345 if (!data->bulk_rx_ep)
346 return -ENODEV;
347
348 urb = usb_alloc_urb(0, mem_flags);
349 if (!urb)
350 return -ENOMEM;
351
352 buf = kmalloc(size, mem_flags);
353 if (!buf) {
354 usb_free_urb(urb);
355 return -ENOMEM;
356 }
357
358 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
359
360 usb_fill_bulk_urb(urb, data->udev, pipe,
361 buf, size, btusb_bulk_complete, hdev);
362
363 urb->transfer_flags |= URB_FREE_BUFFER;
364
365 usb_mark_last_busy(data->udev);
366 usb_anchor_urb(urb, &data->bulk_anchor);
367
368 err = usb_submit_urb(urb, mem_flags);
369 if (err < 0) {
370 BT_ERR("%s urb %p submission failed (%d)",
371 hdev->name, urb, -err);
372 usb_unanchor_urb(urb);
373 }
374
375 usb_free_urb(urb);
376
377 return err;
378 }
379
380 static void btusb_isoc_complete(struct urb *urb)
381 {
382 struct hci_dev *hdev = urb->context;
383 struct btusb_data *data = hdev->driver_data;
384 int i, err;
385
386 BT_DBG("%s urb %p status %d count %d", hdev->name,
387 urb, urb->status, urb->actual_length);
388
389 if (!test_bit(HCI_RUNNING, &hdev->flags))
390 return;
391
392 if (urb->status == 0) {
393 for (i = 0; i < urb->number_of_packets; i++) {
394 unsigned int offset = urb->iso_frame_desc[i].offset;
395 unsigned int length = urb->iso_frame_desc[i].actual_length;
396
397 if (urb->iso_frame_desc[i].status)
398 continue;
399
400 hdev->stat.byte_rx += length;
401
402 if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
403 urb->transfer_buffer + offset,
404 length) < 0) {
405 BT_ERR("%s corrupted SCO packet", hdev->name);
406 hdev->stat.err_rx++;
407 }
408 }
409 }
410
411 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
412 return;
413
414 usb_anchor_urb(urb, &data->isoc_anchor);
415
416 err = usb_submit_urb(urb, GFP_ATOMIC);
417 if (err < 0) {
418 BT_ERR("%s urb %p failed to resubmit (%d)",
419 hdev->name, urb, -err);
420 usb_unanchor_urb(urb);
421 }
422 }
423
424 static void inline __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
425 {
426 int i, offset = 0;
427
428 BT_DBG("len %d mtu %d", len, mtu);
429
430 for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
431 i++, offset += mtu, len -= mtu) {
432 urb->iso_frame_desc[i].offset = offset;
433 urb->iso_frame_desc[i].length = mtu;
434 }
435
436 if (len && i < BTUSB_MAX_ISOC_FRAMES) {
437 urb->iso_frame_desc[i].offset = offset;
438 urb->iso_frame_desc[i].length = len;
439 i++;
440 }
441
442 urb->number_of_packets = i;
443 }
444
445 static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
446 {
447 struct btusb_data *data = hdev->driver_data;
448 struct urb *urb;
449 unsigned char *buf;
450 unsigned int pipe;
451 int err, size;
452
453 BT_DBG("%s", hdev->name);
454
455 if (!data->isoc_rx_ep)
456 return -ENODEV;
457
458 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
459 if (!urb)
460 return -ENOMEM;
461
462 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
463 BTUSB_MAX_ISOC_FRAMES;
464
465 buf = kmalloc(size, mem_flags);
466 if (!buf) {
467 usb_free_urb(urb);
468 return -ENOMEM;
469 }
470
471 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
472
473 usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
474 hdev, data->isoc_rx_ep->bInterval);
475
476 urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
477
478 __fill_isoc_descriptor(urb, size,
479 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
480
481 usb_anchor_urb(urb, &data->isoc_anchor);
482
483 err = usb_submit_urb(urb, mem_flags);
484 if (err < 0) {
485 BT_ERR("%s urb %p submission failed (%d)",
486 hdev->name, urb, -err);
487 usb_unanchor_urb(urb);
488 }
489
490 usb_free_urb(urb);
491
492 return err;
493 }
494
495 static void btusb_tx_complete(struct urb *urb)
496 {
497 struct sk_buff *skb = urb->context;
498 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
499 struct btusb_data *data = hdev->driver_data;
500
501 BT_DBG("%s urb %p status %d count %d", hdev->name,
502 urb, urb->status, urb->actual_length);
503
504 if (!test_bit(HCI_RUNNING, &hdev->flags))
505 goto done;
506
507 if (!urb->status)
508 hdev->stat.byte_tx += urb->transfer_buffer_length;
509 else
510 hdev->stat.err_tx++;
511
512 done:
513 spin_lock(&data->txlock);
514 data->tx_in_flight--;
515 spin_unlock(&data->txlock);
516
517 kfree(urb->setup_packet);
518
519 kfree_skb(skb);
520 }
521
522 static void btusb_isoc_tx_complete(struct urb *urb)
523 {
524 struct sk_buff *skb = urb->context;
525 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
526
527 BT_DBG("%s urb %p status %d count %d", hdev->name,
528 urb, urb->status, urb->actual_length);
529
530 if (!test_bit(HCI_RUNNING, &hdev->flags))
531 goto done;
532
533 if (!urb->status)
534 hdev->stat.byte_tx += urb->transfer_buffer_length;
535 else
536 hdev->stat.err_tx++;
537
538 done:
539 kfree(urb->setup_packet);
540
541 kfree_skb(skb);
542 }
543
544 static int btusb_open(struct hci_dev *hdev)
545 {
546 struct btusb_data *data = hdev->driver_data;
547 int err;
548
549 BT_DBG("%s", hdev->name);
550
551 err = usb_autopm_get_interface(data->intf);
552 if (err < 0)
553 return err;
554
555 data->intf->needs_remote_wakeup = 1;
556
557 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
558 goto done;
559
560 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
561 goto done;
562
563 err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
564 if (err < 0)
565 goto failed;
566
567 err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
568 if (err < 0) {
569 usb_kill_anchored_urbs(&data->intr_anchor);
570 goto failed;
571 }
572
573 set_bit(BTUSB_BULK_RUNNING, &data->flags);
574 btusb_submit_bulk_urb(hdev, GFP_KERNEL);
575
576 done:
577 usb_autopm_put_interface(data->intf);
578 return 0;
579
580 failed:
581 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
582 clear_bit(HCI_RUNNING, &hdev->flags);
583 usb_autopm_put_interface(data->intf);
584 return err;
585 }
586
587 static void btusb_stop_traffic(struct btusb_data *data)
588 {
589 usb_kill_anchored_urbs(&data->intr_anchor);
590 usb_kill_anchored_urbs(&data->bulk_anchor);
591 usb_kill_anchored_urbs(&data->isoc_anchor);
592 }
593
594 static int btusb_close(struct hci_dev *hdev)
595 {
596 struct btusb_data *data = hdev->driver_data;
597 int err;
598
599 BT_DBG("%s", hdev->name);
600
601 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
602 return 0;
603
604 cancel_work_sync(&data->work);
605 cancel_work_sync(&data->waker);
606
607 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
608 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
609 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
610
611 btusb_stop_traffic(data);
612 err = usb_autopm_get_interface(data->intf);
613 if (err < 0)
614 goto failed;
615
616 data->intf->needs_remote_wakeup = 0;
617 usb_autopm_put_interface(data->intf);
618
619 failed:
620 usb_scuttle_anchored_urbs(&data->deferred);
621 return 0;
622 }
623
624 static int btusb_flush(struct hci_dev *hdev)
625 {
626 struct btusb_data *data = hdev->driver_data;
627
628 BT_DBG("%s", hdev->name);
629
630 usb_kill_anchored_urbs(&data->tx_anchor);
631
632 return 0;
633 }
634
635 static int btusb_send_frame(struct sk_buff *skb)
636 {
637 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
638 struct btusb_data *data = hdev->driver_data;
639 struct usb_ctrlrequest *dr;
640 struct urb *urb;
641 unsigned int pipe;
642 int err;
643
644 BT_DBG("%s", hdev->name);
645
646 if (!test_bit(HCI_RUNNING, &hdev->flags))
647 return -EBUSY;
648
649 switch (bt_cb(skb)->pkt_type) {
650 case HCI_COMMAND_PKT:
651 urb = usb_alloc_urb(0, GFP_ATOMIC);
652 if (!urb)
653 return -ENOMEM;
654
655 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
656 if (!dr) {
657 usb_free_urb(urb);
658 return -ENOMEM;
659 }
660
661 dr->bRequestType = data->cmdreq_type;
662 dr->bRequest = 0;
663 dr->wIndex = 0;
664 dr->wValue = 0;
665 dr->wLength = __cpu_to_le16(skb->len);
666
667 pipe = usb_sndctrlpipe(data->udev, 0x00);
668
669 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
670 skb->data, skb->len, btusb_tx_complete, skb);
671
672 hdev->stat.cmd_tx++;
673 break;
674
675 case HCI_ACLDATA_PKT:
676 if (!data->bulk_tx_ep || hdev->conn_hash.acl_num < 1)
677 return -ENODEV;
678
679 urb = usb_alloc_urb(0, GFP_ATOMIC);
680 if (!urb)
681 return -ENOMEM;
682
683 pipe = usb_sndbulkpipe(data->udev,
684 data->bulk_tx_ep->bEndpointAddress);
685
686 usb_fill_bulk_urb(urb, data->udev, pipe,
687 skb->data, skb->len, btusb_tx_complete, skb);
688
689 hdev->stat.acl_tx++;
690 break;
691
692 case HCI_SCODATA_PKT:
693 if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)
694 return -ENODEV;
695
696 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
697 if (!urb)
698 return -ENOMEM;
699
700 pipe = usb_sndisocpipe(data->udev,
701 data->isoc_tx_ep->bEndpointAddress);
702
703 urb->dev = data->udev;
704 urb->pipe = pipe;
705 urb->context = skb;
706 urb->complete = btusb_isoc_tx_complete;
707 urb->interval = data->isoc_tx_ep->bInterval;
708
709 urb->transfer_flags = URB_ISO_ASAP;
710 urb->transfer_buffer = skb->data;
711 urb->transfer_buffer_length = skb->len;
712
713 __fill_isoc_descriptor(urb, skb->len,
714 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
715
716 hdev->stat.sco_tx++;
717 goto skip_waking;
718
719 default:
720 return -EILSEQ;
721 }
722
723 err = inc_tx(data);
724 if (err) {
725 usb_anchor_urb(urb, &data->deferred);
726 schedule_work(&data->waker);
727 err = 0;
728 goto done;
729 }
730
731 skip_waking:
732 usb_anchor_urb(urb, &data->tx_anchor);
733
734 err = usb_submit_urb(urb, GFP_ATOMIC);
735 if (err < 0) {
736 BT_ERR("%s urb %p submission failed", hdev->name, urb);
737 kfree(urb->setup_packet);
738 usb_unanchor_urb(urb);
739 } else {
740 usb_mark_last_busy(data->udev);
741 }
742
743 usb_free_urb(urb);
744
745 done:
746 return err;
747 }
748
749 static void btusb_destruct(struct hci_dev *hdev)
750 {
751 struct btusb_data *data = hdev->driver_data;
752
753 BT_DBG("%s", hdev->name);
754
755 kfree(data);
756 }
757
758 static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
759 {
760 struct btusb_data *data = hdev->driver_data;
761
762 BT_DBG("%s evt %d", hdev->name, evt);
763
764 if (hdev->conn_hash.sco_num != data->sco_num) {
765 data->sco_num = hdev->conn_hash.sco_num;
766 schedule_work(&data->work);
767 }
768 }
769
770 static int inline __set_isoc_interface(struct hci_dev *hdev, int altsetting)
771 {
772 struct btusb_data *data = hdev->driver_data;
773 struct usb_interface *intf = data->isoc;
774 struct usb_endpoint_descriptor *ep_desc;
775 int i, err;
776
777 if (!data->isoc)
778 return -ENODEV;
779
780 err = usb_set_interface(data->udev, 1, altsetting);
781 if (err < 0) {
782 BT_ERR("%s setting interface failed (%d)", hdev->name, -err);
783 return err;
784 }
785
786 data->isoc_altsetting = altsetting;
787
788 data->isoc_tx_ep = NULL;
789 data->isoc_rx_ep = NULL;
790
791 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
792 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
793
794 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
795 data->isoc_tx_ep = ep_desc;
796 continue;
797 }
798
799 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
800 data->isoc_rx_ep = ep_desc;
801 continue;
802 }
803 }
804
805 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
806 BT_ERR("%s invalid SCO descriptors", hdev->name);
807 return -ENODEV;
808 }
809
810 return 0;
811 }
812
813 static void btusb_work(struct work_struct *work)
814 {
815 struct btusb_data *data = container_of(work, struct btusb_data, work);
816 struct hci_dev *hdev = data->hdev;
817 int err;
818
819 if (hdev->conn_hash.sco_num > 0) {
820 if (!data->did_iso_resume) {
821 err = usb_autopm_get_interface(data->isoc);
822 if (err < 0) {
823 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
824 usb_kill_anchored_urbs(&data->isoc_anchor);
825 return;
826 }
827
828 data->did_iso_resume = 1;
829 }
830 if (data->isoc_altsetting != 2) {
831 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
832 usb_kill_anchored_urbs(&data->isoc_anchor);
833
834 if (__set_isoc_interface(hdev, 2) < 0)
835 return;
836 }
837
838 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
839 if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
840 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
841 else
842 btusb_submit_isoc_urb(hdev, GFP_KERNEL);
843 }
844 } else {
845 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
846 usb_kill_anchored_urbs(&data->isoc_anchor);
847
848 __set_isoc_interface(hdev, 0);
849 if (data->did_iso_resume) {
850 data->did_iso_resume = 0;
851 usb_autopm_put_interface(data->isoc);
852 }
853 }
854 }
855
856 static void btusb_waker(struct work_struct *work)
857 {
858 struct btusb_data *data = container_of(work, struct btusb_data, waker);
859 int err;
860
861 err = usb_autopm_get_interface(data->intf);
862 if (err < 0)
863 return;
864
865 usb_autopm_put_interface(data->intf);
866 }
867
868 static int btusb_probe(struct usb_interface *intf,
869 const struct usb_device_id *id)
870 {
871 struct usb_endpoint_descriptor *ep_desc;
872 struct btusb_data *data;
873 struct hci_dev *hdev;
874 int i, err;
875
876 BT_DBG("intf %p id %p", intf, id);
877
878 /* interface numbers are hardcoded in the spec */
879 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
880 return -ENODEV;
881
882 if (!id->driver_info) {
883 const struct usb_device_id *match;
884 match = usb_match_id(intf, blacklist_table);
885 if (match)
886 id = match;
887 }
888
889 if (id->driver_info == BTUSB_IGNORE)
890 return -ENODEV;
891
892 if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)
893 return -ENODEV;
894
895 if (ignore_csr && id->driver_info & BTUSB_CSR)
896 return -ENODEV;
897
898 if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)
899 return -ENODEV;
900
901 data = kzalloc(sizeof(*data), GFP_KERNEL);
902 if (!data)
903 return -ENOMEM;
904
905 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
906 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
907
908 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
909 data->intr_ep = ep_desc;
910 continue;
911 }
912
913 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
914 data->bulk_tx_ep = ep_desc;
915 continue;
916 }
917
918 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
919 data->bulk_rx_ep = ep_desc;
920 continue;
921 }
922 }
923
924 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {
925 kfree(data);
926 return -ENODEV;
927 }
928
929 data->cmdreq_type = USB_TYPE_CLASS;
930
931 data->udev = interface_to_usbdev(intf);
932 data->intf = intf;
933
934 spin_lock_init(&data->lock);
935
936 INIT_WORK(&data->work, btusb_work);
937 INIT_WORK(&data->waker, btusb_waker);
938 spin_lock_init(&data->txlock);
939
940 init_usb_anchor(&data->tx_anchor);
941 init_usb_anchor(&data->intr_anchor);
942 init_usb_anchor(&data->bulk_anchor);
943 init_usb_anchor(&data->isoc_anchor);
944 init_usb_anchor(&data->deferred);
945
946 hdev = hci_alloc_dev();
947 if (!hdev) {
948 kfree(data);
949 return -ENOMEM;
950 }
951
952 hdev->type = HCI_USB;
953 hdev->driver_data = data;
954
955 data->hdev = hdev;
956
957 SET_HCIDEV_DEV(hdev, &intf->dev);
958
959 hdev->open = btusb_open;
960 hdev->close = btusb_close;
961 hdev->flush = btusb_flush;
962 hdev->send = btusb_send_frame;
963 hdev->destruct = btusb_destruct;
964 hdev->notify = btusb_notify;
965
966 hdev->owner = THIS_MODULE;
967
968 /* Interface numbers are hardcoded in the specification */
969 data->isoc = usb_ifnum_to_if(data->udev, 1);
970
971 if (!reset)
972 set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
973
974 if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
975 if (!disable_scofix)
976 set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
977 }
978
979 if (id->driver_info & BTUSB_BROKEN_ISOC)
980 data->isoc = NULL;
981
982 if (id->driver_info & BTUSB_DIGIANSWER) {
983 data->cmdreq_type = USB_TYPE_VENDOR;
984 set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
985 }
986
987 if (id->driver_info & BTUSB_CSR) {
988 struct usb_device *udev = data->udev;
989
990 /* Old firmware would otherwise execute USB reset */
991 if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)
992 set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
993 }
994
995 if (id->driver_info & BTUSB_SNIFFER) {
996 struct usb_device *udev = data->udev;
997
998 /* New sniffer firmware has crippled HCI interface */
999 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
1000 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
1001
1002 data->isoc = NULL;
1003 }
1004
1005 if (id->driver_info & BTUSB_BCM92035) {
1006 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
1007 struct sk_buff *skb;
1008
1009 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1010 if (skb) {
1011 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1012 skb_queue_tail(&hdev->driver_init, skb);
1013 }
1014 }
1015
1016 if (data->isoc) {
1017 err = usb_driver_claim_interface(&btusb_driver,
1018 data->isoc, data);
1019 if (err < 0) {
1020 hci_free_dev(hdev);
1021 kfree(data);
1022 return err;
1023 }
1024 }
1025
1026 err = hci_register_dev(hdev);
1027 if (err < 0) {
1028 hci_free_dev(hdev);
1029 kfree(data);
1030 return err;
1031 }
1032
1033 usb_set_intfdata(intf, data);
1034
1035 return 0;
1036 }
1037
1038 static void btusb_disconnect(struct usb_interface *intf)
1039 {
1040 struct btusb_data *data = usb_get_intfdata(intf);
1041 struct hci_dev *hdev;
1042
1043 BT_DBG("intf %p", intf);
1044
1045 if (!data)
1046 return;
1047
1048 hdev = data->hdev;
1049
1050 __hci_dev_hold(hdev);
1051
1052 usb_set_intfdata(data->intf, NULL);
1053
1054 if (data->isoc)
1055 usb_set_intfdata(data->isoc, NULL);
1056
1057 hci_unregister_dev(hdev);
1058
1059 if (intf == data->isoc)
1060 usb_driver_release_interface(&btusb_driver, data->intf);
1061 else if (data->isoc)
1062 usb_driver_release_interface(&btusb_driver, data->isoc);
1063
1064 __hci_dev_put(hdev);
1065
1066 hci_free_dev(hdev);
1067 }
1068
1069 #ifdef CONFIG_PM
1070 static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
1071 {
1072 struct btusb_data *data = usb_get_intfdata(intf);
1073
1074 BT_DBG("intf %p", intf);
1075
1076 if (data->suspend_count++)
1077 return 0;
1078
1079 spin_lock_irq(&data->txlock);
1080 if (!(interface_to_usbdev(intf)->auto_pm && data->tx_in_flight)) {
1081 set_bit(BTUSB_SUSPENDING, &data->flags);
1082 spin_unlock_irq(&data->txlock);
1083 } else {
1084 spin_unlock_irq(&data->txlock);
1085 data->suspend_count--;
1086 return -EBUSY;
1087 }
1088
1089 cancel_work_sync(&data->work);
1090
1091 btusb_stop_traffic(data);
1092 usb_kill_anchored_urbs(&data->tx_anchor);
1093
1094 return 0;
1095 }
1096
1097 static void play_deferred(struct btusb_data *data)
1098 {
1099 struct urb *urb;
1100 int err;
1101
1102 while ((urb = usb_get_from_anchor(&data->deferred))) {
1103 err = usb_submit_urb(urb, GFP_ATOMIC);
1104 if (err < 0)
1105 break;
1106
1107 data->tx_in_flight++;
1108 }
1109 usb_scuttle_anchored_urbs(&data->deferred);
1110 }
1111
1112 static int btusb_resume(struct usb_interface *intf)
1113 {
1114 struct btusb_data *data = usb_get_intfdata(intf);
1115 struct hci_dev *hdev = data->hdev;
1116 int err = 0;
1117
1118 BT_DBG("intf %p", intf);
1119
1120 if (--data->suspend_count)
1121 return 0;
1122
1123 if (!test_bit(HCI_RUNNING, &hdev->flags))
1124 goto done;
1125
1126 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
1127 err = btusb_submit_intr_urb(hdev, GFP_NOIO);
1128 if (err < 0) {
1129 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1130 goto failed;
1131 }
1132 }
1133
1134 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
1135 err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
1136 if (err < 0) {
1137 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
1138 goto failed;
1139 }
1140
1141 btusb_submit_bulk_urb(hdev, GFP_NOIO);
1142 }
1143
1144 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1145 if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
1146 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1147 else
1148 btusb_submit_isoc_urb(hdev, GFP_NOIO);
1149 }
1150
1151 spin_lock_irq(&data->txlock);
1152 play_deferred(data);
1153 clear_bit(BTUSB_SUSPENDING, &data->flags);
1154 spin_unlock_irq(&data->txlock);
1155 schedule_work(&data->work);
1156
1157 return 0;
1158
1159 failed:
1160 usb_scuttle_anchored_urbs(&data->deferred);
1161 done:
1162 spin_lock_irq(&data->txlock);
1163 clear_bit(BTUSB_SUSPENDING, &data->flags);
1164 spin_unlock_irq(&data->txlock);
1165
1166 return err;
1167 }
1168 #endif
1169
1170 static struct usb_driver btusb_driver = {
1171 .name = "btusb",
1172 .probe = btusb_probe,
1173 .disconnect = btusb_disconnect,
1174 #ifdef CONFIG_PM
1175 .suspend = btusb_suspend,
1176 .resume = btusb_resume,
1177 #endif
1178 .id_table = btusb_table,
1179 .supports_autosuspend = 1,
1180 };
1181
1182 static int __init btusb_init(void)
1183 {
1184 BT_INFO("Generic Bluetooth USB driver ver %s", VERSION);
1185
1186 return usb_register(&btusb_driver);
1187 }
1188
1189 static void __exit btusb_exit(void)
1190 {
1191 usb_deregister(&btusb_driver);
1192 }
1193
1194 module_init(btusb_init);
1195 module_exit(btusb_exit);
1196
1197 module_param(ignore_dga, bool, 0644);
1198 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1199
1200 module_param(ignore_csr, bool, 0644);
1201 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1202
1203 module_param(ignore_sniffer, bool, 0644);
1204 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1205
1206 module_param(disable_scofix, bool, 0644);
1207 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
1208
1209 module_param(force_scofix, bool, 0644);
1210 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
1211
1212 module_param(reset, bool, 0644);
1213 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1214
1215 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1216 MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
1217 MODULE_VERSION(VERSION);
1218 MODULE_LICENSE("GPL");
Linux MOXA ART SoC ARM port