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