1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#define VERSION "2.4"
34
35#include <linux/config.h>
36#include <linux/module.h>
37
38#include <linux/version.h>
39#include <linux/kernel.h>
40#include <linux/init.h>
41#include <linux/sched.h>
42#include <linux/unistd.h>
43#include <linux/types.h>
44#include <linux/interrupt.h>
45
46#include <linux/slab.h>
47#include <linux/errno.h>
48#include <linux/string.h>
49#include <linux/skbuff.h>
50
51#include <linux/usb.h>
52
53#include <net/bluetooth/bluetooth.h>
54#include <net/bluetooth/hci_core.h>
55
56#include "hci_usb.h"
57
58#ifndef HCI_USB_DEBUG
59#undef BT_DBG
60#define BT_DBG( A... )
61#undef BT_DMP
62#define BT_DMP( A... )
63#endif
64
65#ifndef CONFIG_BLUEZ_USB_ZERO_PACKET
66#undef USB_ZERO_PACKET
67#define USB_ZERO_PACKET 0
68#endif
69
70static struct usb_driver hci_usb_driver;
71
72static struct usb_device_id bluetooth_ids[] = {
73
74 { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
75
76
77 { USB_DEVICE(0x0bdb, 0x1002) },
78
79
80 { USB_DEVICE(0x04bf, 0x030a) },
81
82 { }
83};
84
85MODULE_DEVICE_TABLE (usb, bluetooth_ids);
86
87static struct usb_device_id ignore_ids[] = {
88
89 { USB_DEVICE(0x0a5c, 0x2033) },
90
91 { }
92};
93
94struct _urb *_urb_alloc(int isoc, int gfp)
95{
96 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
97 sizeof(struct iso_packet_descriptor) * isoc, gfp);
98 if (_urb) {
99 memset(_urb, 0, sizeof(*_urb));
100 spin_lock_init(&_urb->urb.lock);
101 }
102 return _urb;
103}
104
105struct _urb *_urb_dequeue(struct _urb_queue *q)
106{
107 struct _urb *_urb = NULL;
108 unsigned long flags;
109 spin_lock_irqsave(&q->lock, flags);
110 {
111 struct list_head *head = &q->head;
112 struct list_head *next = head->next;
113 if (next != head) {
114 _urb = list_entry(next, struct _urb, list);
115 list_del(next); _urb->queue = NULL;
116 }
117 }
118 spin_unlock_irqrestore(&q->lock, flags);
119 return _urb;
120}
121
122static void hci_usb_rx_complete(struct urb *urb);
123static void hci_usb_tx_complete(struct urb *urb);
124
125#define __pending_tx(husb, type) (&husb->pending_tx[type-1])
126#define __pending_q(husb, type) (&husb->pending_q[type-1])
127#define __completed_q(husb, type) (&husb->completed_q[type-1])
128#define __transmit_q(husb, type) (&husb->transmit_q[type-1])
129#define __reassembly(husb, type) (husb->reassembly[type-1])
130
131static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
132{
133 return _urb_dequeue(__completed_q(husb, type));
134}
135
136static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
137{
138 int offset = 0, i;
139
140 BT_DBG("len %d mtu %d", len, mtu);
141
142 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
143 urb->iso_frame_desc[i].offset = offset;
144 urb->iso_frame_desc[i].length = mtu;
145 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
146 }
147 if (len && i < HCI_MAX_ISOC_FRAMES) {
148 urb->iso_frame_desc[i].offset = offset;
149 urb->iso_frame_desc[i].length = len;
150 BT_DBG("desc %d offset %d len %d", i, offset, len);
151 i++;
152 }
153 urb->number_of_packets = i;
154}
155
156static int hci_usb_intr_rx_submit(struct hci_usb *husb)
157{
158 struct _urb *_urb;
159 struct urb *urb;
160 int err, pipe, interval, size;
161 void *buf;
162
163 BT_DBG("%s", husb->hdev.name);
164
165 size = husb->intr_in_ep->wMaxPacketSize;
166
167 buf = kmalloc(size, GFP_ATOMIC);
168 if (!buf)
169 return -ENOMEM;
170
171 _urb = _urb_alloc(0, GFP_ATOMIC);
172 if (!_urb) {
173 kfree(buf);
174 return -ENOMEM;
175 }
176 _urb->type = HCI_EVENT_PKT;
177 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
178
179 urb = &_urb->urb;
180 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->bEndpointAddress);
181 interval = husb->intr_in_ep->bInterval;
182 FILL_INT_URB(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
183
184 err = usb_submit_urb(urb);
185 if (err) {
186 BT_ERR("%s intr rx submit failed urb %p err %d",
187 husb->hdev.name, urb, err);
188 _urb_unlink(_urb);
189 _urb_free(_urb);
190 kfree(buf);
191 }
192 return err;
193}
194
195static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
196{
197 struct _urb *_urb;
198 struct urb *urb;
199 int err, pipe, size = HCI_MAX_FRAME_SIZE;
200 void *buf;
201
202 buf = kmalloc(size, GFP_ATOMIC);
203 if (!buf)
204 return -ENOMEM;
205
206 _urb = _urb_alloc(0, GFP_ATOMIC);
207 if (!_urb) {
208 kfree(buf);
209 return -ENOMEM;
210 }
211 _urb->type = HCI_ACLDATA_PKT;
212 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
213
214 urb = &_urb->urb;
215 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->bEndpointAddress);
216 FILL_BULK_URB(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
217 urb->transfer_flags = USB_QUEUE_BULK;
218
219 BT_DBG("%s urb %p", husb->hdev.name, urb);
220
221 err = usb_submit_urb(urb);
222 if (err) {
223 BT_ERR("%s bulk rx submit failed urb %p err %d",
224 husb->hdev.name, urb, err);
225 _urb_unlink(_urb);
226 _urb_free(_urb);
227 kfree(buf);
228 }
229 return err;
230}
231
232#ifdef CONFIG_BLUEZ_USB_SCO
233static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
234{
235 struct _urb *_urb;
236 struct urb *urb;
237 int err, mtu, size;
238 void *buf;
239
240 mtu = husb->isoc_in_ep->wMaxPacketSize;
241 size = mtu * HCI_MAX_ISOC_FRAMES;
242
243 buf = kmalloc(size, GFP_ATOMIC);
244 if (!buf)
245 return -ENOMEM;
246
247 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
248 if (!_urb) {
249 kfree(buf);
250 return -ENOMEM;
251 }
252 _urb->type = HCI_SCODATA_PKT;
253 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
254
255 urb = &_urb->urb;
256
257 urb->context = husb;
258 urb->dev = husb->udev;
259 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->bEndpointAddress);
260 urb->complete = hci_usb_rx_complete;
261
262 urb->transfer_buffer_length = size;
263 urb->transfer_buffer = buf;
264 urb->transfer_flags = USB_ISO_ASAP;
265
266 __fill_isoc_desc(urb, size, mtu);
267
268 BT_DBG("%s urb %p", husb->hdev.name, urb);
269
270 err = usb_submit_urb(urb);
271 if (err) {
272 BT_ERR("%s isoc rx submit failed urb %p err %d",
273 husb->hdev.name, urb, err);
274 _urb_unlink(_urb);
275 _urb_free(_urb);
276 kfree(buf);
277 }
278 return err;
279}
280#endif
281
282
283static int hci_usb_open(struct hci_dev *hdev)
284{
285 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
286 int i, err;
287 unsigned long flags;
288
289 BT_DBG("%s", hdev->name);
290
291 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
292 return 0;
293
294 MOD_INC_USE_COUNT;
295
296 write_lock_irqsave(&husb->completion_lock, flags);
297
298 err = hci_usb_intr_rx_submit(husb);
299 if (!err) {
300 for (i = 0; i < HCI_MAX_BULK_RX; i++)
301 hci_usb_bulk_rx_submit(husb);
302
303#ifdef CONFIG_BLUEZ_USB_SCO
304 if (husb->isoc_iface)
305 hci_usb_isoc_rx_submit(husb);
306#endif
307 } else {
308 clear_bit(HCI_RUNNING, &hdev->flags);
309 MOD_DEC_USE_COUNT;
310 }
311
312 write_unlock_irqrestore(&husb->completion_lock, flags);
313 return err;
314}
315
316
317static int hci_usb_flush(struct hci_dev *hdev)
318{
319 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
320 int i;
321
322 BT_DBG("%s", hdev->name);
323
324 for (i=0; i < 4; i++)
325 skb_queue_purge(&husb->transmit_q[i]);
326 return 0;
327}
328
329static void hci_usb_unlink_urbs(struct hci_usb *husb)
330{
331 int i;
332
333 BT_DBG("%s", husb->hdev.name);
334
335 for (i=0; i < 4; i++) {
336 struct _urb *_urb;
337 struct urb *urb;
338
339
340 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
341 urb = &_urb->urb;
342 BT_DBG("%s unlinking _urb %p type %d urb %p",
343 husb->hdev.name, _urb, _urb->type, urb);
344 usb_unlink_urb(urb);
345 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
346 }
347
348
349 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
350 urb = &_urb->urb;
351 BT_DBG("%s freeing _urb %p type %d urb %p",
352 husb->hdev.name, _urb, _urb->type, urb);
353 if (urb->setup_packet)
354 kfree(urb->setup_packet);
355 if (urb->transfer_buffer)
356 kfree(urb->transfer_buffer);
357 _urb_free(_urb);
358 }
359
360
361 if (husb->reassembly[i]) {
362 kfree_skb(husb->reassembly[i]);
363 husb->reassembly[i] = NULL;
364 }
365 }
366}
367
368
369static int hci_usb_close(struct hci_dev *hdev)
370{
371 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
372 unsigned long flags;
373
374 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
375 return 0;
376
377 BT_DBG("%s", hdev->name);
378
379 write_lock_irqsave(&husb->completion_lock, flags);
380
381 hci_usb_unlink_urbs(husb);
382 hci_usb_flush(hdev);
383
384 write_unlock_irqrestore(&husb->completion_lock, flags);
385
386 MOD_DEC_USE_COUNT;
387 return 0;
388}
389
390static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
391{
392 struct urb *urb = &_urb->urb;
393 int err;
394
395 BT_DBG("%s urb %p type %d", husb->hdev.name, urb, _urb->type);
396
397 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
398 err = usb_submit_urb(urb);
399 if (err) {
400 BT_ERR("%s tx submit failed urb %p type %d err %d",
401 husb->hdev.name, urb, _urb->type, err);
402 _urb_unlink(_urb);
403 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
404 } else
405 atomic_inc(__pending_tx(husb, _urb->type));
406
407 return err;
408}
409
410static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
411{
412 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
413 struct usb_ctrlrequest *dr;
414 struct urb *urb;
415
416 if (!_urb) {
417 _urb = _urb_alloc(0, GFP_ATOMIC);
418 if (!_urb)
419 return -ENOMEM;
420 _urb->type = skb->pkt_type;
421
422 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
423 if (!dr) {
424 _urb_free(_urb);
425 return -ENOMEM;
426 }
427 } else
428 dr = (void *) _urb->urb.setup_packet;
429
430 dr->bRequestType = HCI_CTRL_REQ;
431 dr->bRequest = 0;
432 dr->wIndex = 0;
433 dr->wValue = 0;
434 dr->wLength = __cpu_to_le16(skb->len);
435
436 urb = &_urb->urb;
437 FILL_CONTROL_URB(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
438 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
439
440 BT_DBG("%s skb %p len %d", husb->hdev.name, skb, skb->len);
441
442 _urb->priv = skb;
443 return __tx_submit(husb, _urb);
444}
445
446static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
447{
448 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
449 struct urb *urb;
450 int pipe;
451
452 if (!_urb) {
453 _urb = _urb_alloc(0, GFP_ATOMIC);
454 if (!_urb)
455 return -ENOMEM;
456 _urb->type = skb->pkt_type;
457 }
458
459 urb = &_urb->urb;
460 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->bEndpointAddress);
461 FILL_BULK_URB(urb, husb->udev, pipe, skb->data, skb->len,
462 hci_usb_tx_complete, husb);
463 urb->transfer_flags = USB_QUEUE_BULK | USB_ZERO_PACKET;
464
465 BT_DBG("%s skb %p len %d", husb->hdev.name, skb, skb->len);
466
467 _urb->priv = skb;
468 return __tx_submit(husb, _urb);
469}
470
471#ifdef CONFIG_BLUEZ_USB_SCO
472static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
473{
474 struct _urb *_urb = __get_completed(husb, skb->pkt_type);
475 struct urb *urb;
476
477 if (!_urb) {
478 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
479 if (!_urb)
480 return -ENOMEM;
481 _urb->type = skb->pkt_type;
482 }
483
484 BT_DBG("%s skb %p len %d", husb->hdev.name, skb, skb->len);
485
486 urb = &_urb->urb;
487
488 urb->context = husb;
489 urb->dev = husb->udev;
490 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->bEndpointAddress);
491 urb->complete = hci_usb_tx_complete;
492 urb->transfer_flags = USB_ISO_ASAP;
493
494 urb->transfer_buffer = skb->data;
495 urb->transfer_buffer_length = skb->len;
496
497 __fill_isoc_desc(urb, skb->len, husb->isoc_out_ep->wMaxPacketSize);
498
499 _urb->priv = skb;
500 return __tx_submit(husb, _urb);
501}
502#endif
503
504static void hci_usb_tx_process(struct hci_usb *husb)
505{
506 struct sk_buff_head *q;
507 struct sk_buff *skb;
508
509 BT_DBG("%s", husb->hdev.name);
510
511 do {
512 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
513
514
515 q = __transmit_q(husb, HCI_COMMAND_PKT);
516 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
517 (skb = skb_dequeue(q))) {
518 if (hci_usb_send_ctrl(husb, skb) < 0)
519 skb_queue_head(q, skb);
520 }
521
522#ifdef CONFIG_BLUEZ_USB_SCO
523
524 q = __transmit_q(husb, HCI_SCODATA_PKT);
525 if (!atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) &&
526 (skb = skb_dequeue(q))) {
527 if (hci_usb_send_isoc(husb, skb) < 0)
528 skb_queue_head(q, skb);
529 }
530#endif
531
532
533 q = __transmit_q(husb, HCI_ACLDATA_PKT);
534 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
535 (skb = skb_dequeue(q))) {
536 if (hci_usb_send_bulk(husb, skb) < 0) {
537 skb_queue_head(q, skb);
538 break;
539 }
540 }
541 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
542}
543
544static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
545{
546
547 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
548 hci_usb_tx_process(husb);
549 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
550 } else
551 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
552}
553
554
555static int hci_usb_send_frame(struct sk_buff *skb)
556{
557 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
558 struct hci_usb *husb;
559
560 if (!hdev) {
561 BT_ERR("frame for uknown device (hdev=NULL)");
562 return -ENODEV;
563 }
564
565 if (!test_bit(HCI_RUNNING, &hdev->flags))
566 return -EBUSY;
567
568 BT_DBG("%s type %d len %d", hdev->name, skb->pkt_type, skb->len);
569
570 husb = (struct hci_usb *) hdev->driver_data;
571
572 switch (skb->pkt_type) {
573 case HCI_COMMAND_PKT:
574 hdev->stat.cmd_tx++;
575 break;
576
577 case HCI_ACLDATA_PKT:
578 hdev->stat.acl_tx++;
579 break;
580
581#ifdef CONFIG_BLUEZ_USB_SCO
582 case HCI_SCODATA_PKT:
583 hdev->stat.sco_tx++;
584 break;
585#endif
586
587 default:
588 kfree_skb(skb);
589 return 0;
590 }
591
592 read_lock(&husb->completion_lock);
593
594 skb_queue_tail(__transmit_q(husb, skb->pkt_type), skb);
595 hci_usb_tx_wakeup(husb);
596
597 read_unlock(&husb->completion_lock);
598 return 0;
599}
600
601static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
602{
603 BT_DBG("%s type %d data %p count %d", husb->hdev.name, type, data, count);
604
605 husb->hdev.stat.byte_rx += count;
606
607 while (count) {
608 struct sk_buff *skb = __reassembly(husb, type);
609 struct { int expect; } *scb;
610 int len = 0;
611
612 if (!skb) {
613
614
615 switch (type) {
616 case HCI_EVENT_PKT:
617 if (count >= HCI_EVENT_HDR_SIZE) {
618 hci_event_hdr *h = data;
619 len = HCI_EVENT_HDR_SIZE + h->plen;
620 } else
621 return -EILSEQ;
622 break;
623
624 case HCI_ACLDATA_PKT:
625 if (count >= HCI_ACL_HDR_SIZE) {
626 hci_acl_hdr *h = data;
627 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
628 } else
629 return -EILSEQ;
630 break;
631#ifdef CONFIG_BLUEZ_USB_SCO
632 case HCI_SCODATA_PKT:
633 if (count >= HCI_SCO_HDR_SIZE) {
634 hci_sco_hdr *h = data;
635 len = HCI_SCO_HDR_SIZE + h->dlen;
636 } else
637 return -EILSEQ;
638 break;
639#endif
640 }
641 BT_DBG("new packet len %d", len);
642
643 skb = bluez_skb_alloc(len, GFP_ATOMIC);
644 if (!skb) {
645 BT_ERR("%s no memory for the packet", husb->hdev.name);
646 return -ENOMEM;
647 }
648 skb->dev = (void *) &husb->hdev;
649 skb->pkt_type = type;
650
651 __reassembly(husb, type) = skb;
652
653 scb = (void *) skb->cb;
654 scb->expect = len;
655 } else {
656
657 scb = (void *) skb->cb;
658 len = scb->expect;
659 }
660
661 len = min(len, count);
662
663 memcpy(skb_put(skb, len), data, len);
664
665 scb->expect -= len;
666 if (!scb->expect) {
667
668 __reassembly(husb, type) = NULL;
669 hci_recv_frame(skb);
670 }
671
672 count -= len; data += len;
673 }
674 return 0;
675}
676
677static void hci_usb_rx_complete(struct urb *urb)
678{
679 struct _urb *_urb = container_of(urb, struct _urb, urb);
680 struct hci_usb *husb = (void *) urb->context;
681 struct hci_dev *hdev = &husb->hdev;
682 int err, count = urb->actual_length;
683
684 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
685 _urb->type, urb->status, count, urb->transfer_flags);
686
687 if (!test_bit(HCI_RUNNING, &hdev->flags))
688 return;
689
690 read_lock(&husb->completion_lock);
691
692 if (urb->status || !count)
693 goto resubmit;
694
695 if (_urb->type == HCI_SCODATA_PKT) {
696#ifdef CONFIG_BLUEZ_USB_SCO
697 int i;
698 for (i=0; i < urb->number_of_packets; i++) {
699 BT_DBG("desc %d status %d offset %d len %d", i,
700 urb->iso_frame_desc[i].status,
701 urb->iso_frame_desc[i].offset,
702 urb->iso_frame_desc[i].actual_length);
703
704 if (!urb->iso_frame_desc[i].status)
705 __recv_frame(husb, _urb->type,
706 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
707 urb->iso_frame_desc[i].actual_length);
708 }
709#else
710 ;
711#endif
712 } else {
713 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
714 if (err < 0) {
715 BT_ERR("%s corrupted packet: type %d count %d",
716 husb->hdev.name, _urb->type, count);
717 hdev->stat.err_rx++;
718 }
719 }
720
721resubmit:
722 if (_urb->type != HCI_EVENT_PKT) {
723 urb->dev = husb->udev;
724 err = usb_submit_urb(urb);
725 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
726 _urb->type, err);
727 }
728 read_unlock(&husb->completion_lock);
729}
730
731static void hci_usb_tx_complete(struct urb *urb)
732{
733 struct _urb *_urb = container_of(urb, struct _urb, urb);
734 struct hci_usb *husb = (void *) urb->context;
735 struct hci_dev *hdev = &husb->hdev;
736
737 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
738 urb->status, urb->transfer_flags);
739
740 atomic_dec(__pending_tx(husb, _urb->type));
741
742 urb->transfer_buffer = NULL;
743 kfree_skb((struct sk_buff *) _urb->priv);
744
745 if (!test_bit(HCI_RUNNING, &hdev->flags))
746 return;
747
748 if (!urb->status)
749 hdev->stat.byte_tx += urb->transfer_buffer_length;
750 else
751 hdev->stat.err_tx++;
752
753 read_lock(&husb->completion_lock);
754
755 _urb_unlink(_urb);
756 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
757
758 hci_usb_tx_wakeup(husb);
759
760 read_unlock(&husb->completion_lock);
761}
762
763static void hci_usb_destruct(struct hci_dev *hdev)
764{
765 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
766
767 BT_DBG("%s", hdev->name);
768
769 kfree(husb);
770}
771
772static void *hci_usb_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id)
773{
774 struct usb_endpoint_descriptor *bulk_out_ep[HCI_MAX_IFACE_NUM];
775 struct usb_endpoint_descriptor *isoc_out_ep[HCI_MAX_IFACE_NUM];
776 struct usb_endpoint_descriptor *bulk_in_ep[HCI_MAX_IFACE_NUM];
777 struct usb_endpoint_descriptor *isoc_in_ep[HCI_MAX_IFACE_NUM];
778 struct usb_endpoint_descriptor *intr_in_ep[HCI_MAX_IFACE_NUM];
779 struct usb_interface_descriptor *uif;
780 struct usb_endpoint_descriptor *ep;
781 struct usb_interface *iface, *isoc_iface;
782 struct hci_usb *husb;
783 struct hci_dev *hdev;
784 int i, a, e, size, ifn, isoc_ifnum, isoc_alts;
785
786 BT_DBG("udev %p ifnum %d", udev, ifnum);
787
788 iface = &udev->actconfig->interface[0];
789
790
791 if (usb_match_id(udev, iface, ignore_ids))
792 return NULL;
793
794
795 if (udev->actconfig->interface[ifnum].altsetting[0].bNumEndpoints < 3)
796 return NULL;
797
798 memset(bulk_out_ep, 0, sizeof(bulk_out_ep));
799 memset(isoc_out_ep, 0, sizeof(isoc_out_ep));
800 memset(bulk_in_ep, 0, sizeof(bulk_in_ep));
801 memset(isoc_in_ep, 0, sizeof(isoc_in_ep));
802 memset(intr_in_ep, 0, sizeof(intr_in_ep));
803
804 size = 0;
805 isoc_iface = NULL;
806 isoc_alts = isoc_ifnum = 0;
807
808
809
810 ifn = MIN(udev->actconfig->bNumInterfaces, HCI_MAX_IFACE_NUM);
811 for (i = 0; i < ifn; i++) {
812 iface = &udev->actconfig->interface[i];
813 for (a = 0; a < iface->num_altsetting; a++) {
814 uif = &iface->altsetting[a];
815 for (e = 0; e < uif->bNumEndpoints; e++) {
816 ep = &uif->endpoint[e];
817
818 switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
819 case USB_ENDPOINT_XFER_INT:
820 if (ep->bEndpointAddress & USB_DIR_IN)
821 intr_in_ep[i] = ep;
822 break;
823
824 case USB_ENDPOINT_XFER_BULK:
825 if (ep->bEndpointAddress & USB_DIR_IN)
826 bulk_in_ep[i] = ep;
827 else
828 bulk_out_ep[i] = ep;
829 break;
830
831#ifdef CONFIG_BLUEZ_USB_SCO
832 case USB_ENDPOINT_XFER_ISOC:
833 if (ep->wMaxPacketSize < size)
834 break;
835 size = ep->wMaxPacketSize;
836
837 isoc_iface = iface;
838 isoc_alts = a;
839 isoc_ifnum = i;
840
841 if (ep->bEndpointAddress & USB_DIR_IN)
842 isoc_in_ep[i] = ep;
843 else
844 isoc_out_ep[i] = ep;
845 break;
846#endif
847 }
848 }
849 }
850 }
851
852 if (!bulk_in_ep[0] || !bulk_out_ep[0] || !intr_in_ep[0]) {
853 BT_DBG("Bulk endpoints not found");
854 goto done;
855 }
856
857#ifdef CONFIG_BLUEZ_USB_SCO
858 if (!isoc_in_ep[1] || !isoc_out_ep[1]) {
859 BT_DBG("Isoc endpoints not found");
860 isoc_iface = NULL;
861 }
862#endif
863
864 if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
865 BT_ERR("Can't allocate: control structure");
866 goto done;
867 }
868
869 memset(husb, 0, sizeof(struct hci_usb));
870
871 husb->udev = udev;
872 husb->bulk_out_ep = bulk_out_ep[0];
873 husb->bulk_in_ep = bulk_in_ep[0];
874 husb->intr_in_ep = intr_in_ep[0];
875
876#ifdef CONFIG_BLUEZ_USB_SCO
877 if (isoc_iface) {
878 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
879 if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
880 BT_ERR("Can't set isoc interface settings");
881 isoc_iface = NULL;
882 }
883 usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb);
884 husb->isoc_iface = isoc_iface;
885 husb->isoc_in_ep = isoc_in_ep[isoc_ifnum];
886 husb->isoc_out_ep = isoc_out_ep[isoc_ifnum];
887 }
888#endif
889
890 husb->completion_lock = RW_LOCK_UNLOCKED;
891
892 for (i = 0; i < 4; i++) {
893 skb_queue_head_init(&husb->transmit_q[i]);
894 _urb_queue_init(&husb->pending_q[i]);
895 _urb_queue_init(&husb->completed_q[i]);
896 }
897
898
899 hdev = &husb->hdev;
900
901 hdev->type = HCI_USB;
902 hdev->driver_data = husb;
903
904 hdev->open = hci_usb_open;
905 hdev->close = hci_usb_close;
906 hdev->flush = hci_usb_flush;
907 hdev->send = hci_usb_send_frame;
908 hdev->destruct = hci_usb_destruct;
909
910 if (hci_register_dev(hdev) < 0) {
911 BT_ERR("Can't register HCI device");
912 goto probe_error;
913 }
914
915 return husb;
916
917probe_error:
918 kfree(husb);
919
920done:
921 return NULL;
922}
923
924static void hci_usb_disconnect(struct usb_device *udev, void *ptr)
925{
926 struct hci_usb *husb = (struct hci_usb *) ptr;
927 struct hci_dev *hdev = &husb->hdev;
928
929 if (!husb)
930 return;
931
932 BT_DBG("%s", hdev->name);
933
934 hci_usb_close(hdev);
935
936 if (husb->isoc_iface)
937 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
938
939 if (hci_unregister_dev(hdev) < 0)
940 BT_ERR("Can't unregister HCI device %s", hdev->name);
941}
942
943static struct usb_driver hci_usb_driver = {
944 name: "hci_usb",
945 probe: hci_usb_probe,
946 disconnect: hci_usb_disconnect,
947 id_table: bluetooth_ids,
948};
949
950int hci_usb_init(void)
951{
952 int err;
953
954 BT_INFO("BlueZ HCI USB driver ver %s Copyright (C) 2000,2001 Qualcomm Inc",
955 VERSION);
956 BT_INFO("Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>");
957
958 if ((err = usb_register(&hci_usb_driver)) < 0)
959 BT_ERR("Failed to register HCI USB driver");
960
961 return err;
962}
963
964void hci_usb_cleanup(void)
965{
966 usb_deregister(&hci_usb_driver);
967}
968
969module_init(hci_usb_init);
970module_exit(hci_usb_cleanup);
971
972MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
973MODULE_DESCRIPTION("BlueZ HCI USB driver ver " VERSION);
974MODULE_LICENSE("GPL");
975
