projects / deliverable / linux.git / blob
? search:


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