URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [bluetooth/] [bfusb.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 *
 *  AVM BlueFRITZ! USB driver
 *
 *  Copyright (C) 2003-2006  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
 
#include <linux/module.h>
 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
 
#include <linux/device.h>
#include <linux/firmware.h>
 
#include <linux/usb.h>
 
#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
 
#ifndef CONFIG_BT_HCIBFUSB_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif
 
#define VERSION "1.1"
 
static int ignore = 0;
 
static struct usb_driver bfusb_driver;
 
static struct usb_device_id bfusb_table[] = {
        /* AVM BlueFRITZ! USB */
        { USB_DEVICE(0x057c, 0x2200) },
 
        { }     /* Terminating entry */
};
 
MODULE_DEVICE_TABLE(usb, bfusb_table);
 
#define BFUSB_MAX_BLOCK_SIZE    256
 
#define BFUSB_BLOCK_TIMEOUT     3000
 
#define BFUSB_TX_PROCESS        1
#define BFUSB_TX_WAKEUP         2
 
#define BFUSB_MAX_BULK_TX       2
#define BFUSB_MAX_BULK_RX       2
 
struct bfusb_data {
        struct hci_dev          *hdev;
 
        unsigned long           state;
 
        struct usb_device       *udev;
 
        unsigned int            bulk_in_ep;
        unsigned int            bulk_out_ep;
        unsigned int            bulk_pkt_size;
 
        rwlock_t                lock;
 
        struct sk_buff_head     transmit_q;
 
        struct sk_buff          *reassembly;
 
        atomic_t                pending_tx;
        struct sk_buff_head     pending_q;
        struct sk_buff_head     completed_q;
};
 
struct bfusb_data_scb {
        struct urb *urb;
};
 
static void bfusb_tx_complete(struct urb *urb);
static void bfusb_rx_complete(struct urb *urb);
 
static struct urb *bfusb_get_completed(struct bfusb_data *data)
{
        struct sk_buff *skb;
        struct urb *urb = NULL;
 
        BT_DBG("bfusb %p", data);
 
        skb = skb_dequeue(&data->completed_q);
        if (skb) {
                urb = ((struct bfusb_data_scb *) skb->cb)->urb;
                kfree_skb(skb);
        }
 
        return urb;
}
 
static void bfusb_unlink_urbs(struct bfusb_data *data)
{
        struct sk_buff *skb;
        struct urb *urb;
 
        BT_DBG("bfusb %p", data);
 
        while ((skb = skb_dequeue(&data->pending_q))) {
                urb = ((struct bfusb_data_scb *) skb->cb)->urb;
                usb_kill_urb(urb);
                skb_queue_tail(&data->completed_q, skb);
        }
 
        while ((urb = bfusb_get_completed(data)))
                usb_free_urb(urb);
}
 
static int bfusb_send_bulk(struct bfusb_data *data, struct sk_buff *skb)
{
        struct bfusb_data_scb *scb = (void *) skb->cb;
        struct urb *urb = bfusb_get_completed(data);
        int err, pipe;
 
        BT_DBG("bfusb %p skb %p len %d", data, skb, skb->len);
 
        if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
                return -ENOMEM;
 
        pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);
 
        usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, skb->len,
                        bfusb_tx_complete, skb);
 
        scb->urb = urb;
 
        skb_queue_tail(&data->pending_q, skb);
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err) {
                BT_ERR("%s bulk tx submit failed urb %p err %d",
                                        data->hdev->name, urb, err);
                skb_unlink(skb, &data->pending_q);
                usb_free_urb(urb);
        } else
                atomic_inc(&data->pending_tx);
 
        return err;
}
 
static void bfusb_tx_wakeup(struct bfusb_data *data)
{
        struct sk_buff *skb;
 
        BT_DBG("bfusb %p", data);
 
        if (test_and_set_bit(BFUSB_TX_PROCESS, &data->state)) {
                set_bit(BFUSB_TX_WAKEUP, &data->state);
                return;
        }
 
        do {
                clear_bit(BFUSB_TX_WAKEUP, &data->state);
 
                while ((atomic_read(&data->pending_tx) < BFUSB_MAX_BULK_TX) &&
                                (skb = skb_dequeue(&data->transmit_q))) {
                        if (bfusb_send_bulk(data, skb) < 0) {
                                skb_queue_head(&data->transmit_q, skb);
                                break;
                        }
                }
 
        } while (test_bit(BFUSB_TX_WAKEUP, &data->state));
 
        clear_bit(BFUSB_TX_PROCESS, &data->state);
}
 
static void bfusb_tx_complete(struct urb *urb)
{
        struct sk_buff *skb = (struct sk_buff *) urb->context;
        struct bfusb_data *data = (struct bfusb_data *) skb->dev;
 
        BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len);
 
        atomic_dec(&data->pending_tx);
 
        if (!test_bit(HCI_RUNNING, &data->hdev->flags))
                return;
 
        if (!urb->status)
                data->hdev->stat.byte_tx += skb->len;
        else
                data->hdev->stat.err_tx++;
 
        read_lock(&data->lock);
 
        skb_unlink(skb, &data->pending_q);
        skb_queue_tail(&data->completed_q, skb);
 
        bfusb_tx_wakeup(data);
 
        read_unlock(&data->lock);
}
 
 
static int bfusb_rx_submit(struct bfusb_data *data, struct urb *urb)
{
        struct bfusb_data_scb *scb;
        struct sk_buff *skb;
        int err, pipe, size = HCI_MAX_FRAME_SIZE + 32;
 
        BT_DBG("bfusb %p urb %p", bfusb, urb);
 
        if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
                return -ENOMEM;
 
        skb = bt_skb_alloc(size, GFP_ATOMIC);
        if (!skb) {
                usb_free_urb(urb);
                return -ENOMEM;
        }
 
        skb->dev = (void *) data;
 
        scb = (struct bfusb_data_scb *) skb->cb;
        scb->urb = urb;
 
        pipe = usb_rcvbulkpipe(data->udev, data->bulk_in_ep);
 
        usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, size,
                        bfusb_rx_complete, skb);
 
        skb_queue_tail(&data->pending_q, skb);
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err) {
                BT_ERR("%s bulk rx submit failed urb %p err %d",
                                        data->hdev->name, urb, err);
                skb_unlink(skb, &data->pending_q);
                kfree_skb(skb);
                usb_free_urb(urb);
        }
 
        return err;
}
 
static inline int bfusb_recv_block(struct bfusb_data *data, int hdr, unsigned char *buf, int len)
{
        BT_DBG("bfusb %p hdr 0x%02x data %p len %d", data, hdr, buf, len);
 
        if (hdr & 0x10) {
                BT_ERR("%s error in block", data->hdev->name);
                if (data->reassembly)
                        kfree_skb(data->reassembly);
                data->reassembly = NULL;
                return -EIO;
        }
 
        if (hdr & 0x04) {
                struct sk_buff *skb;
                unsigned char pkt_type;
                int pkt_len = 0;
 
                if (data->reassembly) {
                        BT_ERR("%s unexpected start block", data->hdev->name);
                        kfree_skb(data->reassembly);
                        data->reassembly = NULL;
                }
 
                if (len < 1) {
                        BT_ERR("%s no packet type found", data->hdev->name);
                        return -EPROTO;
                }
 
                pkt_type = *buf++; len--;
 
                switch (pkt_type) {
                case HCI_EVENT_PKT:
                        if (len >= HCI_EVENT_HDR_SIZE) {
                                struct hci_event_hdr *hdr = (struct hci_event_hdr *) buf;
                                pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;
                        } else {
                                BT_ERR("%s event block is too short", data->hdev->name);
                                return -EILSEQ;
                        }
                        break;
 
                case HCI_ACLDATA_PKT:
                        if (len >= HCI_ACL_HDR_SIZE) {
                                struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) buf;
                                pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);
                        } else {
                                BT_ERR("%s data block is too short", data->hdev->name);
                                return -EILSEQ;
                        }
                        break;
 
                case HCI_SCODATA_PKT:
                        if (len >= HCI_SCO_HDR_SIZE) {
                                struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) buf;
                                pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;
                        } else {
                                BT_ERR("%s audio block is too short", data->hdev->name);
                                return -EILSEQ;
                        }
                        break;
                }
 
                skb = bt_skb_alloc(pkt_len, GFP_ATOMIC);
                if (!skb) {
                        BT_ERR("%s no memory for the packet", data->hdev->name);
                        return -ENOMEM;
                }
 
                skb->dev = (void *) data->hdev;
                bt_cb(skb)->pkt_type = pkt_type;
 
                data->reassembly = skb;
        } else {
                if (!data->reassembly) {
                        BT_ERR("%s unexpected continuation block", data->hdev->name);
                        return -EIO;
                }
        }
 
        if (len > 0)
                memcpy(skb_put(data->reassembly, len), buf, len);
 
        if (hdr & 0x08) {
                hci_recv_frame(data->reassembly);
                data->reassembly = NULL;
        }
 
        return 0;
}
 
static void bfusb_rx_complete(struct urb *urb)
{
        struct sk_buff *skb = (struct sk_buff *) urb->context;
        struct bfusb_data *data = (struct bfusb_data *) skb->dev;
        unsigned char *buf = urb->transfer_buffer;
        int count = urb->actual_length;
        int err, hdr, len;
 
        BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
 
        read_lock(&data->lock);
 
        if (!test_bit(HCI_RUNNING, &data->hdev->flags))
                goto unlock;
 
        if (urb->status || !count)
                goto resubmit;
 
        data->hdev->stat.byte_rx += count;
 
        skb_put(skb, count);
 
        while (count) {
                hdr = buf[0] | (buf[1] << 8);
 
                if (hdr & 0x4000) {
                        len = 0;
                        count -= 2;
                        buf   += 2;
                } else {
                        len = (buf[2] == 0) ? 256 : buf[2];
                        count -= 3;
                        buf   += 3;
                }
 
                if (count < len) {
                        BT_ERR("%s block extends over URB buffer ranges",
                                        data->hdev->name);
                }
 
                if ((hdr & 0xe1) == 0xc1)
                        bfusb_recv_block(data, hdr, buf, len);
 
                count -= len;
                buf   += len;
        }
 
        skb_unlink(skb, &data->pending_q);
        kfree_skb(skb);
 
        bfusb_rx_submit(data, urb);
 
        read_unlock(&data->lock);
 
        return;
 
resubmit:
        urb->dev = data->udev;
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err) {
                BT_ERR("%s bulk resubmit failed urb %p err %d",
                                        data->hdev->name, urb, err);
        }
 
unlock:
        read_unlock(&data->lock);
}
 
static int bfusb_open(struct hci_dev *hdev)
{
        struct bfusb_data *data = hdev->driver_data;
        unsigned long flags;
        int i, err;
 
        BT_DBG("hdev %p bfusb %p", hdev, data);
 
        if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
                return 0;
 
        write_lock_irqsave(&data->lock, flags);
 
        err = bfusb_rx_submit(data, NULL);
        if (!err) {
                for (i = 1; i < BFUSB_MAX_BULK_RX; i++)
                        bfusb_rx_submit(data, NULL);
        } else {
                clear_bit(HCI_RUNNING, &hdev->flags);
        }
 
        write_unlock_irqrestore(&data->lock, flags);
 
        return err;
}
 
static int bfusb_flush(struct hci_dev *hdev)
{
        struct bfusb_data *data = hdev->driver_data;
 
        BT_DBG("hdev %p bfusb %p", hdev, data);
 
        skb_queue_purge(&data->transmit_q);
 
        return 0;
}
 
static int bfusb_close(struct hci_dev *hdev)
{
        struct bfusb_data *data = hdev->driver_data;
        unsigned long flags;
 
        BT_DBG("hdev %p bfusb %p", hdev, data);
 
        if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
                return 0;
 
        write_lock_irqsave(&data->lock, flags);
        write_unlock_irqrestore(&data->lock, flags);
 
        bfusb_unlink_urbs(data);
        bfusb_flush(hdev);
 
        return 0;
}
 
static int bfusb_send_frame(struct sk_buff *skb)
{
        struct hci_dev *hdev = (struct hci_dev *) skb->dev;
        struct bfusb_data *data;
        struct sk_buff *nskb;
        unsigned char buf[3];
        int sent = 0, size, count;
 
        BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len);
 
        if (!hdev) {
                BT_ERR("Frame for unknown HCI device (hdev=NULL)");
                return -ENODEV;
        }
 
        if (!test_bit(HCI_RUNNING, &hdev->flags))
                return -EBUSY;
 
        data = hdev->driver_data;
 
        switch (bt_cb(skb)->pkt_type) {
        case HCI_COMMAND_PKT:
                hdev->stat.cmd_tx++;
                break;
        case HCI_ACLDATA_PKT:
                hdev->stat.acl_tx++;
                break;
        case HCI_SCODATA_PKT:
                hdev->stat.sco_tx++;
                break;
        };
 
        /* Prepend skb with frame type */
        memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 
        count = skb->len;
 
        /* Max HCI frame size seems to be 1511 + 1 */
        nskb = bt_skb_alloc(count + 32, GFP_ATOMIC);
        if (!nskb) {
                BT_ERR("Can't allocate memory for new packet");
                return -ENOMEM;
        }
 
        nskb->dev = (void *) data;
 
        while (count) {
                size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE);
 
                buf[0] = 0xc1 | ((sent == 0) ? 0x04 : 0) | ((count == size) ? 0x08 : 0);
                buf[1] = 0x00;
                buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size;
 
                memcpy(skb_put(nskb, 3), buf, 3);
                skb_copy_from_linear_data_offset(skb, sent, skb_put(nskb, size), size);
 
                sent  += size;
                count -= size;
        }
 
        /* Don't send frame with multiple size of bulk max packet */
        if ((nskb->len % data->bulk_pkt_size) == 0) {
                buf[0] = 0xdd;
                buf[1] = 0x00;
                memcpy(skb_put(nskb, 2), buf, 2);
        }
 
        read_lock(&data->lock);
 
        skb_queue_tail(&data->transmit_q, nskb);
        bfusb_tx_wakeup(data);
 
        read_unlock(&data->lock);
 
        kfree_skb(skb);
 
        return 0;
}
 
static void bfusb_destruct(struct hci_dev *hdev)
{
        struct bfusb_data *data = hdev->driver_data;
 
        BT_DBG("hdev %p bfusb %p", hdev, data);
 
        kfree(data);
}
 
static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
{
        return -ENOIOCTLCMD;
}
 
static int bfusb_load_firmware(struct bfusb_data *data, unsigned char *firmware, int count)
{
        unsigned char *buf;
        int err, pipe, len, size, sent = 0;
 
        BT_DBG("bfusb %p udev %p", data, data->udev);
 
        BT_INFO("BlueFRITZ! USB loading firmware");
 
        pipe = usb_sndctrlpipe(data->udev, 0);
 
        if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
                                0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {
                BT_ERR("Can't change to loading configuration");
                return -EBUSY;
        }
 
        data->udev->toggle[0] = data->udev->toggle[1] = 0;
 
        buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);
        if (!buf) {
                BT_ERR("Can't allocate memory chunk for firmware");
                return -ENOMEM;
        }
 
        pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);
 
        while (count) {
                size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);
 
                memcpy(buf, firmware + sent, size);
 
                err = usb_bulk_msg(data->udev, pipe, buf, size,
                                        &len, BFUSB_BLOCK_TIMEOUT);
 
                if (err || (len != size)) {
                        BT_ERR("Error in firmware loading");
                        goto error;
                }
 
                sent  += size;
                count -= size;
        }
 
        err = usb_bulk_msg(data->udev, pipe, NULL, 0,
                                        &len, BFUSB_BLOCK_TIMEOUT);
        if (err < 0) {
                BT_ERR("Error in null packet request");
                goto error;
        }
 
        pipe = usb_sndctrlpipe(data->udev, 0);
 
        err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
                                0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
        if (err < 0) {
                BT_ERR("Can't change to running configuration");
                goto error;
        }
 
        data->udev->toggle[0] = data->udev->toggle[1] = 0;
 
        BT_INFO("BlueFRITZ! USB device ready");
 
        kfree(buf);
        return 0;
 
error:
        kfree(buf);
 
        pipe = usb_sndctrlpipe(data->udev, 0);
 
        usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
                                0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 
        return err;
}
 
static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
        const struct firmware *firmware;
        struct usb_device *udev = interface_to_usbdev(intf);
        struct usb_host_endpoint *bulk_out_ep;
        struct usb_host_endpoint *bulk_in_ep;
        struct hci_dev *hdev;
        struct bfusb_data *data;
 
        BT_DBG("intf %p id %p", intf, id);
 
        if (ignore)
                return -ENODEV;
 
        /* Check number of endpoints */
        if (intf->cur_altsetting->desc.bNumEndpoints < 2)
                return -EIO;
 
        bulk_out_ep = &intf->cur_altsetting->endpoint[0];
        bulk_in_ep  = &intf->cur_altsetting->endpoint[1];
 
        if (!bulk_out_ep || !bulk_in_ep) {
                BT_ERR("Bulk endpoints not found");
                goto done;
        }
 
        /* Initialize control structure and load firmware */
        data = kzalloc(sizeof(struct bfusb_data), GFP_KERNEL);
        if (!data) {
                BT_ERR("Can't allocate memory for control structure");
                goto done;
        }
 
        data->udev = udev;
        data->bulk_in_ep    = bulk_in_ep->desc.bEndpointAddress;
        data->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;
        data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
 
        rwlock_init(&data->lock);
 
        data->reassembly = NULL;
 
        skb_queue_head_init(&data->transmit_q);
        skb_queue_head_init(&data->pending_q);
        skb_queue_head_init(&data->completed_q);
 
        if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {
                BT_ERR("Firmware request failed");
                goto error;
        }
 
        BT_DBG("firmware data %p size %d", firmware->data, firmware->size);
 
        if (bfusb_load_firmware(data, firmware->data, firmware->size) < 0) {
                BT_ERR("Firmware loading failed");
                goto release;
        }
 
        release_firmware(firmware);
 
        /* Initialize and register HCI device */
        hdev = hci_alloc_dev();
        if (!hdev) {
                BT_ERR("Can't allocate HCI device");
                goto error;
        }
 
        data->hdev = hdev;
 
        hdev->type = HCI_USB;
        hdev->driver_data = data;
        SET_HCIDEV_DEV(hdev, &intf->dev);
 
        hdev->open     = bfusb_open;
        hdev->close    = bfusb_close;
        hdev->flush    = bfusb_flush;
        hdev->send     = bfusb_send_frame;
        hdev->destruct = bfusb_destruct;
        hdev->ioctl    = bfusb_ioctl;
 
        hdev->owner = THIS_MODULE;
 
        if (hci_register_dev(hdev) < 0) {
                BT_ERR("Can't register HCI device");
                hci_free_dev(hdev);
                goto error;
        }
 
        usb_set_intfdata(intf, data);
 
        return 0;
 
release:
        release_firmware(firmware);
 
error:
        kfree(data);
 
done:
        return -EIO;
}
 
static void bfusb_disconnect(struct usb_interface *intf)
{
        struct bfusb_data *data = usb_get_intfdata(intf);
        struct hci_dev *hdev = data->hdev;
 
        BT_DBG("intf %p", intf);
 
        if (!hdev)
                return;
 
        usb_set_intfdata(intf, NULL);
 
        bfusb_close(hdev);
 
        if (hci_unregister_dev(hdev) < 0)
                BT_ERR("Can't unregister HCI device %s", hdev->name);
 
        hci_free_dev(hdev);
}
 
static struct usb_driver bfusb_driver = {
        .name           = "bfusb",
        .probe          = bfusb_probe,
        .disconnect     = bfusb_disconnect,
        .id_table       = bfusb_table,
};
 
static int __init bfusb_init(void)
{
        int err;
 
        BT_INFO("BlueFRITZ! USB driver ver %s", VERSION);
 
        err = usb_register(&bfusb_driver);
        if (err < 0)
                BT_ERR("Failed to register BlueFRITZ! USB driver");
 
        return err;
}
 
static void __exit bfusb_exit(void)
{
        usb_deregister(&bfusb_driver);
}
 
module_init(bfusb_init);
module_exit(bfusb_exit);
 
module_param(ignore, bool, 0644);
MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
 
MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_FIRMWARE("bfubase.frm");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [bluetooth/] [bfusb.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`*`
3			`* AVM BlueFRITZ! USB driver`
4			`*`
5			`* Copyright (C) 2003-2006 Marcel Holtmann <marcel@holtmann.org>`
6			`*`
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 as published by`
10			`* the Free Software Foundation; either version 2 of the License, or`
11			`* (at your option) any later version.`
12			`*`
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.`
17			`*`
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`
21			`*`
22			`*/`
23
24			`#include <linux/module.h>`
25
26			`#include <linux/kernel.h>`
27			`#include <linux/init.h>`
28			`#include <linux/slab.h>`
29			`#include <linux/types.h>`
30			`#include <linux/errno.h>`
31			`#include <linux/skbuff.h>`
32
33			`#include <linux/device.h>`
34			`#include <linux/firmware.h>`
35
36			`#include <linux/usb.h>`
37
38			`#include <net/bluetooth/bluetooth.h>`
39			`#include <net/bluetooth/hci_core.h>`
40
41			`#ifndef CONFIG_BT_HCIBFUSB_DEBUG`
42			`#undef BT_DBG`
43			`#define BT_DBG(D...)`
44			`#endif`
45
46			`#define VERSION "1.1"`
47
48			`static int ignore = 0;`
49
50			`static struct usb_driver bfusb_driver;`
51
52			`static struct usb_device_id bfusb_table[] = {`
53			`/* AVM BlueFRITZ! USB */`
54			`{ USB_DEVICE(0x057c, 0x2200) },`
55
56			`{ } /* Terminating entry */`
57			`};`
58
59			`MODULE_DEVICE_TABLE(usb, bfusb_table);`
60
61			`#define BFUSB_MAX_BLOCK_SIZE 256`
62
63			`#define BFUSB_BLOCK_TIMEOUT 3000`
64
65			`#define BFUSB_TX_PROCESS 1`
66			`#define BFUSB_TX_WAKEUP 2`
67
68			`#define BFUSB_MAX_BULK_TX 2`
69			`#define BFUSB_MAX_BULK_RX 2`
70
71			`struct bfusb_data {`
72			`struct hci_dev *hdev;`
73
74			`unsigned long state;`
75
76			`struct usb_device *udev;`
77
78			`unsigned int bulk_in_ep;`
79			`unsigned int bulk_out_ep;`
80			`unsigned int bulk_pkt_size;`
81
82			`rwlock_t lock;`
83
84			`struct sk_buff_head transmit_q;`
85
86			`struct sk_buff *reassembly;`
87
88			`atomic_t pending_tx;`
89			`struct sk_buff_head pending_q;`
90			`struct sk_buff_head completed_q;`
91			`};`
92
93			`struct bfusb_data_scb {`
94			`struct urb *urb;`
95			`};`
96
97			`static void bfusb_tx_complete(struct urb *urb);`
98			`static void bfusb_rx_complete(struct urb *urb);`
99
100			`static struct urb bfusb_get_completed(struct bfusb_data data)`
101			`{`
102			`struct sk_buff *skb;`
103			`struct urb *urb = NULL;`
104
105			`BT_DBG("bfusb %p", data);`
106
107			`skb = skb_dequeue(&data->completed_q);`
108			`if (skb) {`
109			`urb = ((struct bfusb_data_scb *) skb->cb)->urb;`
110			`kfree_skb(skb);`
111			`}`
112
113			`return urb;`
114			`}`
115
116			`static void bfusb_unlink_urbs(struct bfusb_data *data)`
117			`{`
118			`struct sk_buff *skb;`
119			`struct urb *urb;`
120
121			`BT_DBG("bfusb %p", data);`
122
123			`while ((skb = skb_dequeue(&data->pending_q))) {`
124			`urb = ((struct bfusb_data_scb *) skb->cb)->urb;`
125			`usb_kill_urb(urb);`
126			`skb_queue_tail(&data->completed_q, skb);`
127			`}`
128
129			`while ((urb = bfusb_get_completed(data)))`
130			`usb_free_urb(urb);`
131			`}`
132
133			`static int bfusb_send_bulk(struct bfusb_data data, struct sk_buff skb)`
134			`{`
135			`struct bfusb_data_scb scb = (void ) skb->cb;`
136			`struct urb *urb = bfusb_get_completed(data);`
137			`int err, pipe;`
138
139			`BT_DBG("bfusb %p skb %p len %d", data, skb, skb->len);`
140
141			`if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))`
142			`return -ENOMEM;`
143
144			`pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);`
145
146			`usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, skb->len,`
147			`bfusb_tx_complete, skb);`
148
149			`scb->urb = urb;`
150
151			`skb_queue_tail(&data->pending_q, skb);`
152
153			`err = usb_submit_urb(urb, GFP_ATOMIC);`
154			`if (err) {`
155			`BT_ERR("%s bulk tx submit failed urb %p err %d",`
156			`data->hdev->name, urb, err);`
157			`skb_unlink(skb, &data->pending_q);`
158			`usb_free_urb(urb);`
159			`} else`
160			`atomic_inc(&data->pending_tx);`
161
162			`return err;`
163			`}`
164
165			`static void bfusb_tx_wakeup(struct bfusb_data *data)`
166			`{`
167			`struct sk_buff *skb;`
168
169			`BT_DBG("bfusb %p", data);`
170
171			`if (test_and_set_bit(BFUSB_TX_PROCESS, &data->state)) {`
172			`set_bit(BFUSB_TX_WAKEUP, &data->state);`
173			`return;`
174			`}`
175
176			`do {`
177			`clear_bit(BFUSB_TX_WAKEUP, &data->state);`
178
179			`while ((atomic_read(&data->pending_tx) < BFUSB_MAX_BULK_TX) &&`
180			`(skb = skb_dequeue(&data->transmit_q))) {`
181			`if (bfusb_send_bulk(data, skb) < 0) {`
182			`skb_queue_head(&data->transmit_q, skb);`
183			`break;`
184			`}`
185			`}`
186
187			`} while (test_bit(BFUSB_TX_WAKEUP, &data->state));`
188
189			`clear_bit(BFUSB_TX_PROCESS, &data->state);`
190			`}`
191
192			`static void bfusb_tx_complete(struct urb *urb)`
193			`{`
194			`struct sk_buff skb = (struct sk_buff ) urb->context;`
195			`struct bfusb_data data = (struct bfusb_data ) skb->dev;`
196
197			`BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len);`
198
199			`atomic_dec(&data->pending_tx);`
200
201			`if (!test_bit(HCI_RUNNING, &data->hdev->flags))`
202			`return;`
203
204			`if (!urb->status)`
205			`data->hdev->stat.byte_tx += skb->len;`
206			`else`
207			`data->hdev->stat.err_tx++;`
208
209			`read_lock(&data->lock);`
210
211			`skb_unlink(skb, &data->pending_q);`
212			`skb_queue_tail(&data->completed_q, skb);`
213
214			`bfusb_tx_wakeup(data);`
215
216			`read_unlock(&data->lock);`
217			`}`
218
219
220			`static int bfusb_rx_submit(struct bfusb_data data, struct urb urb)`
221			`{`
222			`struct bfusb_data_scb *scb;`
223			`struct sk_buff *skb;`
224			`int err, pipe, size = HCI_MAX_FRAME_SIZE + 32;`
225
226			`BT_DBG("bfusb %p urb %p", bfusb, urb);`
227
228			`if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))`
229			`return -ENOMEM;`
230
231			`skb = bt_skb_alloc(size, GFP_ATOMIC);`
232			`if (!skb) {`
233			`usb_free_urb(urb);`
234			`return -ENOMEM;`
235			`}`
236
237			`skb->dev = (void *) data;`
238
239			`scb = (struct bfusb_data_scb *) skb->cb;`
240			`scb->urb = urb;`
241
242			`pipe = usb_rcvbulkpipe(data->udev, data->bulk_in_ep);`
243
244			`usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, size,`
245			`bfusb_rx_complete, skb);`
246
247			`skb_queue_tail(&data->pending_q, skb);`
248
249			`err = usb_submit_urb(urb, GFP_ATOMIC);`
250			`if (err) {`
251			`BT_ERR("%s bulk rx submit failed urb %p err %d",`
252			`data->hdev->name, urb, err);`
253			`skb_unlink(skb, &data->pending_q);`
254			`kfree_skb(skb);`
255			`usb_free_urb(urb);`
256			`}`
257
258			`return err;`
259			`}`
260
261			`static inline int bfusb_recv_block(struct bfusb_data data, int hdr, unsigned char buf, int len)`
262			`{`
263			`BT_DBG("bfusb %p hdr 0x%02x data %p len %d", data, hdr, buf, len);`
264
265			`if (hdr & 0x10) {`
266			`BT_ERR("%s error in block", data->hdev->name);`
267			`if (data->reassembly)`
268			`kfree_skb(data->reassembly);`
269			`data->reassembly = NULL;`
270			`return -EIO;`
271			`}`
272
273			`if (hdr & 0x04) {`
274			`struct sk_buff *skb;`
275			`unsigned char pkt_type;`
276			`int pkt_len = 0;`
277
278			`if (data->reassembly) {`
279			`BT_ERR("%s unexpected start block", data->hdev->name);`
280			`kfree_skb(data->reassembly);`
281			`data->reassembly = NULL;`
282			`}`
283
284			`if (len < 1) {`
285			`BT_ERR("%s no packet type found", data->hdev->name);`
286			`return -EPROTO;`
287			`}`
288
289			`pkt_type = *buf++; len--;`
290
291			`switch (pkt_type) {`
292			`case HCI_EVENT_PKT:`
293			`if (len >= HCI_EVENT_HDR_SIZE) {`
294			`struct hci_event_hdr hdr = (struct hci_event_hdr ) buf;`
295			`pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;`
296			`} else {`
297			`BT_ERR("%s event block is too short", data->hdev->name);`
298			`return -EILSEQ;`
299			`}`
300			`break;`
301
302			`case HCI_ACLDATA_PKT:`
303			`if (len >= HCI_ACL_HDR_SIZE) {`
304			`struct hci_acl_hdr hdr = (struct hci_acl_hdr ) buf;`
305			`pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);`
306			`} else {`
307			`BT_ERR("%s data block is too short", data->hdev->name);`
308			`return -EILSEQ;`
309			`}`
310			`break;`
311
312			`case HCI_SCODATA_PKT:`
313			`if (len >= HCI_SCO_HDR_SIZE) {`
314			`struct hci_sco_hdr hdr = (struct hci_sco_hdr ) buf;`
315			`pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;`
316			`} else {`
317			`BT_ERR("%s audio block is too short", data->hdev->name);`
318			`return -EILSEQ;`
319			`}`
320			`break;`
321			`}`
322
323			`skb = bt_skb_alloc(pkt_len, GFP_ATOMIC);`
324			`if (!skb) {`
325			`BT_ERR("%s no memory for the packet", data->hdev->name);`
326			`return -ENOMEM;`
327			`}`
328
329			`skb->dev = (void *) data->hdev;`
330			`bt_cb(skb)->pkt_type = pkt_type;`
331
332			`data->reassembly = skb;`
333			`} else {`
334			`if (!data->reassembly) {`
335			`BT_ERR("%s unexpected continuation block", data->hdev->name);`
336			`return -EIO;`
337			`}`
338			`}`
339
340			`if (len > 0)`
341			`memcpy(skb_put(data->reassembly, len), buf, len);`
342
343			`if (hdr & 0x08) {`
344			`hci_recv_frame(data->reassembly);`
345			`data->reassembly = NULL;`
346			`}`
347
348			`return 0;`
349			`}`
350
351			`static void bfusb_rx_complete(struct urb *urb)`
352			`{`
353			`struct sk_buff skb = (struct sk_buff ) urb->context;`
354			`struct bfusb_data data = (struct bfusb_data ) skb->dev;`
355			`unsigned char *buf = urb->transfer_buffer;`
356			`int count = urb->actual_length;`
357			`int err, hdr, len;`
358
359			`BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);`
360
361			`read_lock(&data->lock);`
362
363			`if (!test_bit(HCI_RUNNING, &data->hdev->flags))`
364			`goto unlock;`
365
366			`if (urb->status \|\| !count)`
367			`goto resubmit;`
368
369			`data->hdev->stat.byte_rx += count;`
370
371			`skb_put(skb, count);`
372
373			`while (count) {`
374			`hdr = buf[0] \| (buf[1] << 8);`
375
376			`if (hdr & 0x4000) {`
377			`len = 0;`
378			`count -= 2;`
379			`buf += 2;`
380			`} else {`
381			`len = (buf[2] == 0) ? 256 : buf[2];`
382			`count -= 3;`
383			`buf += 3;`
384			`}`
385
386			`if (count < len) {`
387			`BT_ERR("%s block extends over URB buffer ranges",`
388			`data->hdev->name);`
389			`}`
390
391			`if ((hdr & 0xe1) == 0xc1)`
392			`bfusb_recv_block(data, hdr, buf, len);`
393
394			`count -= len;`
395			`buf += len;`
396			`}`
397
398			`skb_unlink(skb, &data->pending_q);`
399			`kfree_skb(skb);`
400
401			`bfusb_rx_submit(data, urb);`
402
403			`read_unlock(&data->lock);`
404
405			`return;`
406
407			`resubmit:`
408			`urb->dev = data->udev;`
409
410			`err = usb_submit_urb(urb, GFP_ATOMIC);`
411			`if (err) {`
412			`BT_ERR("%s bulk resubmit failed urb %p err %d",`
413			`data->hdev->name, urb, err);`
414			`}`
415
416			`unlock:`
417			`read_unlock(&data->lock);`
418			`}`
419
420			`static int bfusb_open(struct hci_dev *hdev)`
421			`{`
422			`struct bfusb_data *data = hdev->driver_data;`
423			`unsigned long flags;`
424			`int i, err;`
425
426			`BT_DBG("hdev %p bfusb %p", hdev, data);`
427
428			`if (test_and_set_bit(HCI_RUNNING, &hdev->flags))`
429			`return 0;`
430
431			`write_lock_irqsave(&data->lock, flags);`
432
433			`err = bfusb_rx_submit(data, NULL);`
434			`if (!err) {`
435			`for (i = 1; i < BFUSB_MAX_BULK_RX; i++)`
436			`bfusb_rx_submit(data, NULL);`
437			`} else {`
438			`clear_bit(HCI_RUNNING, &hdev->flags);`
439			`}`
440
441			`write_unlock_irqrestore(&data->lock, flags);`
442
443			`return err;`
444			`}`
445
446			`static int bfusb_flush(struct hci_dev *hdev)`
447			`{`
448			`struct bfusb_data *data = hdev->driver_data;`
449
450			`BT_DBG("hdev %p bfusb %p", hdev, data);`
451
452			`skb_queue_purge(&data->transmit_q);`
453
454			`return 0;`
455			`}`
456
457			`static int bfusb_close(struct hci_dev *hdev)`
458			`{`
459			`struct bfusb_data *data = hdev->driver_data;`
460			`unsigned long flags;`
461
462			`BT_DBG("hdev %p bfusb %p", hdev, data);`
463
464			`if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))`
465			`return 0;`
466
467			`write_lock_irqsave(&data->lock, flags);`
468			`write_unlock_irqrestore(&data->lock, flags);`
469
470			`bfusb_unlink_urbs(data);`
471			`bfusb_flush(hdev);`
472
473			`return 0;`
474			`}`
475
476			`static int bfusb_send_frame(struct sk_buff *skb)`
477			`{`
478			`struct hci_dev hdev = (struct hci_dev ) skb->dev;`
479			`struct bfusb_data *data;`
480			`struct sk_buff *nskb;`
481			`unsigned char buf[3];`
482			`int sent = 0, size, count;`
483
484			`BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len);`
485
486			`if (!hdev) {`
487			`BT_ERR("Frame for unknown HCI device (hdev=NULL)");`
488			`return -ENODEV;`
489			`}`
490
491			`if (!test_bit(HCI_RUNNING, &hdev->flags))`
492			`return -EBUSY;`
493
494			`data = hdev->driver_data;`
495
496			`switch (bt_cb(skb)->pkt_type) {`
497			`case HCI_COMMAND_PKT:`
498			`hdev->stat.cmd_tx++;`
499			`break;`
500			`case HCI_ACLDATA_PKT:`
501			`hdev->stat.acl_tx++;`
502			`break;`
503			`case HCI_SCODATA_PKT:`
504			`hdev->stat.sco_tx++;`
505			`break;`
506			`};`
507
508			`/* Prepend skb with frame type */`
509			`memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);`
510
511			`count = skb->len;`
512
513			`/* Max HCI frame size seems to be 1511 + 1 */`
514			`nskb = bt_skb_alloc(count + 32, GFP_ATOMIC);`
515			`if (!nskb) {`
516			`BT_ERR("Can't allocate memory for new packet");`
517			`return -ENOMEM;`
518			`}`
519
520			`nskb->dev = (void *) data;`
521
522			`while (count) {`
523			`size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE);`
524
525			`buf[0] = 0xc1 \| ((sent == 0) ? 0x04 : 0) \| ((count == size) ? 0x08 : 0);`
526			`buf[1] = 0x00;`
527			`buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size;`
528
529			`memcpy(skb_put(nskb, 3), buf, 3);`
530			`skb_copy_from_linear_data_offset(skb, sent, skb_put(nskb, size), size);`
531
532			`sent += size;`
533			`count -= size;`
534			`}`
535
536			`/* Don't send frame with multiple size of bulk max packet */`
537			`if ((nskb->len % data->bulk_pkt_size) == 0) {`
538			`buf[0] = 0xdd;`
539			`buf[1] = 0x00;`
540			`memcpy(skb_put(nskb, 2), buf, 2);`
541			`}`
542
543			`read_lock(&data->lock);`
544
545			`skb_queue_tail(&data->transmit_q, nskb);`
546			`bfusb_tx_wakeup(data);`
547
548			`read_unlock(&data->lock);`
549
550			`kfree_skb(skb);`
551
552			`return 0;`
553			`}`
554
555			`static void bfusb_destruct(struct hci_dev *hdev)`
556			`{`
557			`struct bfusb_data *data = hdev->driver_data;`
558
559			`BT_DBG("hdev %p bfusb %p", hdev, data);`
560
561			`kfree(data);`
562			`}`
563
564			`static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)`
565			`{`
566			`return -ENOIOCTLCMD;`
567			`}`
568
569			`static int bfusb_load_firmware(struct bfusb_data data, unsigned char firmware, int count)`
570			`{`
571			`unsigned char *buf;`
572			`int err, pipe, len, size, sent = 0;`
573
574			`BT_DBG("bfusb %p udev %p", data, data->udev);`
575
576			`BT_INFO("BlueFRITZ! USB loading firmware");`
577
578			`pipe = usb_sndctrlpipe(data->udev, 0);`
579
580			`if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,`
581			`0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {`
582			`BT_ERR("Can't change to loading configuration");`
583			`return -EBUSY;`
584			`}`
585
586			`data->udev->toggle[0] = data->udev->toggle[1] = 0;`
587
588			`buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);`
589			`if (!buf) {`
590			`BT_ERR("Can't allocate memory chunk for firmware");`
591			`return -ENOMEM;`
592			`}`
593
594			`pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);`
595
596			`while (count) {`
597			`size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);`
598
599			`memcpy(buf, firmware + sent, size);`
600
601			`err = usb_bulk_msg(data->udev, pipe, buf, size,`
602			`&len, BFUSB_BLOCK_TIMEOUT);`
603
604			`if (err \|\| (len != size)) {`
605			`BT_ERR("Error in firmware loading");`
606			`goto error;`
607			`}`
608
609			`sent += size;`
610			`count -= size;`
611			`}`
612
613			`err = usb_bulk_msg(data->udev, pipe, NULL, 0,`
614			`&len, BFUSB_BLOCK_TIMEOUT);`
615			`if (err < 0) {`
616			`BT_ERR("Error in null packet request");`
617			`goto error;`
618			`}`
619
620			`pipe = usb_sndctrlpipe(data->udev, 0);`
621
622			`err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,`
623			`0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);`
624			`if (err < 0) {`
625			`BT_ERR("Can't change to running configuration");`
626			`goto error;`
627			`}`
628
629			`data->udev->toggle[0] = data->udev->toggle[1] = 0;`
630
631			`BT_INFO("BlueFRITZ! USB device ready");`
632
633			`kfree(buf);`
634			`return 0;`
635
636			`error:`
637			`kfree(buf);`
638
639			`pipe = usb_sndctrlpipe(data->udev, 0);`
640
641			`usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,`
642			`0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);`
643
644			`return err;`
645			`}`
646
647			`static int bfusb_probe(struct usb_interface intf, const struct usb_device_id id)`
648			`{`
649			`const struct firmware *firmware;`
650			`struct usb_device *udev = interface_to_usbdev(intf);`
651			`struct usb_host_endpoint *bulk_out_ep;`
652			`struct usb_host_endpoint *bulk_in_ep;`
653			`struct hci_dev *hdev;`
654			`struct bfusb_data *data;`
655
656			`BT_DBG("intf %p id %p", intf, id);`
657
658			`if (ignore)`
659			`return -ENODEV;`
660
661			`/* Check number of endpoints */`
662			`if (intf->cur_altsetting->desc.bNumEndpoints < 2)`
663			`return -EIO;`
664
665			`bulk_out_ep = &intf->cur_altsetting->endpoint[0];`
666			`bulk_in_ep = &intf->cur_altsetting->endpoint[1];`
667
668			`if (!bulk_out_ep \|\| !bulk_in_ep) {`
669			`BT_ERR("Bulk endpoints not found");`
670			`goto done;`
671			`}`
672
673			`/* Initialize control structure and load firmware */`
674			`data = kzalloc(sizeof(struct bfusb_data), GFP_KERNEL);`
675			`if (!data) {`
676			`BT_ERR("Can't allocate memory for control structure");`
677			`goto done;`
678			`}`
679
680			`data->udev = udev;`
681			`data->bulk_in_ep = bulk_in_ep->desc.bEndpointAddress;`
682			`data->bulk_out_ep = bulk_out_ep->desc.bEndpointAddress;`
683			`data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);`
684
685			`rwlock_init(&data->lock);`
686
687			`data->reassembly = NULL;`
688
689			`skb_queue_head_init(&data->transmit_q);`
690			`skb_queue_head_init(&data->pending_q);`
691			`skb_queue_head_init(&data->completed_q);`
692
693			`if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {`
694			`BT_ERR("Firmware request failed");`
695			`goto error;`
696			`}`
697
698			`BT_DBG("firmware data %p size %d", firmware->data, firmware->size);`
699
700			`if (bfusb_load_firmware(data, firmware->data, firmware->size) < 0) {`
701			`BT_ERR("Firmware loading failed");`
702			`goto release;`
703			`}`
704
705			`release_firmware(firmware);`
706
707			`/* Initialize and register HCI device */`
708			`hdev = hci_alloc_dev();`
709			`if (!hdev) {`
710			`BT_ERR("Can't allocate HCI device");`
711			`goto error;`
712			`}`
713
714			`data->hdev = hdev;`
715
716			`hdev->type = HCI_USB;`
717			`hdev->driver_data = data;`
718			`SET_HCIDEV_DEV(hdev, &intf->dev);`
719
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;`
726
727			`hdev->owner = THIS_MODULE;`
728
729			`if (hci_register_dev(hdev) < 0) {`
730			`BT_ERR("Can't register HCI device");`
731			`hci_free_dev(hdev);`
732			`goto error;`
733			`}`
734
735			`usb_set_intfdata(intf, data);`
736
737			`return 0;`
738
739			`release:`
740			`release_firmware(firmware);`
741
742			`error:`
743			`kfree(data);`
744
745			`done:`
746			`return -EIO;`
747			`}`
748
749			`static void bfusb_disconnect(struct usb_interface *intf)`
750			`{`
751			`struct bfusb_data *data = usb_get_intfdata(intf);`
752			`struct hci_dev *hdev = data->hdev;`
753
754			`BT_DBG("intf %p", intf);`
755
756			`if (!hdev)`
757			`return;`
758
759			`usb_set_intfdata(intf, NULL);`
760
761			`bfusb_close(hdev);`
762
763			`if (hci_unregister_dev(hdev) < 0)`
764			`BT_ERR("Can't unregister HCI device %s", hdev->name);`
765
766			`hci_free_dev(hdev);`
767			`}`
768
769			`static struct usb_driver bfusb_driver = {`
770			`.name = "bfusb",`
771			`.probe = bfusb_probe,`
772			`.disconnect = bfusb_disconnect,`
773			`.id_table = bfusb_table,`
774			`};`
775
776			`static int __init bfusb_init(void)`
777			`{`
778			`int err;`
779
780			`BT_INFO("BlueFRITZ! USB driver ver %s", VERSION);`
781
782			`err = usb_register(&bfusb_driver);`
783			`if (err < 0)`
784			`BT_ERR("Failed to register BlueFRITZ! USB driver");`
785
786			`return err;`
787			`}`
788
789			`static void __exit bfusb_exit(void)`
790			`{`
791			`usb_deregister(&bfusb_driver);`
792			`}`
793
794			`module_init(bfusb_init);`
795			`module_exit(bfusb_exit);`
796
797			`module_param(ignore, bool, 0644);`
798			`MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");`
799
800			`MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");`
801			`MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION);`
802			`MODULE_VERSION(VERSION);`
803			`MODULE_LICENSE("GPL");`
804			`MODULE_FIRMWARE("bfubase.frm");`