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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [bluetooth/] [btusb.c] - Blame information for rev 67

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *
 *  Generic Bluetooth USB driver
 *
 *  Copyright (C) 2005-2007  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/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
 
#include <linux/usb.h>
 
#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
 
//#define CONFIG_BT_HCIBTUSB_DEBUG
#ifndef CONFIG_BT_HCIBTUSB_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif
 
#define VERSION "0.1"
 
static struct usb_device_id btusb_table[] = {
        /* Generic Bluetooth USB device */
        { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
 
        { }     /* Terminating entry */
};
 
MODULE_DEVICE_TABLE(usb, btusb_table);
 
static struct usb_device_id blacklist_table[] = {
        { }     /* Terminating entry */
};
 
#define BTUSB_INTR_RUNNING      0
#define BTUSB_BULK_RUNNING      1
 
struct btusb_data {
        struct hci_dev       *hdev;
        struct usb_device    *udev;
 
        spinlock_t lock;
 
        unsigned long flags;
 
        struct work_struct work;
 
        struct usb_anchor tx_anchor;
        struct usb_anchor intr_anchor;
        struct usb_anchor bulk_anchor;
 
        struct usb_endpoint_descriptor *intr_ep;
        struct usb_endpoint_descriptor *bulk_tx_ep;
        struct usb_endpoint_descriptor *bulk_rx_ep;
};
 
static void btusb_intr_complete(struct urb *urb)
{
        struct hci_dev *hdev = urb->context;
        struct btusb_data *data = hdev->driver_data;
        int err;
 
        BT_DBG("%s urb %p status %d count %d", hdev->name,
                                        urb, urb->status, urb->actual_length);
 
        if (!test_bit(HCI_RUNNING, &hdev->flags))
                return;
 
        if (urb->status == 0) {
                if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
                                                urb->transfer_buffer,
                                                urb->actual_length) < 0) {
                        BT_ERR("%s corrupted event packet", hdev->name);
                        hdev->stat.err_rx++;
                }
        }
 
        if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
                return;
 
        usb_anchor_urb(urb, &data->intr_anchor);
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err < 0) {
                BT_ERR("%s urb %p failed to resubmit (%d)",
                                                hdev->name, urb, -err);
                usb_unanchor_urb(urb);
        }
}
 
static inline int btusb_submit_intr_urb(struct hci_dev *hdev)
{
        struct btusb_data *data = hdev->driver_data;
        struct urb *urb;
        unsigned char *buf;
        unsigned int pipe;
        int err, size;
 
        BT_DBG("%s", hdev->name);
 
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb)
                return -ENOMEM;
 
        size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
 
        buf = kmalloc(size, GFP_ATOMIC);
        if (!buf) {
                usb_free_urb(urb);
                return -ENOMEM;
        }
 
        pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
 
        usb_fill_int_urb(urb, data->udev, pipe, buf, size,
                                                btusb_intr_complete, hdev,
                                                data->intr_ep->bInterval);
 
        urb->transfer_flags |= URB_FREE_BUFFER;
 
        usb_anchor_urb(urb, &data->intr_anchor);
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err < 0) {
                BT_ERR("%s urb %p submission failed (%d)",
                                                hdev->name, urb, -err);
                usb_unanchor_urb(urb);
                kfree(buf);
        }
 
        usb_free_urb(urb);
 
        return err;
}
 
static void btusb_bulk_complete(struct urb *urb)
{
        struct hci_dev *hdev = urb->context;
        struct btusb_data *data = hdev->driver_data;
        int err;
 
        BT_DBG("%s urb %p status %d count %d", hdev->name,
                                        urb, urb->status, urb->actual_length);
 
        if (!test_bit(HCI_RUNNING, &hdev->flags))
                return;
 
        if (urb->status == 0) {
                if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
                                                urb->transfer_buffer,
                                                urb->actual_length) < 0) {
                        BT_ERR("%s corrupted ACL packet", hdev->name);
                        hdev->stat.err_rx++;
                }
        }
 
        if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
                return;
 
        usb_anchor_urb(urb, &data->bulk_anchor);
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err < 0) {
                BT_ERR("%s urb %p failed to resubmit (%d)",
                                                hdev->name, urb, -err);
                usb_unanchor_urb(urb);
        }
}
 
static inline int btusb_submit_bulk_urb(struct hci_dev *hdev)
{
        struct btusb_data *data = hdev->driver_data;
        struct urb *urb;
        unsigned char *buf;
        unsigned int pipe;
        int err, size;
 
        BT_DBG("%s", hdev->name);
 
        urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!urb)
                return -ENOMEM;
 
        size = le16_to_cpu(data->bulk_rx_ep->wMaxPacketSize);
 
        buf = kmalloc(size, GFP_KERNEL);
        if (!buf) {
                usb_free_urb(urb);
                return -ENOMEM;
        }
 
        pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
 
        usb_fill_bulk_urb(urb, data->udev, pipe,
                                        buf, size, btusb_bulk_complete, hdev);
 
        urb->transfer_flags |= URB_FREE_BUFFER;
 
        usb_anchor_urb(urb, &data->bulk_anchor);
 
        err = usb_submit_urb(urb, GFP_KERNEL);
        if (err < 0) {
                BT_ERR("%s urb %p submission failed (%d)",
                                                hdev->name, urb, -err);
                usb_unanchor_urb(urb);
                kfree(buf);
        }
 
        usb_free_urb(urb);
 
        return err;
}
 
static void btusb_tx_complete(struct urb *urb)
{
        struct sk_buff *skb = urb->context;
        struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 
        BT_DBG("%s urb %p status %d count %d", hdev->name,
                                        urb, urb->status, urb->actual_length);
 
        if (!test_bit(HCI_RUNNING, &hdev->flags))
                goto done;
 
        if (!urb->status)
                hdev->stat.byte_tx += urb->transfer_buffer_length;
        else
                hdev->stat.err_tx++;
 
done:
        kfree(urb->setup_packet);
 
        kfree_skb(skb);
}
 
static int btusb_open(struct hci_dev *hdev)
{
        struct btusb_data *data = hdev->driver_data;
        int err;
 
        BT_DBG("%s", hdev->name);
 
        if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
                return 0;
 
        if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
                return 0;
 
        err = btusb_submit_intr_urb(hdev);
        if (err < 0) {
                clear_bit(BTUSB_INTR_RUNNING, &hdev->flags);
                clear_bit(HCI_RUNNING, &hdev->flags);
        }
 
        return err;
}
 
static int btusb_close(struct hci_dev *hdev)
{
        struct btusb_data *data = hdev->driver_data;
 
        BT_DBG("%s", hdev->name);
 
        if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
                return 0;
 
        clear_bit(BTUSB_BULK_RUNNING, &data->flags);
        usb_kill_anchored_urbs(&data->bulk_anchor);
 
        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
        usb_kill_anchored_urbs(&data->intr_anchor);
 
        return 0;
}
 
static int btusb_flush(struct hci_dev *hdev)
{
        struct btusb_data *data = hdev->driver_data;
 
        BT_DBG("%s", hdev->name);
 
        usb_kill_anchored_urbs(&data->tx_anchor);
 
        return 0;
}
 
static int btusb_send_frame(struct sk_buff *skb)
{
        struct hci_dev *hdev = (struct hci_dev *) skb->dev;
        struct btusb_data *data = hdev->driver_data;
        struct usb_ctrlrequest *dr;
        struct urb *urb;
        unsigned int pipe;
        int err;
 
        BT_DBG("%s", hdev->name);
 
        if (!test_bit(HCI_RUNNING, &hdev->flags))
                return -EBUSY;
 
        switch (bt_cb(skb)->pkt_type) {
        case HCI_COMMAND_PKT:
                urb = usb_alloc_urb(0, GFP_ATOMIC);
                if (!urb)
                        return -ENOMEM;
 
                dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
                if (!dr) {
                        usb_free_urb(urb);
                        return -ENOMEM;
                }
 
                dr->bRequestType = USB_TYPE_CLASS;
                dr->bRequest     = 0;
                dr->wIndex       = 0;
                dr->wValue       = 0;
                dr->wLength      = __cpu_to_le16(skb->len);
 
                pipe = usb_sndctrlpipe(data->udev, 0x00);
 
                usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
                                skb->data, skb->len, btusb_tx_complete, skb);
 
                hdev->stat.cmd_tx++;
                break;
 
        case HCI_ACLDATA_PKT:
                urb = usb_alloc_urb(0, GFP_ATOMIC);
                if (!urb)
                        return -ENOMEM;
 
                pipe = usb_sndbulkpipe(data->udev,
                                        data->bulk_tx_ep->bEndpointAddress);
 
                usb_fill_bulk_urb(urb, data->udev, pipe,
                                skb->data, skb->len, btusb_tx_complete, skb);
 
                hdev->stat.acl_tx++;
                break;
 
        case HCI_SCODATA_PKT:
                hdev->stat.sco_tx++;
                kfree_skb(skb);
                return 0;
 
        default:
                return -EILSEQ;
        }
 
        usb_anchor_urb(urb, &data->tx_anchor);
 
        err = usb_submit_urb(urb, GFP_ATOMIC);
        if (err < 0) {
                BT_ERR("%s urb %p submission failed", hdev->name, urb);
                kfree(urb->setup_packet);
                usb_unanchor_urb(urb);
        }
 
        usb_free_urb(urb);
 
        return err;
}
 
static void btusb_destruct(struct hci_dev *hdev)
{
        struct btusb_data *data = hdev->driver_data;
 
        BT_DBG("%s", hdev->name);
 
        kfree(data);
}
 
static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
{
        struct btusb_data *data = hdev->driver_data;
 
        BT_DBG("%s evt %d", hdev->name, evt);
 
        if (evt == HCI_NOTIFY_CONN_ADD || evt == HCI_NOTIFY_CONN_DEL)
                schedule_work(&data->work);
}
 
static void btusb_work(struct work_struct *work)
{
        struct btusb_data *data = container_of(work, struct btusb_data, work);
        struct hci_dev *hdev = data->hdev;
 
        if (hdev->conn_hash.acl_num == 0) {
                clear_bit(BTUSB_BULK_RUNNING, &data->flags);
                usb_kill_anchored_urbs(&data->bulk_anchor);
                return;
        }
 
        if (!test_and_set_bit(BTUSB_BULK_RUNNING, &data->flags)) {
                if (btusb_submit_bulk_urb(hdev) < 0)
                        clear_bit(BTUSB_BULK_RUNNING, &data->flags);
                else
                        btusb_submit_bulk_urb(hdev);
        }
}
 
static int btusb_probe(struct usb_interface *intf,
                                const struct usb_device_id *id)
{
        struct usb_endpoint_descriptor *ep_desc;
        struct btusb_data *data;
        struct hci_dev *hdev;
        int i, err;
 
        BT_DBG("intf %p id %p", intf, id);
 
        if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
                return -ENODEV;
 
        if (!id->driver_info) {
                const struct usb_device_id *match;
                match = usb_match_id(intf, blacklist_table);
                if (match)
                        id = match;
        }
 
        data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
 
        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
                ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 
                if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
                        data->intr_ep = ep_desc;
                        continue;
                }
 
                if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
                        data->bulk_tx_ep = ep_desc;
                        continue;
                }
 
                if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
                        data->bulk_rx_ep = ep_desc;
                        continue;
                }
        }
 
        if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {
                kfree(data);
                return -ENODEV;
        }
 
        data->udev = interface_to_usbdev(intf);
 
        spin_lock_init(&data->lock);
 
        INIT_WORK(&data->work, btusb_work);
 
        init_usb_anchor(&data->tx_anchor);
        init_usb_anchor(&data->intr_anchor);
        init_usb_anchor(&data->bulk_anchor);
 
        hdev = hci_alloc_dev();
        if (!hdev) {
                kfree(data);
                return -ENOMEM;
        }
 
        hdev->type = HCI_USB;
        hdev->driver_data = data;
 
        data->hdev = hdev;
 
        SET_HCIDEV_DEV(hdev, &intf->dev);
 
        hdev->open     = btusb_open;
        hdev->close    = btusb_close;
        hdev->flush    = btusb_flush;
        hdev->send     = btusb_send_frame;
        hdev->destruct = btusb_destruct;
        hdev->notify   = btusb_notify;
 
        hdev->owner = THIS_MODULE;
 
        set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
 
        err = hci_register_dev(hdev);
        if (err < 0) {
                hci_free_dev(hdev);
                kfree(data);
                return err;
        }
 
        usb_set_intfdata(intf, data);
 
        return 0;
}
 
static void btusb_disconnect(struct usb_interface *intf)
{
        struct btusb_data *data = usb_get_intfdata(intf);
        struct hci_dev *hdev;
 
        BT_DBG("intf %p", intf);
 
        if (!data)
                return;
 
        hdev = data->hdev;
 
        usb_set_intfdata(intf, NULL);
 
        hci_unregister_dev(hdev);
 
        hci_free_dev(hdev);
}
 
static struct usb_driver btusb_driver = {
        .name           = "btusb",
        .probe          = btusb_probe,
        .disconnect     = btusb_disconnect,
        .id_table       = btusb_table,
};
 
static int __init btusb_init(void)
{
        BT_INFO("Generic Bluetooth USB driver ver %s", VERSION);
 
        return usb_register(&btusb_driver);
}
 
static void __exit btusb_exit(void)
{
        usb_deregister(&btusb_driver);
}
 
module_init(btusb_init);
module_exit(btusb_exit);
 
MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [bluetooth/] [btusb.c] - Blame information for rev 67

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`*`
3			`* Generic Bluetooth USB driver`
4			`*`
5			`* Copyright (C) 2005-2007 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/kernel.h>`
25			`#include <linux/module.h>`
26			`#include <linux/init.h>`
27			`#include <linux/slab.h>`
28			`#include <linux/types.h>`
29			`#include <linux/sched.h>`
30			`#include <linux/errno.h>`
31			`#include <linux/skbuff.h>`
32
33			`#include <linux/usb.h>`
34
35			`#include <net/bluetooth/bluetooth.h>`
36			`#include <net/bluetooth/hci_core.h>`
37
38			`//#define CONFIG_BT_HCIBTUSB_DEBUG`
39			`#ifndef CONFIG_BT_HCIBTUSB_DEBUG`
40			`#undef BT_DBG`
41			`#define BT_DBG(D...)`
42			`#endif`
43
44			`#define VERSION "0.1"`
45
46			`static struct usb_device_id btusb_table[] = {`
47			`/* Generic Bluetooth USB device */`
48			`{ USB_DEVICE_INFO(0xe0, 0x01, 0x01) },`
49
50			`{ } /* Terminating entry */`
51			`};`
52
53			`MODULE_DEVICE_TABLE(usb, btusb_table);`
54
55			`static struct usb_device_id blacklist_table[] = {`
56			`{ } /* Terminating entry */`
57			`};`
58
59			`#define BTUSB_INTR_RUNNING 0`
60			`#define BTUSB_BULK_RUNNING 1`
61
62			`struct btusb_data {`
63			`struct hci_dev *hdev;`
64			`struct usb_device *udev;`
65
66			`spinlock_t lock;`
67
68			`unsigned long flags;`
69
70			`struct work_struct work;`
71
72			`struct usb_anchor tx_anchor;`
73			`struct usb_anchor intr_anchor;`
74			`struct usb_anchor bulk_anchor;`
75
76			`struct usb_endpoint_descriptor *intr_ep;`
77			`struct usb_endpoint_descriptor *bulk_tx_ep;`
78			`struct usb_endpoint_descriptor *bulk_rx_ep;`
79			`};`
80
81			`static void btusb_intr_complete(struct urb *urb)`
82			`{`
83			`struct hci_dev *hdev = urb->context;`
84			`struct btusb_data *data = hdev->driver_data;`
85			`int err;`
86
87			`BT_DBG("%s urb %p status %d count %d", hdev->name,`
88			`urb, urb->status, urb->actual_length);`
89
90			`if (!test_bit(HCI_RUNNING, &hdev->flags))`
91			`return;`
92
93			`if (urb->status == 0) {`
94			`if (hci_recv_fragment(hdev, HCI_EVENT_PKT,`
95			`urb->transfer_buffer,`
96			`urb->actual_length) < 0) {`
97			`BT_ERR("%s corrupted event packet", hdev->name);`
98			`hdev->stat.err_rx++;`
99			`}`
100			`}`
101
102			`if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))`
103			`return;`
104
105			`usb_anchor_urb(urb, &data->intr_anchor);`
106
107			`err = usb_submit_urb(urb, GFP_ATOMIC);`
108			`if (err < 0) {`
109			`BT_ERR("%s urb %p failed to resubmit (%d)",`
110			`hdev->name, urb, -err);`
111			`usb_unanchor_urb(urb);`
112			`}`
113			`}`
114
115			`static inline int btusb_submit_intr_urb(struct hci_dev *hdev)`
116			`{`
117			`struct btusb_data *data = hdev->driver_data;`
118			`struct urb *urb;`
119			`unsigned char *buf;`
120			`unsigned int pipe;`
121			`int err, size;`
122
123			`BT_DBG("%s", hdev->name);`
124
125			`urb = usb_alloc_urb(0, GFP_ATOMIC);`
126			`if (!urb)`
127			`return -ENOMEM;`
128
129			`size = le16_to_cpu(data->intr_ep->wMaxPacketSize);`
130
131			`buf = kmalloc(size, GFP_ATOMIC);`
132			`if (!buf) {`
133			`usb_free_urb(urb);`
134			`return -ENOMEM;`
135			`}`
136
137			`pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);`
138
139			`usb_fill_int_urb(urb, data->udev, pipe, buf, size,`
140			`btusb_intr_complete, hdev,`
141			`data->intr_ep->bInterval);`
142
143			`urb->transfer_flags \|= URB_FREE_BUFFER;`
144
145			`usb_anchor_urb(urb, &data->intr_anchor);`
146
147			`err = usb_submit_urb(urb, GFP_ATOMIC);`
148			`if (err < 0) {`
149			`BT_ERR("%s urb %p submission failed (%d)",`
150			`hdev->name, urb, -err);`
151			`usb_unanchor_urb(urb);`
152			`kfree(buf);`
153			`}`
154
155			`usb_free_urb(urb);`
156
157			`return err;`
158			`}`
159
160			`static void btusb_bulk_complete(struct urb *urb)`
161			`{`
162			`struct hci_dev *hdev = urb->context;`
163			`struct btusb_data *data = hdev->driver_data;`
164			`int err;`
165
166			`BT_DBG("%s urb %p status %d count %d", hdev->name,`
167			`urb, urb->status, urb->actual_length);`
168
169			`if (!test_bit(HCI_RUNNING, &hdev->flags))`
170			`return;`
171
172			`if (urb->status == 0) {`
173			`if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,`
174			`urb->transfer_buffer,`
175			`urb->actual_length) < 0) {`
176			`BT_ERR("%s corrupted ACL packet", hdev->name);`
177			`hdev->stat.err_rx++;`
178			`}`
179			`}`
180
181			`if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))`
182			`return;`
183
184			`usb_anchor_urb(urb, &data->bulk_anchor);`
185
186			`err = usb_submit_urb(urb, GFP_ATOMIC);`
187			`if (err < 0) {`
188			`BT_ERR("%s urb %p failed to resubmit (%d)",`
189			`hdev->name, urb, -err);`
190			`usb_unanchor_urb(urb);`
191			`}`
192			`}`
193
194			`static inline int btusb_submit_bulk_urb(struct hci_dev *hdev)`
195			`{`
196			`struct btusb_data *data = hdev->driver_data;`
197			`struct urb *urb;`
198			`unsigned char *buf;`
199			`unsigned int pipe;`
200			`int err, size;`
201
202			`BT_DBG("%s", hdev->name);`
203
204			`urb = usb_alloc_urb(0, GFP_KERNEL);`
205			`if (!urb)`
206			`return -ENOMEM;`
207
208			`size = le16_to_cpu(data->bulk_rx_ep->wMaxPacketSize);`
209
210			`buf = kmalloc(size, GFP_KERNEL);`
211			`if (!buf) {`
212			`usb_free_urb(urb);`
213			`return -ENOMEM;`
214			`}`
215
216			`pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);`
217
218			`usb_fill_bulk_urb(urb, data->udev, pipe,`
219			`buf, size, btusb_bulk_complete, hdev);`
220
221			`urb->transfer_flags \|= URB_FREE_BUFFER;`
222
223			`usb_anchor_urb(urb, &data->bulk_anchor);`
224
225			`err = usb_submit_urb(urb, GFP_KERNEL);`
226			`if (err < 0) {`
227			`BT_ERR("%s urb %p submission failed (%d)",`
228			`hdev->name, urb, -err);`
229			`usb_unanchor_urb(urb);`
230			`kfree(buf);`
231			`}`
232
233			`usb_free_urb(urb);`
234
235			`return err;`
236			`}`
237
238			`static void btusb_tx_complete(struct urb *urb)`
239			`{`
240			`struct sk_buff *skb = urb->context;`
241			`struct hci_dev hdev = (struct hci_dev ) skb->dev;`
242
243			`BT_DBG("%s urb %p status %d count %d", hdev->name,`
244			`urb, urb->status, urb->actual_length);`
245
246			`if (!test_bit(HCI_RUNNING, &hdev->flags))`
247			`goto done;`
248
249			`if (!urb->status)`
250			`hdev->stat.byte_tx += urb->transfer_buffer_length;`
251			`else`
252			`hdev->stat.err_tx++;`
253
254			`done:`
255			`kfree(urb->setup_packet);`
256
257			`kfree_skb(skb);`
258			`}`
259
260			`static int btusb_open(struct hci_dev *hdev)`
261			`{`
262			`struct btusb_data *data = hdev->driver_data;`
263			`int err;`
264
265			`BT_DBG("%s", hdev->name);`
266
267			`if (test_and_set_bit(HCI_RUNNING, &hdev->flags))`
268			`return 0;`
269
270			`if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))`
271			`return 0;`
272
273			`err = btusb_submit_intr_urb(hdev);`
274			`if (err < 0) {`
275			`clear_bit(BTUSB_INTR_RUNNING, &hdev->flags);`
276			`clear_bit(HCI_RUNNING, &hdev->flags);`
277			`}`
278
279			`return err;`
280			`}`
281
282			`static int btusb_close(struct hci_dev *hdev)`
283			`{`
284			`struct btusb_data *data = hdev->driver_data;`
285
286			`BT_DBG("%s", hdev->name);`
287
288			`if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))`
289			`return 0;`
290
291			`clear_bit(BTUSB_BULK_RUNNING, &data->flags);`
292			`usb_kill_anchored_urbs(&data->bulk_anchor);`
293
294			`clear_bit(BTUSB_INTR_RUNNING, &data->flags);`
295			`usb_kill_anchored_urbs(&data->intr_anchor);`
296
297			`return 0;`
298			`}`
299
300			`static int btusb_flush(struct hci_dev *hdev)`
301			`{`
302			`struct btusb_data *data = hdev->driver_data;`
303
304			`BT_DBG("%s", hdev->name);`
305
306			`usb_kill_anchored_urbs(&data->tx_anchor);`
307
308			`return 0;`
309			`}`
310
311			`static int btusb_send_frame(struct sk_buff *skb)`
312			`{`
313			`struct hci_dev hdev = (struct hci_dev ) skb->dev;`
314			`struct btusb_data *data = hdev->driver_data;`
315			`struct usb_ctrlrequest *dr;`
316			`struct urb *urb;`
317			`unsigned int pipe;`
318			`int err;`
319
320			`BT_DBG("%s", hdev->name);`
321
322			`if (!test_bit(HCI_RUNNING, &hdev->flags))`
323			`return -EBUSY;`
324
325			`switch (bt_cb(skb)->pkt_type) {`
326			`case HCI_COMMAND_PKT:`
327			`urb = usb_alloc_urb(0, GFP_ATOMIC);`
328			`if (!urb)`
329			`return -ENOMEM;`
330
331			`dr = kmalloc(sizeof(*dr), GFP_ATOMIC);`
332			`if (!dr) {`
333			`usb_free_urb(urb);`
334			`return -ENOMEM;`
335			`}`
336
337			`dr->bRequestType = USB_TYPE_CLASS;`
338			`dr->bRequest = 0;`
339			`dr->wIndex = 0;`
340			`dr->wValue = 0;`
341			`dr->wLength = __cpu_to_le16(skb->len);`
342
343			`pipe = usb_sndctrlpipe(data->udev, 0x00);`
344
345			`usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,`
346			`skb->data, skb->len, btusb_tx_complete, skb);`
347
348			`hdev->stat.cmd_tx++;`
349			`break;`
350
351			`case HCI_ACLDATA_PKT:`
352			`urb = usb_alloc_urb(0, GFP_ATOMIC);`
353			`if (!urb)`
354			`return -ENOMEM;`
355
356			`pipe = usb_sndbulkpipe(data->udev,`
357			`data->bulk_tx_ep->bEndpointAddress);`
358
359			`usb_fill_bulk_urb(urb, data->udev, pipe,`
360			`skb->data, skb->len, btusb_tx_complete, skb);`
361
362			`hdev->stat.acl_tx++;`
363			`break;`
364
365			`case HCI_SCODATA_PKT:`
366			`hdev->stat.sco_tx++;`
367			`kfree_skb(skb);`
368			`return 0;`
369
370			`default:`
371			`return -EILSEQ;`
372			`}`
373
374			`usb_anchor_urb(urb, &data->tx_anchor);`
375
376			`err = usb_submit_urb(urb, GFP_ATOMIC);`
377			`if (err < 0) {`
378			`BT_ERR("%s urb %p submission failed", hdev->name, urb);`
379			`kfree(urb->setup_packet);`
380			`usb_unanchor_urb(urb);`
381			`}`
382
383			`usb_free_urb(urb);`
384
385			`return err;`
386			`}`
387
388			`static void btusb_destruct(struct hci_dev *hdev)`
389			`{`
390			`struct btusb_data *data = hdev->driver_data;`
391
392			`BT_DBG("%s", hdev->name);`
393
394			`kfree(data);`
395			`}`
396
397			`static void btusb_notify(struct hci_dev *hdev, unsigned int evt)`
398			`{`
399			`struct btusb_data *data = hdev->driver_data;`
400
401			`BT_DBG("%s evt %d", hdev->name, evt);`
402
403			`if (evt == HCI_NOTIFY_CONN_ADD \|\| evt == HCI_NOTIFY_CONN_DEL)`
404			`schedule_work(&data->work);`
405			`}`
406
407			`static void btusb_work(struct work_struct *work)`
408			`{`
409			`struct btusb_data *data = container_of(work, struct btusb_data, work);`
410			`struct hci_dev *hdev = data->hdev;`
411
412			`if (hdev->conn_hash.acl_num == 0) {`
413			`clear_bit(BTUSB_BULK_RUNNING, &data->flags);`
414			`usb_kill_anchored_urbs(&data->bulk_anchor);`
415			`return;`
416			`}`
417
418			`if (!test_and_set_bit(BTUSB_BULK_RUNNING, &data->flags)) {`
419			`if (btusb_submit_bulk_urb(hdev) < 0)`
420			`clear_bit(BTUSB_BULK_RUNNING, &data->flags);`
421			`else`
422			`btusb_submit_bulk_urb(hdev);`
423			`}`
424			`}`
425
426			`static int btusb_probe(struct usb_interface *intf,`
427			`const struct usb_device_id *id)`
428			`{`
429			`struct usb_endpoint_descriptor *ep_desc;`
430			`struct btusb_data *data;`
431			`struct hci_dev *hdev;`
432			`int i, err;`
433
434			`BT_DBG("intf %p id %p", intf, id);`
435
436			`if (intf->cur_altsetting->desc.bInterfaceNumber != 0)`
437			`return -ENODEV;`
438
439			`if (!id->driver_info) {`
440			`const struct usb_device_id *match;`
441			`match = usb_match_id(intf, blacklist_table);`
442			`if (match)`
443			`id = match;`
444			`}`
445
446			`data = kzalloc(sizeof(*data), GFP_KERNEL);`
447			`if (!data)`
448			`return -ENOMEM;`
449
450			`for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {`
451			`ep_desc = &intf->cur_altsetting->endpoint[i].desc;`
452
453			`if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {`
454			`data->intr_ep = ep_desc;`
455			`continue;`
456			`}`
457
458			`if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {`
459			`data->bulk_tx_ep = ep_desc;`
460			`continue;`
461			`}`
462
463			`if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {`
464			`data->bulk_rx_ep = ep_desc;`
465			`continue;`
466			`}`
467			`}`
468
469			`if (!data->intr_ep \|\| !data->bulk_tx_ep \|\| !data->bulk_rx_ep) {`
470			`kfree(data);`
471			`return -ENODEV;`
472			`}`
473
474			`data->udev = interface_to_usbdev(intf);`
475
476			`spin_lock_init(&data->lock);`
477
478			`INIT_WORK(&data->work, btusb_work);`
479
480			`init_usb_anchor(&data->tx_anchor);`
481			`init_usb_anchor(&data->intr_anchor);`
482			`init_usb_anchor(&data->bulk_anchor);`
483
484			`hdev = hci_alloc_dev();`
485			`if (!hdev) {`
486			`kfree(data);`
487			`return -ENOMEM;`
488			`}`
489
490			`hdev->type = HCI_USB;`
491			`hdev->driver_data = data;`
492
493			`data->hdev = hdev;`
494
495			`SET_HCIDEV_DEV(hdev, &intf->dev);`
496
497			`hdev->open = btusb_open;`
498			`hdev->close = btusb_close;`
499			`hdev->flush = btusb_flush;`
500			`hdev->send = btusb_send_frame;`
501			`hdev->destruct = btusb_destruct;`
502			`hdev->notify = btusb_notify;`
503
504			`hdev->owner = THIS_MODULE;`
505
506			`set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);`
507
508			`err = hci_register_dev(hdev);`
509			`if (err < 0) {`
510			`hci_free_dev(hdev);`
511			`kfree(data);`
512			`return err;`
513			`}`
514
515			`usb_set_intfdata(intf, data);`
516
517			`return 0;`
518			`}`
519
520			`static void btusb_disconnect(struct usb_interface *intf)`
521			`{`
522			`struct btusb_data *data = usb_get_intfdata(intf);`
523			`struct hci_dev *hdev;`
524
525			`BT_DBG("intf %p", intf);`
526
527			`if (!data)`
528			`return;`
529
530			`hdev = data->hdev;`
531
532			`usb_set_intfdata(intf, NULL);`
533
534			`hci_unregister_dev(hdev);`
535
536			`hci_free_dev(hdev);`
537			`}`
538
539			`static struct usb_driver btusb_driver = {`
540			`.name = "btusb",`
541			`.probe = btusb_probe,`
542			`.disconnect = btusb_disconnect,`
543			`.id_table = btusb_table,`
544			`};`
545
546			`static int __init btusb_init(void)`
547			`{`
548			`BT_INFO("Generic Bluetooth USB driver ver %s", VERSION);`
549
550			`return usb_register(&btusb_driver);`
551			`}`
552
553			`static void __exit btusb_exit(void)`
554			`{`
555			`usb_deregister(&btusb_driver);`
556			`}`
557
558			`module_init(btusb_init);`
559			`module_exit(btusb_exit);`
560
561			`MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");`
562			`MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);`
563			`MODULE_VERSION(VERSION);`
564			`MODULE_LICENSE("GPL");`