3 * AVM BlueFRITZ! USB driver
5 * Copyright (C) 2003 Marcel Holtmann <marcel@holtmann.org>
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.
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.
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
24 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/errno.h>
32 #include <linux/skbuff.h>
34 #include <linux/device.h>
35 #include <linux/firmware.h>
37 #include <linux/usb.h>
39 #include <net/bluetooth/bluetooth.h>
40 #include <net/bluetooth/hci_core.h>
42 #ifndef CONFIG_BT_HCIBFUSB_DEBUG
49 static int ignore
= 0;
51 static struct usb_driver bfusb_driver
;
53 static struct usb_device_id bfusb_table
[] = {
54 /* AVM BlueFRITZ! USB */
55 { USB_DEVICE(0x057c, 0x2200) },
57 { } /* Terminating entry */
60 MODULE_DEVICE_TABLE(usb
, bfusb_table
);
63 #define BFUSB_MAX_BLOCK_SIZE 256
65 #define BFUSB_BLOCK_TIMEOUT 3000
67 #define BFUSB_TX_PROCESS 1
68 #define BFUSB_TX_WAKEUP 2
70 #define BFUSB_MAX_BULK_TX 2
71 #define BFUSB_MAX_BULK_RX 2
78 struct usb_device
*udev
;
80 unsigned int bulk_in_ep
;
81 unsigned int bulk_out_ep
;
82 unsigned int bulk_pkt_size
;
86 struct sk_buff_head transmit_q
;
88 struct sk_buff
*reassembly
;
91 struct sk_buff_head pending_q
;
92 struct sk_buff_head completed_q
;
99 static void bfusb_tx_complete(struct urb
*urb
, struct pt_regs
*regs
);
100 static void bfusb_rx_complete(struct urb
*urb
, struct pt_regs
*regs
);
102 static struct urb
*bfusb_get_completed(struct bfusb
*bfusb
)
105 struct urb
*urb
= NULL
;
107 BT_DBG("bfusb %p", bfusb
);
109 skb
= skb_dequeue(&bfusb
->completed_q
);
111 urb
= ((struct bfusb_scb
*) skb
->cb
)->urb
;
118 static void bfusb_unlink_urbs(struct bfusb
*bfusb
)
123 BT_DBG("bfusb %p", bfusb
);
125 while ((skb
= skb_dequeue(&bfusb
->pending_q
))) {
126 urb
= ((struct bfusb_scb
*) skb
->cb
)->urb
;
128 skb_queue_tail(&bfusb
->completed_q
, skb
);
131 while ((urb
= bfusb_get_completed(bfusb
)))
136 static int bfusb_send_bulk(struct bfusb
*bfusb
, struct sk_buff
*skb
)
138 struct bfusb_scb
*scb
= (void *) skb
->cb
;
139 struct urb
*urb
= bfusb_get_completed(bfusb
);
142 BT_DBG("bfusb %p skb %p len %d", bfusb
, skb
, skb
->len
);
144 if (!urb
&& !(urb
= usb_alloc_urb(0, GFP_ATOMIC
)))
147 pipe
= usb_sndbulkpipe(bfusb
->udev
, bfusb
->bulk_out_ep
);
149 usb_fill_bulk_urb(urb
, bfusb
->udev
, pipe
, skb
->data
, skb
->len
,
150 bfusb_tx_complete
, skb
);
154 skb_queue_tail(&bfusb
->pending_q
, skb
);
156 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
158 BT_ERR("%s bulk tx submit failed urb %p err %d",
159 bfusb
->hdev
->name
, urb
, err
);
160 skb_unlink(skb
, &bfusb
->pending_q
);
163 atomic_inc(&bfusb
->pending_tx
);
168 static void bfusb_tx_wakeup(struct bfusb
*bfusb
)
172 BT_DBG("bfusb %p", bfusb
);
174 if (test_and_set_bit(BFUSB_TX_PROCESS
, &bfusb
->state
)) {
175 set_bit(BFUSB_TX_WAKEUP
, &bfusb
->state
);
180 clear_bit(BFUSB_TX_WAKEUP
, &bfusb
->state
);
182 while ((atomic_read(&bfusb
->pending_tx
) < BFUSB_MAX_BULK_TX
) &&
183 (skb
= skb_dequeue(&bfusb
->transmit_q
))) {
184 if (bfusb_send_bulk(bfusb
, skb
) < 0) {
185 skb_queue_head(&bfusb
->transmit_q
, skb
);
190 } while (test_bit(BFUSB_TX_WAKEUP
, &bfusb
->state
));
192 clear_bit(BFUSB_TX_PROCESS
, &bfusb
->state
);
195 static void bfusb_tx_complete(struct urb
*urb
, struct pt_regs
*regs
)
197 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
198 struct bfusb
*bfusb
= (struct bfusb
*) skb
->dev
;
200 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb
, urb
, skb
, skb
->len
);
202 atomic_dec(&bfusb
->pending_tx
);
204 if (!test_bit(HCI_RUNNING
, &bfusb
->hdev
->flags
))
208 bfusb
->hdev
->stat
.byte_tx
+= skb
->len
;
210 bfusb
->hdev
->stat
.err_tx
++;
212 read_lock(&bfusb
->lock
);
214 skb_unlink(skb
, &bfusb
->pending_q
);
215 skb_queue_tail(&bfusb
->completed_q
, skb
);
217 bfusb_tx_wakeup(bfusb
);
219 read_unlock(&bfusb
->lock
);
223 static int bfusb_rx_submit(struct bfusb
*bfusb
, struct urb
*urb
)
225 struct bfusb_scb
*scb
;
227 int err
, pipe
, size
= HCI_MAX_FRAME_SIZE
+ 32;
229 BT_DBG("bfusb %p urb %p", bfusb
, urb
);
231 if (!urb
&& !(urb
= usb_alloc_urb(0, GFP_ATOMIC
)))
234 if (!(skb
= bt_skb_alloc(size
, GFP_ATOMIC
))) {
239 skb
->dev
= (void *) bfusb
;
241 scb
= (struct bfusb_scb
*) skb
->cb
;
244 pipe
= usb_rcvbulkpipe(bfusb
->udev
, bfusb
->bulk_in_ep
);
246 usb_fill_bulk_urb(urb
, bfusb
->udev
, pipe
, skb
->data
, size
,
247 bfusb_rx_complete
, skb
);
249 skb_queue_tail(&bfusb
->pending_q
, skb
);
251 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
253 BT_ERR("%s bulk rx submit failed urb %p err %d",
254 bfusb
->hdev
->name
, urb
, err
);
255 skb_unlink(skb
, &bfusb
->pending_q
);
263 static inline int bfusb_recv_block(struct bfusb
*bfusb
, int hdr
, unsigned char *data
, int len
)
265 BT_DBG("bfusb %p hdr 0x%02x data %p len %d", bfusb
, hdr
, data
, len
);
268 BT_ERR("%s error in block", bfusb
->hdev
->name
);
269 if (bfusb
->reassembly
)
270 kfree_skb(bfusb
->reassembly
);
271 bfusb
->reassembly
= NULL
;
277 unsigned char pkt_type
;
280 if (bfusb
->reassembly
) {
281 BT_ERR("%s unexpected start block", bfusb
->hdev
->name
);
282 kfree_skb(bfusb
->reassembly
);
283 bfusb
->reassembly
= NULL
;
287 BT_ERR("%s no packet type found", bfusb
->hdev
->name
);
291 pkt_type
= *data
++; len
--;
295 if (len
>= HCI_EVENT_HDR_SIZE
) {
296 struct hci_event_hdr
*hdr
= (struct hci_event_hdr
*) data
;
297 pkt_len
= HCI_EVENT_HDR_SIZE
+ hdr
->plen
;
299 BT_ERR("%s event block is too short", bfusb
->hdev
->name
);
304 case HCI_ACLDATA_PKT
:
305 if (len
>= HCI_ACL_HDR_SIZE
) {
306 struct hci_acl_hdr
*hdr
= (struct hci_acl_hdr
*) data
;
307 pkt_len
= HCI_ACL_HDR_SIZE
+ __le16_to_cpu(hdr
->dlen
);
309 BT_ERR("%s data block is too short", bfusb
->hdev
->name
);
314 case HCI_SCODATA_PKT
:
315 if (len
>= HCI_SCO_HDR_SIZE
) {
316 struct hci_sco_hdr
*hdr
= (struct hci_sco_hdr
*) data
;
317 pkt_len
= HCI_SCO_HDR_SIZE
+ hdr
->dlen
;
319 BT_ERR("%s audio block is too short", bfusb
->hdev
->name
);
325 skb
= bt_skb_alloc(pkt_len
, GFP_ATOMIC
);
327 BT_ERR("%s no memory for the packet", bfusb
->hdev
->name
);
331 skb
->dev
= (void *) bfusb
->hdev
;
332 bt_cb(skb
)->pkt_type
= pkt_type
;
334 bfusb
->reassembly
= skb
;
336 if (!bfusb
->reassembly
) {
337 BT_ERR("%s unexpected continuation block", bfusb
->hdev
->name
);
343 memcpy(skb_put(bfusb
->reassembly
, len
), data
, len
);
346 hci_recv_frame(bfusb
->reassembly
);
347 bfusb
->reassembly
= NULL
;
353 static void bfusb_rx_complete(struct urb
*urb
, struct pt_regs
*regs
)
355 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
356 struct bfusb
*bfusb
= (struct bfusb
*) skb
->dev
;
357 unsigned char *buf
= urb
->transfer_buffer
;
358 int count
= urb
->actual_length
;
361 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb
, urb
, skb
, skb
->len
);
363 read_lock(&bfusb
->lock
);
365 if (!test_bit(HCI_RUNNING
, &bfusb
->hdev
->flags
))
368 if (urb
->status
|| !count
)
371 bfusb
->hdev
->stat
.byte_rx
+= count
;
376 hdr
= buf
[0] | (buf
[1] << 8);
383 len
= (buf
[2] == 0) ? 256 : buf
[2];
389 BT_ERR("%s block extends over URB buffer ranges",
393 if ((hdr
& 0xe1) == 0xc1)
394 bfusb_recv_block(bfusb
, hdr
, buf
, len
);
400 skb_unlink(skb
, &bfusb
->pending_q
);
403 bfusb_rx_submit(bfusb
, urb
);
405 read_unlock(&bfusb
->lock
);
410 urb
->dev
= bfusb
->udev
;
412 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
414 BT_ERR("%s bulk resubmit failed urb %p err %d",
415 bfusb
->hdev
->name
, urb
, err
);
419 read_unlock(&bfusb
->lock
);
423 static int bfusb_open(struct hci_dev
*hdev
)
425 struct bfusb
*bfusb
= (struct bfusb
*) hdev
->driver_data
;
429 BT_DBG("hdev %p bfusb %p", hdev
, bfusb
);
431 if (test_and_set_bit(HCI_RUNNING
, &hdev
->flags
))
434 write_lock_irqsave(&bfusb
->lock
, flags
);
436 err
= bfusb_rx_submit(bfusb
, NULL
);
438 for (i
= 1; i
< BFUSB_MAX_BULK_RX
; i
++)
439 bfusb_rx_submit(bfusb
, NULL
);
441 clear_bit(HCI_RUNNING
, &hdev
->flags
);
444 write_unlock_irqrestore(&bfusb
->lock
, flags
);
449 static int bfusb_flush(struct hci_dev
*hdev
)
451 struct bfusb
*bfusb
= (struct bfusb
*) hdev
->driver_data
;
453 BT_DBG("hdev %p bfusb %p", hdev
, bfusb
);
455 skb_queue_purge(&bfusb
->transmit_q
);
460 static int bfusb_close(struct hci_dev
*hdev
)
462 struct bfusb
*bfusb
= (struct bfusb
*) hdev
->driver_data
;
465 BT_DBG("hdev %p bfusb %p", hdev
, bfusb
);
467 if (!test_and_clear_bit(HCI_RUNNING
, &hdev
->flags
))
470 write_lock_irqsave(&bfusb
->lock
, flags
);
471 write_unlock_irqrestore(&bfusb
->lock
, flags
);
473 bfusb_unlink_urbs(bfusb
);
479 static int bfusb_send_frame(struct sk_buff
*skb
)
481 struct hci_dev
*hdev
= (struct hci_dev
*) skb
->dev
;
483 struct sk_buff
*nskb
;
484 unsigned char buf
[3];
485 int sent
= 0, size
, count
;
487 BT_DBG("hdev %p skb %p type %d len %d", hdev
, skb
, bt_cb(skb
)->pkt_type
, skb
->len
);
490 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
494 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
497 bfusb
= (struct bfusb
*) hdev
->driver_data
;
499 switch (bt_cb(skb
)->pkt_type
) {
500 case HCI_COMMAND_PKT
:
503 case HCI_ACLDATA_PKT
:
506 case HCI_SCODATA_PKT
:
511 /* Prepend skb with frame type */
512 memcpy(skb_push(skb
, 1), &bt_cb(skb
)->pkt_type
, 1);
516 /* Max HCI frame size seems to be 1511 + 1 */
517 if (!(nskb
= bt_skb_alloc(count
+ 32, GFP_ATOMIC
))) {
518 BT_ERR("Can't allocate memory for new packet");
522 nskb
->dev
= (void *) bfusb
;
525 size
= min_t(uint
, count
, BFUSB_MAX_BLOCK_SIZE
);
527 buf
[0] = 0xc1 | ((sent
== 0) ? 0x04 : 0) | ((count
== size
) ? 0x08 : 0);
529 buf
[2] = (size
== BFUSB_MAX_BLOCK_SIZE
) ? 0 : size
;
531 memcpy(skb_put(nskb
, 3), buf
, 3);
532 memcpy(skb_put(nskb
, size
), skb
->data
+ sent
, size
);
538 /* Don't send frame with multiple size of bulk max packet */
539 if ((nskb
->len
% bfusb
->bulk_pkt_size
) == 0) {
542 memcpy(skb_put(nskb
, 2), buf
, 2);
545 read_lock(&bfusb
->lock
);
547 skb_queue_tail(&bfusb
->transmit_q
, nskb
);
548 bfusb_tx_wakeup(bfusb
);
550 read_unlock(&bfusb
->lock
);
557 static void bfusb_destruct(struct hci_dev
*hdev
)
559 struct bfusb
*bfusb
= (struct bfusb
*) hdev
->driver_data
;
561 BT_DBG("hdev %p bfusb %p", hdev
, bfusb
);
566 static int bfusb_ioctl(struct hci_dev
*hdev
, unsigned int cmd
, unsigned long arg
)
572 static int bfusb_load_firmware(struct bfusb
*bfusb
, unsigned char *firmware
, int count
)
575 int err
, pipe
, len
, size
, sent
= 0;
577 BT_DBG("bfusb %p udev %p", bfusb
, bfusb
->udev
);
579 BT_INFO("BlueFRITZ! USB loading firmware");
581 pipe
= usb_sndctrlpipe(bfusb
->udev
, 0);
583 if (usb_control_msg(bfusb
->udev
, pipe
, USB_REQ_SET_CONFIGURATION
,
584 0, 1, 0, NULL
, 0, USB_CTRL_SET_TIMEOUT
) < 0) {
585 BT_ERR("Can't change to loading configuration");
589 bfusb
->udev
->toggle
[0] = bfusb
->udev
->toggle
[1] = 0;
591 buf
= kmalloc(BFUSB_MAX_BLOCK_SIZE
+ 3, GFP_ATOMIC
);
593 BT_ERR("Can't allocate memory chunk for firmware");
597 pipe
= usb_sndbulkpipe(bfusb
->udev
, bfusb
->bulk_out_ep
);
600 size
= min_t(uint
, count
, BFUSB_MAX_BLOCK_SIZE
+ 3);
602 memcpy(buf
, firmware
+ sent
, size
);
604 err
= usb_bulk_msg(bfusb
->udev
, pipe
, buf
, size
,
605 &len
, BFUSB_BLOCK_TIMEOUT
);
607 if (err
|| (len
!= size
)) {
608 BT_ERR("Error in firmware loading");
616 if ((err
= usb_bulk_msg(bfusb
->udev
, pipe
, NULL
, 0,
617 &len
, BFUSB_BLOCK_TIMEOUT
)) < 0) {
618 BT_ERR("Error in null packet request");
622 pipe
= usb_sndctrlpipe(bfusb
->udev
, 0);
624 if ((err
= usb_control_msg(bfusb
->udev
, pipe
, USB_REQ_SET_CONFIGURATION
,
625 0, 2, 0, NULL
, 0, USB_CTRL_SET_TIMEOUT
)) < 0) {
626 BT_ERR("Can't change to running configuration");
630 bfusb
->udev
->toggle
[0] = bfusb
->udev
->toggle
[1] = 0;
632 BT_INFO("BlueFRITZ! USB device ready");
640 pipe
= usb_sndctrlpipe(bfusb
->udev
, 0);
642 usb_control_msg(bfusb
->udev
, pipe
, USB_REQ_SET_CONFIGURATION
,
643 0, 0, 0, NULL
, 0, USB_CTRL_SET_TIMEOUT
);
648 static int bfusb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
650 const struct firmware
*firmware
;
651 struct usb_device
*udev
= interface_to_usbdev(intf
);
652 struct usb_host_endpoint
*bulk_out_ep
;
653 struct usb_host_endpoint
*bulk_in_ep
;
654 struct hci_dev
*hdev
;
657 BT_DBG("intf %p id %p", intf
, id
);
662 /* Check number of endpoints */
663 if (intf
->cur_altsetting
->desc
.bNumEndpoints
< 2)
666 bulk_out_ep
= &intf
->cur_altsetting
->endpoint
[0];
667 bulk_in_ep
= &intf
->cur_altsetting
->endpoint
[1];
669 if (!bulk_out_ep
|| !bulk_in_ep
) {
670 BT_ERR("Bulk endpoints not found");
674 /* Initialize control structure and load firmware */
675 if (!(bfusb
= kzalloc(sizeof(struct bfusb
), GFP_KERNEL
))) {
676 BT_ERR("Can't allocate memory for control structure");
681 bfusb
->bulk_in_ep
= bulk_in_ep
->desc
.bEndpointAddress
;
682 bfusb
->bulk_out_ep
= bulk_out_ep
->desc
.bEndpointAddress
;
683 bfusb
->bulk_pkt_size
= le16_to_cpu(bulk_out_ep
->desc
.wMaxPacketSize
);
685 rwlock_init(&bfusb
->lock
);
687 bfusb
->reassembly
= NULL
;
689 skb_queue_head_init(&bfusb
->transmit_q
);
690 skb_queue_head_init(&bfusb
->pending_q
);
691 skb_queue_head_init(&bfusb
->completed_q
);
693 if (request_firmware(&firmware
, "bfubase.frm", &udev
->dev
) < 0) {
694 BT_ERR("Firmware request failed");
698 BT_DBG("firmware data %p size %d", firmware
->data
, firmware
->size
);
700 if (bfusb_load_firmware(bfusb
, firmware
->data
, firmware
->size
) < 0) {
701 BT_ERR("Firmware loading failed");
705 release_firmware(firmware
);
707 /* Initialize and register HCI device */
708 hdev
= hci_alloc_dev();
710 BT_ERR("Can't allocate HCI device");
716 hdev
->type
= HCI_USB
;
717 hdev
->driver_data
= bfusb
;
718 SET_HCIDEV_DEV(hdev
, &intf
->dev
);
720 hdev
->open
= bfusb_open
;
721 hdev
->close
= bfusb_close
;
722 hdev
->flush
= bfusb_flush
;
723 hdev
->send
= bfusb_send_frame
;
724 hdev
->destruct
= bfusb_destruct
;
725 hdev
->ioctl
= bfusb_ioctl
;
727 hdev
->owner
= THIS_MODULE
;
729 if (hci_register_dev(hdev
) < 0) {
730 BT_ERR("Can't register HCI device");
735 usb_set_intfdata(intf
, bfusb
);
740 release_firmware(firmware
);
749 static void bfusb_disconnect(struct usb_interface
*intf
)
751 struct bfusb
*bfusb
= usb_get_intfdata(intf
);
752 struct hci_dev
*hdev
= bfusb
->hdev
;
754 BT_DBG("intf %p", intf
);
759 usb_set_intfdata(intf
, NULL
);
763 if (hci_unregister_dev(hdev
) < 0)
764 BT_ERR("Can't unregister HCI device %s", hdev
->name
);
769 static struct usb_driver bfusb_driver
= {
771 .probe
= bfusb_probe
,
772 .disconnect
= bfusb_disconnect
,
773 .id_table
= bfusb_table
,
776 static int __init
bfusb_init(void)
780 BT_INFO("BlueFRITZ! USB driver ver %s", VERSION
);
782 if ((err
= usb_register(&bfusb_driver
)) < 0)
783 BT_ERR("Failed to register BlueFRITZ! USB driver");
788 static void __exit
bfusb_exit(void)
790 usb_deregister(&bfusb_driver
);
793 module_init(bfusb_init
);
794 module_exit(bfusb_exit
);
796 module_param(ignore
, bool, 0644);
797 MODULE_PARM_DESC(ignore
, "Ignore devices from the matching table");
799 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
800 MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION
);
801 MODULE_VERSION(VERSION
);
802 MODULE_LICENSE("GPL");