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