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/config.h>
25 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/types.h>
31 #include <linux/sched.h>
32 #include <linux/errno.h>
33 #include <linux/skbuff.h>
35 #include <linux/firmware.h>
36 #include <linux/usb.h>
38 #include <net/bluetooth/bluetooth.h>
39 #include <net/bluetooth/hci_core.h>
41 #ifndef CONFIG_BLUEZ_HCIBFUSB_DEBUG
48 static struct usb_device_id bfusb_table[] = {
49 /* AVM BlueFRITZ! USB */
50 { USB_DEVICE(0x057c, 0x2200) },
52 { } /* Terminating entry */
55 MODULE_DEVICE_TABLE(usb, bfusb_table);
58 #define BFUSB_MAX_BLOCK_SIZE 256
60 #define BFUSB_BLOCK_TIMEOUT (HZ * 3)
62 #define BFUSB_TX_PROCESS 1
63 #define BFUSB_TX_WAKEUP 2
65 #define BFUSB_MAX_BULK_TX 1
66 #define BFUSB_MAX_BULK_RX 1
73 struct usb_device *udev;
75 unsigned int bulk_in_ep;
76 unsigned int bulk_out_ep;
77 unsigned int bulk_pkt_size;
81 struct sk_buff_head transmit_q;
83 struct sk_buff *reassembly;
86 struct sk_buff_head pending_q;
87 struct sk_buff_head completed_q;
94 static void bfusb_tx_complete(struct urb *urb);
95 static void bfusb_rx_complete(struct urb *urb);
97 static struct urb *bfusb_get_completed(struct bfusb *bfusb)
100 struct urb *urb = NULL;
102 BT_DBG("bfusb %p", bfusb);
104 skb = skb_dequeue(&bfusb->completed_q);
106 urb = ((struct bfusb_scb *) skb->cb)->urb;
113 static inline void bfusb_unlink_urbs(struct bfusb *bfusb)
118 BT_DBG("bfusb %p", bfusb);
120 while ((skb = skb_dequeue(&bfusb->pending_q))) {
121 urb = ((struct bfusb_scb *) skb->cb)->urb;
123 skb_queue_tail(&bfusb->completed_q, skb);
126 while ((urb = bfusb_get_completed(bfusb)))
131 static int bfusb_send_bulk(struct bfusb *bfusb, struct sk_buff *skb)
133 struct bfusb_scb *scb = (void *) skb->cb;
134 struct urb *urb = bfusb_get_completed(bfusb);
137 BT_DBG("bfusb %p skb %p len %d", bfusb, skb, skb->len);
139 if (!urb && !(urb = usb_alloc_urb(0)))
142 pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
144 FILL_BULK_URB(urb, bfusb->udev, pipe, skb->data, skb->len,
145 bfusb_tx_complete, skb);
147 urb->transfer_flags = USB_QUEUE_BULK;
151 skb_queue_tail(&bfusb->pending_q, skb);
153 err = usb_submit_urb(urb);
155 BT_ERR("%s bulk tx submit failed urb %p err %d",
156 bfusb->hdev.name, urb, err);
160 atomic_inc(&bfusb->pending_tx);
165 static void bfusb_tx_wakeup(struct bfusb *bfusb)
169 BT_DBG("bfusb %p", bfusb);
171 if (test_and_set_bit(BFUSB_TX_PROCESS, &bfusb->state)) {
172 set_bit(BFUSB_TX_WAKEUP, &bfusb->state);
177 clear_bit(BFUSB_TX_WAKEUP, &bfusb->state);
179 while ((atomic_read(&bfusb->pending_tx) < BFUSB_MAX_BULK_TX) &&
180 (skb = skb_dequeue(&bfusb->transmit_q))) {
181 if (bfusb_send_bulk(bfusb, skb) < 0) {
182 skb_queue_head(&bfusb->transmit_q, skb);
187 } while (test_bit(BFUSB_TX_WAKEUP, &bfusb->state));
189 clear_bit(BFUSB_TX_PROCESS, &bfusb->state);
192 static void bfusb_tx_complete(struct urb *urb)
194 struct sk_buff *skb = (struct sk_buff *) urb->context;
195 struct bfusb *bfusb = (struct bfusb *) skb->dev;
197 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
199 atomic_dec(&bfusb->pending_tx);
201 if (!test_bit(HCI_RUNNING, &bfusb->hdev.flags))
205 bfusb->hdev.stat.byte_tx += skb->len;
207 bfusb->hdev.stat.err_tx++;
209 read_lock(&bfusb->lock);
212 skb_queue_tail(&bfusb->completed_q, skb);
214 bfusb_tx_wakeup(bfusb);
216 read_unlock(&bfusb->lock);
220 static int bfusb_rx_submit(struct bfusb *bfusb, struct urb *urb)
222 struct bfusb_scb *scb;
224 int err, pipe, size = HCI_MAX_FRAME_SIZE + 32;
226 BT_DBG("bfusb %p urb %p", bfusb, urb);
228 if (!urb && !(urb = usb_alloc_urb(0)))
231 if (!(skb = bluez_skb_alloc(size, GFP_ATOMIC))) {
236 skb->dev = (void *) bfusb;
238 scb = (struct bfusb_scb *) skb->cb;
241 pipe = usb_rcvbulkpipe(bfusb->udev, bfusb->bulk_in_ep);
243 FILL_BULK_URB(urb, bfusb->udev, pipe, skb->data, size,
244 bfusb_rx_complete, skb);
246 urb->transfer_flags = USB_QUEUE_BULK;
248 skb_queue_tail(&bfusb->pending_q, skb);
250 err = usb_submit_urb(urb);
252 BT_ERR("%s bulk rx submit failed urb %p err %d",
253 bfusb->hdev.name, urb, err);
262 static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *data, int len)
264 BT_DBG("bfusb %p hdr 0x%02x data %p len %d", bfusb, hdr, data, len);
267 BT_ERR("%s error in block", bfusb->hdev.name);
268 if (bfusb->reassembly)
269 kfree_skb(bfusb->reassembly);
270 bfusb->reassembly = NULL;
276 unsigned char pkt_type;
279 if (bfusb->reassembly) {
280 BT_ERR("%s unexpected start block", bfusb->hdev.name);
281 kfree_skb(bfusb->reassembly);
282 bfusb->reassembly = NULL;
286 BT_ERR("%s no packet type found", bfusb->hdev.name);
290 pkt_type = *data++; len--;
294 if (len >= HCI_EVENT_HDR_SIZE) {
295 hci_event_hdr *hdr = (hci_event_hdr *) data;
296 pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;
298 BT_ERR("%s event block is too short", bfusb->hdev.name);
303 case HCI_ACLDATA_PKT:
304 if (len >= HCI_ACL_HDR_SIZE) {
305 hci_acl_hdr *hdr = (hci_acl_hdr *) data;
306 pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);
308 BT_ERR("%s data block is too short", bfusb->hdev.name);
313 case HCI_SCODATA_PKT:
314 if (len >= HCI_SCO_HDR_SIZE) {
315 hci_sco_hdr *hdr = (hci_sco_hdr *) data;
316 pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;
318 BT_ERR("%s audio block is too short", bfusb->hdev.name);
324 skb = bluez_skb_alloc(pkt_len, GFP_ATOMIC);
326 BT_ERR("%s no memory for the packet", bfusb->hdev.name);
330 skb->dev = (void *) &bfusb->hdev;
331 skb->pkt_type = pkt_type;
333 bfusb->reassembly = skb;
335 if (!bfusb->reassembly) {
336 BT_ERR("%s unexpected continuation block", bfusb->hdev.name);
342 memcpy(skb_put(bfusb->reassembly, len), data, len);
345 hci_recv_frame(bfusb->reassembly);
346 bfusb->reassembly = NULL;
352 static void bfusb_rx_complete(struct urb *urb)
354 struct sk_buff *skb = (struct sk_buff *) urb->context;
355 struct bfusb *bfusb = (struct bfusb *) skb->dev;
356 unsigned char *buf = urb->transfer_buffer;
357 int count = urb->actual_length;
360 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
362 read_lock(&bfusb->lock);
364 if (!test_bit(HCI_RUNNING, &bfusb->hdev.flags))
367 if (urb->status || !count)
370 bfusb->hdev.stat.byte_rx += count;
375 hdr = buf[0] | (buf[1] << 8);
382 len = (buf[2] == 0) ? 256 : buf[2];
388 BT_ERR("%s block extends over URB buffer ranges",
392 if ((hdr & 0xe1) == 0xc1)
393 bfusb_recv_block(bfusb, hdr, buf, len);
402 bfusb_rx_submit(bfusb, urb);
404 read_unlock(&bfusb->lock);
409 urb->dev = bfusb->udev;
411 err = usb_submit_urb(urb);
413 BT_ERR("%s bulk resubmit failed urb %p err %d",
414 bfusb->hdev.name, urb, err);
418 read_unlock(&bfusb->lock);
422 static int bfusb_open(struct hci_dev *hdev)
424 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
428 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
430 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
435 write_lock_irqsave(&bfusb->lock, flags);
437 err = bfusb_rx_submit(bfusb, NULL);
439 for (i = 1; i < BFUSB_MAX_BULK_RX; i++)
440 bfusb_rx_submit(bfusb, NULL);
442 clear_bit(HCI_RUNNING, &hdev->flags);
446 write_unlock_irqrestore(&bfusb->lock, flags);
451 static int bfusb_flush(struct hci_dev *hdev)
453 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
455 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
457 skb_queue_purge(&bfusb->transmit_q);
462 static int bfusb_close(struct hci_dev *hdev)
464 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
467 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
469 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
472 write_lock_irqsave(&bfusb->lock, flags);
473 write_unlock_irqrestore(&bfusb->lock, flags);
475 bfusb_unlink_urbs(bfusb);
483 static int bfusb_send_frame(struct sk_buff *skb)
485 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
487 struct sk_buff *nskb;
488 unsigned char buf[3];
489 int sent = 0, size, count;
491 BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, skb->pkt_type, skb->len);
494 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
498 if (!test_bit(HCI_RUNNING, &hdev->flags))
501 bfusb = (struct bfusb *) hdev->driver_data;
503 switch (skb->pkt_type) {
504 case HCI_COMMAND_PKT:
507 case HCI_ACLDATA_PKT:
510 case HCI_SCODATA_PKT:
515 /* Prepend skb with frame type */
516 memcpy(skb_push(skb, 1), &(skb->pkt_type), 1);
520 /* Max HCI frame size seems to be 1511 + 1 */
521 if (!(nskb = bluez_skb_alloc(count + 32, GFP_ATOMIC))) {
522 BT_ERR("Can't allocate memory for new packet");
526 nskb->dev = (void *) bfusb;
529 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE);
531 buf[0] = 0xc1 | ((sent == 0) ? 0x04 : 0) | ((count == size) ? 0x08 : 0);
533 buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size;
535 memcpy(skb_put(nskb, 3), buf, 3);
536 memcpy(skb_put(nskb, size), skb->data + sent, size);
542 /* Don't send frame with multiple size of bulk max packet */
543 if ((nskb->len % bfusb->bulk_pkt_size) == 0) {
546 memcpy(skb_put(nskb, 2), buf, 2);
549 read_lock(&bfusb->lock);
551 skb_queue_tail(&bfusb->transmit_q, nskb);
552 bfusb_tx_wakeup(bfusb);
554 read_unlock(&bfusb->lock);
561 static void bfusb_destruct(struct hci_dev *hdev)
563 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
565 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
570 static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
576 static int bfusb_load_firmware(struct bfusb *bfusb, unsigned char *firmware, int count)
579 int err, pipe, len, size, sent = 0;
581 BT_DBG("bfusb %p udev %p firmware %p count %d", bfusb, bfusb->udev, firmware, count);
583 BT_INFO("BlueFRITZ! USB loading firmware");
585 if (usb_set_configuration(bfusb->udev, 1) < 0) {
586 BT_ERR("Can't change to loading configuration");
590 buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);
592 BT_ERR("Can't allocate memory chunk for firmware");
596 pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
599 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);
601 memcpy(buf, firmware + sent, size);
603 err = usb_bulk_msg(bfusb->udev, pipe, buf, size,
604 &len, BFUSB_BLOCK_TIMEOUT);
606 if (err || (len != size)) {
607 BT_ERR("Error in firmware loading");
615 if ((err = usb_bulk_msg(bfusb->udev, pipe, NULL, 0,
616 &len, BFUSB_BLOCK_TIMEOUT)) < 0) {
617 BT_ERR("Error in null packet request");
621 if ((err = usb_set_configuration(bfusb->udev, 2)) < 0) {
622 BT_ERR("Can't change to running configuration");
626 BT_INFO("BlueFRITZ! USB device ready");
634 pipe = usb_sndctrlpipe(bfusb->udev, 0);
636 usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
637 0, 0, 0, NULL, 0, BFUSB_BLOCK_TIMEOUT);
642 static void *bfusb_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id)
644 const struct firmware *firmware;
646 struct usb_interface *iface;
647 struct usb_interface_descriptor *iface_desc;
648 struct usb_endpoint_descriptor *bulk_out_ep;
649 struct usb_endpoint_descriptor *bulk_in_ep;
650 struct hci_dev *hdev;
653 BT_DBG("udev %p ifnum %d id %p", udev, ifnum, id);
655 /* Check number of endpoints */
656 iface = &udev->actconfig->interface[0];
657 iface_desc = &iface->altsetting[0];
659 if (iface_desc->bNumEndpoints < 2)
662 bulk_out_ep = &iface_desc->endpoint[0];
663 bulk_in_ep = &iface_desc->endpoint[1];
665 if (!bulk_out_ep || !bulk_in_ep) {
666 BT_ERR("Bulk endpoints not found");
670 /* Initialize control structure and load firmware */
671 if (!(bfusb = kmalloc(sizeof(struct bfusb), GFP_KERNEL))) {
672 BT_ERR("Can't allocate memory for control structure");
676 memset(bfusb, 0, sizeof(struct bfusb));
679 bfusb->bulk_in_ep = bulk_in_ep->bEndpointAddress;
680 bfusb->bulk_out_ep = bulk_out_ep->bEndpointAddress;
681 bfusb->bulk_pkt_size = bulk_out_ep->wMaxPacketSize;
683 bfusb->lock = RW_LOCK_UNLOCKED;
685 bfusb->reassembly = NULL;
687 skb_queue_head_init(&bfusb->transmit_q);
688 skb_queue_head_init(&bfusb->pending_q);
689 skb_queue_head_init(&bfusb->completed_q);
691 snprintf(device, sizeof(device), "bfusb%3.3d%3.3d", udev->bus->busnum, udev->devnum);
693 if (request_firmware(&firmware, "bfubase.frm", device) < 0) {
694 BT_ERR("Firmware request failed");
698 if (bfusb_load_firmware(bfusb, firmware->data, firmware->size) < 0) {
699 BT_ERR("Firmware loading failed");
703 release_firmware(firmware);
705 /* Initialize and register HCI device */
708 hdev->type = HCI_USB;
709 hdev->driver_data = bfusb;
711 hdev->open = bfusb_open;
712 hdev->close = bfusb_close;
713 hdev->flush = bfusb_flush;
714 hdev->send = bfusb_send_frame;
715 hdev->destruct = bfusb_destruct;
716 hdev->ioctl = bfusb_ioctl;
718 if (hci_register_dev(hdev) < 0) {
719 BT_ERR("Can't register HCI device");
726 release_firmware(firmware);
735 static void bfusb_disconnect(struct usb_device *udev, void *ptr)
737 struct bfusb *bfusb = (struct bfusb *) ptr;
738 struct hci_dev *hdev = &bfusb->hdev;
740 BT_DBG("udev %p ptr %p", udev, ptr);
747 if (hci_unregister_dev(hdev) < 0)
748 BT_ERR("Can't unregister HCI device %s", hdev->name);
751 static struct usb_driver bfusb_driver = {
754 disconnect: bfusb_disconnect,
755 id_table: bfusb_table,
758 static int __init bfusb_init(void)
762 BT_INFO("BlueFRITZ! USB driver ver %s", VERSION);
763 BT_INFO("Copyright (C) 2003 Marcel Holtmann <marcel@holtmann.org>");
765 if ((err = usb_register(&bfusb_driver)) < 0)
766 BT_ERR("Failed to register BlueFRITZ! USB driver");
771 static void __exit bfusb_cleanup(void)
773 usb_deregister(&bfusb_driver);
776 module_init(bfusb_init);
777 module_exit(bfusb_cleanup);
779 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
780 MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION);
781 MODULE_LICENSE("GPL");