blob: b936d8ce2728836c2ba3c214a2cf93960886187f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 *
3 * Digianswer Bluetooth USB driver
4 *
Marcel Holtmanne24b21e2007-10-20 13:41:33 +02005 * Copyright (C) 2004-2007 Marcel Holtmann <marcel@holtmann.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/kernel.h>
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020025#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/init.h>
27#include <linux/slab.h>
28#include <linux/types.h>
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020029#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/errno.h>
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020031#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#include <linux/usb.h>
34
35#include <net/bluetooth/bluetooth.h>
36#include <net/bluetooth/hci_core.h>
37
38#ifndef CONFIG_BT_HCIBPA10X_DEBUG
39#undef BT_DBG
40#define BT_DBG(D...)
41#endif
42
Marcel Holtmann943d56b2008-08-07 22:26:55 +020043#define VERSION "0.10"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45static struct usb_device_id bpa10x_table[] = {
46 /* Tektronix BPA 100/105 (Digianswer) */
47 { USB_DEVICE(0x08fd, 0x0002) },
48
49 { } /* Terminating entry */
50};
51
52MODULE_DEVICE_TABLE(usb, bpa10x_table);
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054struct bpa10x_data {
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020055 struct hci_dev *hdev;
56 struct usb_device *udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020058 struct usb_anchor tx_anchor;
59 struct usb_anchor rx_anchor;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020061 struct sk_buff *rx_skb[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -070062};
63
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020064#define HCI_VENDOR_HDR_SIZE 5
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66struct hci_vendor_hdr {
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020067 __u8 type;
68 __le16 snum;
69 __le16 dlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070} __attribute__ ((packed));
71
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020072static int bpa10x_recv(struct hci_dev *hdev, int queue, void *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020074 struct bpa10x_data *data = hdev->driver_data;
75
76 BT_DBG("%s queue %d buffer %p count %d", hdev->name,
77 queue, buf, count);
78
79 if (queue < 0 || queue > 1)
80 return -EILSEQ;
81
82 hdev->stat.byte_rx += count;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84 while (count) {
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020085 struct sk_buff *skb = data->rx_skb[queue];
86 struct { __u8 type; int expect; } *scb;
87 int type, len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 if (!skb) {
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020090 /* Start of the frame */
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020092 type = *((__u8 *) buf);
93 count--; buf++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Marcel Holtmanne24b21e2007-10-20 13:41:33 +020095 switch (type) {
96 case HCI_EVENT_PKT:
97 if (count >= HCI_EVENT_HDR_SIZE) {
98 struct hci_event_hdr *h = buf;
99 len = HCI_EVENT_HDR_SIZE + h->plen;
100 } else
101 return -EILSEQ;
102 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200104 case HCI_ACLDATA_PKT:
105 if (count >= HCI_ACL_HDR_SIZE) {
106 struct hci_acl_hdr *h = buf;
107 len = HCI_ACL_HDR_SIZE +
108 __le16_to_cpu(h->dlen);
109 } else
110 return -EILSEQ;
111 break;
112
113 case HCI_SCODATA_PKT:
114 if (count >= HCI_SCO_HDR_SIZE) {
115 struct hci_sco_hdr *h = buf;
116 len = HCI_SCO_HDR_SIZE + h->dlen;
117 } else
118 return -EILSEQ;
119 break;
120
121 case HCI_VENDOR_PKT:
122 if (count >= HCI_VENDOR_HDR_SIZE) {
123 struct hci_vendor_hdr *h = buf;
124 len = HCI_VENDOR_HDR_SIZE +
125 __le16_to_cpu(h->dlen);
126 } else
127 return -EILSEQ;
128 break;
129 }
130
131 skb = bt_skb_alloc(len, GFP_ATOMIC);
132 if (!skb) {
133 BT_ERR("%s no memory for packet", hdev->name);
134 return -ENOMEM;
135 }
136
137 skb->dev = (void *) hdev;
138
139 data->rx_skb[queue] = skb;
140
141 scb = (void *) skb->cb;
142 scb->type = type;
143 scb->expect = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 } else {
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200145 /* Continuation */
146
147 scb = (void *) skb->cb;
148 len = scb->expect;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200150
151 len = min(len, count);
152
153 memcpy(skb_put(skb, len), buf, len);
154
155 scb->expect -= len;
156
157 if (scb->expect == 0) {
158 /* Complete frame */
159
160 data->rx_skb[queue] = NULL;
161
162 bt_cb(skb)->pkt_type = scb->type;
163 hci_recv_frame(skb);
164 }
165
166 count -= len; buf += len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 }
168
169 return 0;
170}
171
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200172static void bpa10x_tx_complete(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173{
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200174 struct sk_buff *skb = urb->context;
175 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
176
177 BT_DBG("%s urb %p status %d count %d", hdev->name,
178 urb, urb->status, urb->actual_length);
179
180 if (!test_bit(HCI_RUNNING, &hdev->flags))
181 goto done;
182
183 if (!urb->status)
184 hdev->stat.byte_tx += urb->transfer_buffer_length;
185 else
186 hdev->stat.err_tx++;
187
188done:
189 kfree(urb->setup_packet);
190
191 kfree_skb(skb);
192}
193
194static void bpa10x_rx_complete(struct urb *urb)
195{
196 struct hci_dev *hdev = urb->context;
197 struct bpa10x_data *data = hdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 int err;
199
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200200 BT_DBG("%s urb %p status %d count %d", hdev->name,
201 urb, urb->status, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200203 if (!test_bit(HCI_RUNNING, &hdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 return;
205
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200206 if (urb->status == 0) {
207 if (bpa10x_recv(hdev, usb_pipebulk(urb->pipe),
208 urb->transfer_buffer,
209 urb->actual_length) < 0) {
210 BT_ERR("%s corrupted event packet", hdev->name);
211 hdev->stat.err_rx++;
212 }
213 }
214
215 usb_anchor_urb(urb, &data->rx_anchor);
216
217 err = usb_submit_urb(urb, GFP_ATOMIC);
218 if (err < 0) {
219 BT_ERR("%s urb %p failed to resubmit (%d)",
220 hdev->name, urb, -err);
221 usb_unanchor_urb(urb);
222 }
223}
224
225static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
226{
227 struct bpa10x_data *data = hdev->driver_data;
228 struct urb *urb;
229 unsigned char *buf;
230 unsigned int pipe;
231 int err, size = 16;
232
233 BT_DBG("%s", hdev->name);
234
235 urb = usb_alloc_urb(0, GFP_KERNEL);
236 if (!urb)
237 return -ENOMEM;
238
239 buf = kmalloc(size, GFP_KERNEL);
240 if (!buf) {
241 usb_free_urb(urb);
242 return -ENOMEM;
243 }
244
245 pipe = usb_rcvintpipe(data->udev, 0x81);
246
247 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
248 bpa10x_rx_complete, hdev, 1);
249
250 urb->transfer_flags |= URB_FREE_BUFFER;
251
252 usb_anchor_urb(urb, &data->rx_anchor);
253
254 err = usb_submit_urb(urb, GFP_KERNEL);
255 if (err < 0) {
256 BT_ERR("%s urb %p submission failed (%d)",
257 hdev->name, urb, -err);
258 usb_unanchor_urb(urb);
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 usb_free_urb(urb);
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200262
263 return err;
264}
265
266static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
267{
268 struct bpa10x_data *data = hdev->driver_data;
269 struct urb *urb;
270 unsigned char *buf;
271 unsigned int pipe;
272 int err, size = 64;
273
274 BT_DBG("%s", hdev->name);
275
276 urb = usb_alloc_urb(0, GFP_KERNEL);
277 if (!urb)
278 return -ENOMEM;
279
280 buf = kmalloc(size, GFP_KERNEL);
281 if (!buf) {
282 usb_free_urb(urb);
283 return -ENOMEM;
284 }
285
286 pipe = usb_rcvbulkpipe(data->udev, 0x82);
287
288 usb_fill_bulk_urb(urb, data->udev, pipe,
289 buf, size, bpa10x_rx_complete, hdev);
290
291 urb->transfer_flags |= URB_FREE_BUFFER;
292
293 usb_anchor_urb(urb, &data->rx_anchor);
294
295 err = usb_submit_urb(urb, GFP_KERNEL);
296 if (err < 0) {
297 BT_ERR("%s urb %p submission failed (%d)",
298 hdev->name, urb, -err);
299 usb_unanchor_urb(urb);
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200300 }
301
302 usb_free_urb(urb);
303
304 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305}
306
307static int bpa10x_open(struct hci_dev *hdev)
308{
309 struct bpa10x_data *data = hdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 int err;
311
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200312 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
315 return 0;
316
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200317 err = bpa10x_submit_intr_urb(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 if (err < 0)
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200319 goto error;
320
321 err = bpa10x_submit_bulk_urb(hdev);
322 if (err < 0)
323 goto error;
324
325 return 0;
326
327error:
328 usb_kill_anchored_urbs(&data->rx_anchor);
329
330 clear_bit(HCI_RUNNING, &hdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
332 return err;
333}
334
335static int bpa10x_close(struct hci_dev *hdev)
336{
337 struct bpa10x_data *data = hdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200339 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
342 return 0;
343
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200344 usb_kill_anchored_urbs(&data->rx_anchor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 return 0;
347}
348
349static int bpa10x_flush(struct hci_dev *hdev)
350{
351 struct bpa10x_data *data = hdev->driver_data;
352
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200353 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200355 usb_kill_anchored_urbs(&data->tx_anchor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 return 0;
358}
359
360static int bpa10x_send_frame(struct sk_buff *skb)
361{
362 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200363 struct bpa10x_data *data = hdev->driver_data;
364 struct usb_ctrlrequest *dr;
365 struct urb *urb;
366 unsigned int pipe;
367 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200369 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 if (!test_bit(HCI_RUNNING, &hdev->flags))
372 return -EBUSY;
373
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200374 urb = usb_alloc_urb(0, GFP_ATOMIC);
375 if (!urb)
376 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378 /* Prepend skb with frame type */
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200379 *skb_push(skb, 1) = bt_cb(skb)->pkt_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700381 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 case HCI_COMMAND_PKT:
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200383 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
384 if (!dr) {
385 usb_free_urb(urb);
386 return -ENOMEM;
387 }
388
389 dr->bRequestType = USB_TYPE_VENDOR;
390 dr->bRequest = 0;
391 dr->wIndex = 0;
392 dr->wValue = 0;
393 dr->wLength = __cpu_to_le16(skb->len);
394
395 pipe = usb_sndctrlpipe(data->udev, 0x00);
396
397 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
398 skb->data, skb->len, bpa10x_tx_complete, skb);
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 hdev->stat.cmd_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 break;
402
403 case HCI_ACLDATA_PKT:
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200404 pipe = usb_sndbulkpipe(data->udev, 0x02);
405
406 usb_fill_bulk_urb(urb, data->udev, pipe,
407 skb->data, skb->len, bpa10x_tx_complete, skb);
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 hdev->stat.acl_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 break;
411
412 case HCI_SCODATA_PKT:
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200413 pipe = usb_sndbulkpipe(data->udev, 0x02);
414
415 usb_fill_bulk_urb(urb, data->udev, pipe,
416 skb->data, skb->len, bpa10x_tx_complete, skb);
417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 hdev->stat.sco_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200421 default:
Adrian Bunkcb7cd422008-02-05 03:08:45 -0800422 usb_free_urb(urb);
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200423 return -EILSEQ;
424 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200426 usb_anchor_urb(urb, &data->tx_anchor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200428 err = usb_submit_urb(urb, GFP_ATOMIC);
429 if (err < 0) {
430 BT_ERR("%s urb %p submission failed", hdev->name, urb);
431 kfree(urb->setup_packet);
432 usb_unanchor_urb(urb);
433 }
434
435 usb_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
437 return 0;
438}
439
440static void bpa10x_destruct(struct hci_dev *hdev)
441{
442 struct bpa10x_data *data = hdev->driver_data;
443
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200444 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Ilpo Järvinencbafe312008-10-31 00:40:19 -0700446 kfree_skb(data->rx_skb[0]);
447 kfree_skb(data->rx_skb[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 kfree(data);
449}
450
451static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id)
452{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 struct bpa10x_data *data;
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200454 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 int err;
456
457 BT_DBG("intf %p id %p", intf, id);
458
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200459 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
Marcel Holtmann245dc3d2005-10-28 19:20:57 +0200460 return -ENODEV;
461
Deepak Saxena089b1db2005-11-07 01:01:26 -0800462 data = kzalloc(sizeof(*data), GFP_KERNEL);
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200463 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200466 data->udev = interface_to_usbdev(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200468 init_usb_anchor(&data->tx_anchor);
469 init_usb_anchor(&data->rx_anchor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471 hdev = hci_alloc_dev();
472 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 kfree(data);
474 return -ENOMEM;
475 }
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 hdev->type = HCI_USB;
478 hdev->driver_data = data;
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200479
480 data->hdev = hdev;
481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 SET_HCIDEV_DEV(hdev, &intf->dev);
483
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200484 hdev->open = bpa10x_open;
485 hdev->close = bpa10x_close;
486 hdev->flush = bpa10x_flush;
487 hdev->send = bpa10x_send_frame;
488 hdev->destruct = bpa10x_destruct;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490 hdev->owner = THIS_MODULE;
491
492 err = hci_register_dev(hdev);
493 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 hci_free_dev(hdev);
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200495 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return err;
497 }
498
499 usb_set_intfdata(intf, data);
500
501 return 0;
502}
503
504static void bpa10x_disconnect(struct usb_interface *intf)
505{
506 struct bpa10x_data *data = usb_get_intfdata(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508 BT_DBG("intf %p", intf);
509
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200510 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 return;
512
513 usb_set_intfdata(intf, NULL);
514
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200515 hci_unregister_dev(data->hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200517 hci_free_dev(data->hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518}
519
520static struct usb_driver bpa10x_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 .name = "bpa10x",
522 .probe = bpa10x_probe,
523 .disconnect = bpa10x_disconnect,
524 .id_table = bpa10x_table,
525};
526
527static int __init bpa10x_init(void)
528{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 BT_INFO("Digianswer Bluetooth USB driver ver %s", VERSION);
530
Marcel Holtmanne24b21e2007-10-20 13:41:33 +0200531 return usb_register(&bpa10x_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532}
533
534static void __exit bpa10x_exit(void)
535{
536 usb_deregister(&bpa10x_driver);
537}
538
539module_init(bpa10x_init);
540module_exit(bpa10x_exit);
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
543MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
544MODULE_VERSION(VERSION);
545MODULE_LICENSE("GPL");