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