]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * | |
3 | * Digianswer Bluetooth USB driver | |
4 | * | |
e24b21ec | 5 | * Copyright (C) 2004-2007 Marcel Holtmann <marcel@holtmann.org> |
1da177e4 LT |
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 | ||
1da177e4 | 24 | #include <linux/kernel.h> |
e24b21ec | 25 | #include <linux/module.h> |
1da177e4 LT |
26 | #include <linux/init.h> |
27 | #include <linux/slab.h> | |
28 | #include <linux/types.h> | |
e24b21ec | 29 | #include <linux/sched.h> |
1da177e4 | 30 | #include <linux/errno.h> |
e24b21ec | 31 | #include <linux/skbuff.h> |
1da177e4 LT |
32 | |
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 | ||
e24b21ec | 43 | #define VERSION "0.9" |
1da177e4 LT |
44 | |
45 | static int ignore = 0; | |
46 | ||
47 | static struct usb_device_id bpa10x_table[] = { | |
48 | /* Tektronix BPA 100/105 (Digianswer) */ | |
49 | { USB_DEVICE(0x08fd, 0x0002) }, | |
50 | ||
51 | { } /* Terminating entry */ | |
52 | }; | |
53 | ||
54 | MODULE_DEVICE_TABLE(usb, bpa10x_table); | |
55 | ||
1da177e4 | 56 | struct bpa10x_data { |
e24b21ec MH |
57 | struct hci_dev *hdev; |
58 | struct usb_device *udev; | |
1da177e4 | 59 | |
e24b21ec MH |
60 | struct usb_anchor tx_anchor; |
61 | struct usb_anchor rx_anchor; | |
1da177e4 | 62 | |
e24b21ec | 63 | struct sk_buff *rx_skb[2]; |
1da177e4 LT |
64 | }; |
65 | ||
e24b21ec | 66 | #define HCI_VENDOR_HDR_SIZE 5 |
1da177e4 LT |
67 | |
68 | struct hci_vendor_hdr { | |
e24b21ec MH |
69 | __u8 type; |
70 | __le16 snum; | |
71 | __le16 dlen; | |
1da177e4 LT |
72 | } __attribute__ ((packed)); |
73 | ||
e24b21ec | 74 | static int bpa10x_recv(struct hci_dev *hdev, int queue, void *buf, int count) |
1da177e4 | 75 | { |
e24b21ec MH |
76 | struct bpa10x_data *data = hdev->driver_data; |
77 | ||
78 | BT_DBG("%s queue %d buffer %p count %d", hdev->name, | |
79 | queue, buf, count); | |
80 | ||
81 | if (queue < 0 || queue > 1) | |
82 | return -EILSEQ; | |
83 | ||
84 | hdev->stat.byte_rx += count; | |
1da177e4 LT |
85 | |
86 | while (count) { | |
e24b21ec MH |
87 | struct sk_buff *skb = data->rx_skb[queue]; |
88 | struct { __u8 type; int expect; } *scb; | |
89 | int type, len = 0; | |
1da177e4 | 90 | |
e24b21ec MH |
91 | if (!skb) { |
92 | /* Start of the frame */ | |
93 | ||
94 | type = *((__u8 *) buf); | |
95 | count--; buf++; | |
96 | ||
97 | switch (type) { | |
98 | case HCI_EVENT_PKT: | |
99 | if (count >= HCI_EVENT_HDR_SIZE) { | |
100 | struct hci_event_hdr *h = buf; | |
101 | len = HCI_EVENT_HDR_SIZE + h->plen; | |
102 | } else | |
103 | return -EILSEQ; | |
104 | break; | |
105 | ||
106 | case HCI_ACLDATA_PKT: | |
107 | if (count >= HCI_ACL_HDR_SIZE) { | |
108 | struct hci_acl_hdr *h = buf; | |
109 | len = HCI_ACL_HDR_SIZE + | |
110 | __le16_to_cpu(h->dlen); | |
111 | } else | |
112 | return -EILSEQ; | |
113 | break; | |
114 | ||
115 | case HCI_SCODATA_PKT: | |
116 | if (count >= HCI_SCO_HDR_SIZE) { | |
117 | struct hci_sco_hdr *h = buf; | |
118 | len = HCI_SCO_HDR_SIZE + h->dlen; | |
119 | } else | |
120 | return -EILSEQ; | |
121 | break; | |
122 | ||
123 | case HCI_VENDOR_PKT: | |
124 | if (count >= HCI_VENDOR_HDR_SIZE) { | |
125 | struct hci_vendor_hdr *h = buf; | |
126 | len = HCI_VENDOR_HDR_SIZE + | |
127 | __le16_to_cpu(h->dlen); | |
128 | } else | |
129 | return -EILSEQ; | |
130 | break; | |
1da177e4 | 131 | } |
1da177e4 | 132 | |
1da177e4 | 133 | skb = bt_skb_alloc(len, GFP_ATOMIC); |
e24b21ec MH |
134 | if (!skb) { |
135 | BT_ERR("%s no memory for packet", hdev->name); | |
136 | return -ENOMEM; | |
1da177e4 | 137 | } |
1da177e4 | 138 | |
e24b21ec | 139 | skb->dev = (void *) hdev; |
1da177e4 | 140 | |
e24b21ec | 141 | data->rx_skb[queue] = skb; |
1da177e4 | 142 | |
e24b21ec MH |
143 | scb = (void *) skb->cb; |
144 | scb->type = type; | |
145 | scb->expect = len; | |
146 | } else { | |
147 | /* Continuation */ | |
1da177e4 | 148 | |
e24b21ec MH |
149 | scb = (void *) skb->cb; |
150 | len = scb->expect; | |
1da177e4 LT |
151 | } |
152 | ||
e24b21ec | 153 | len = min(len, count); |
1da177e4 | 154 | |
e24b21ec | 155 | memcpy(skb_put(skb, len), buf, len); |
1da177e4 | 156 | |
e24b21ec | 157 | scb->expect -= len; |
1da177e4 | 158 | |
e24b21ec MH |
159 | if (scb->expect == 0) { |
160 | /* Complete frame */ | |
1da177e4 | 161 | |
e24b21ec | 162 | data->rx_skb[queue] = NULL; |
1da177e4 | 163 | |
e24b21ec | 164 | bt_cb(skb)->pkt_type = scb->type; |
1da177e4 | 165 | hci_recv_frame(skb); |
1da177e4 | 166 | } |
e24b21ec MH |
167 | |
168 | count -= len; buf += len; | |
1da177e4 LT |
169 | } |
170 | ||
171 | return 0; | |
172 | } | |
173 | ||
e24b21ec | 174 | static void bpa10x_tx_complete(struct urb *urb) |
1da177e4 | 175 | { |
e24b21ec MH |
176 | struct sk_buff *skb = urb->context; |
177 | struct hci_dev *hdev = (struct hci_dev *) skb->dev; | |
1da177e4 | 178 | |
e24b21ec MH |
179 | BT_DBG("%s urb %p status %d count %d", hdev->name, |
180 | urb, urb->status, urb->actual_length); | |
1da177e4 | 181 | |
e24b21ec MH |
182 | if (!test_bit(HCI_RUNNING, &hdev->flags)) |
183 | goto done; | |
184 | ||
185 | if (!urb->status) | |
186 | hdev->stat.byte_tx += urb->transfer_buffer_length; | |
1da177e4 | 187 | else |
e24b21ec | 188 | hdev->stat.err_tx++; |
1da177e4 | 189 | |
e24b21ec MH |
190 | done: |
191 | kfree(urb->setup_packet); | |
1da177e4 | 192 | |
e24b21ec MH |
193 | kfree_skb(skb); |
194 | } | |
195 | ||
196 | static void bpa10x_rx_complete(struct urb *urb) | |
197 | { | |
198 | struct hci_dev *hdev = urb->context; | |
199 | struct bpa10x_data *data = hdev->driver_data; | |
200 | int err; | |
1da177e4 | 201 | |
e24b21ec MH |
202 | BT_DBG("%s urb %p status %d count %d", hdev->name, |
203 | urb, urb->status, urb->actual_length); | |
1da177e4 | 204 | |
e24b21ec MH |
205 | if (!test_bit(HCI_RUNNING, &hdev->flags)) |
206 | return; | |
1da177e4 | 207 | |
e24b21ec MH |
208 | if (urb->status == 0) { |
209 | if (bpa10x_recv(hdev, usb_pipebulk(urb->pipe), | |
210 | urb->transfer_buffer, | |
211 | urb->actual_length) < 0) { | |
212 | BT_ERR("%s corrupted event packet", hdev->name); | |
213 | hdev->stat.err_rx++; | |
214 | } | |
1da177e4 LT |
215 | } |
216 | ||
e24b21ec MH |
217 | usb_anchor_urb(urb, &data->rx_anchor); |
218 | ||
219 | err = usb_submit_urb(urb, GFP_ATOMIC); | |
220 | if (err < 0) { | |
221 | BT_ERR("%s urb %p failed to resubmit (%d)", | |
222 | hdev->name, urb, -err); | |
223 | usb_unanchor_urb(urb); | |
1da177e4 LT |
224 | } |
225 | } | |
226 | ||
e24b21ec | 227 | static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev) |
1da177e4 | 228 | { |
e24b21ec MH |
229 | struct bpa10x_data *data = hdev->driver_data; |
230 | struct urb *urb; | |
231 | unsigned char *buf; | |
232 | unsigned int pipe; | |
233 | int err, size = 16; | |
1da177e4 | 234 | |
e24b21ec | 235 | BT_DBG("%s", hdev->name); |
1da177e4 | 236 | |
e24b21ec MH |
237 | urb = usb_alloc_urb(0, GFP_KERNEL); |
238 | if (!urb) | |
239 | return -ENOMEM; | |
1da177e4 | 240 | |
e24b21ec MH |
241 | buf = kmalloc(size, GFP_KERNEL); |
242 | if (!buf) { | |
243 | usb_free_urb(urb); | |
244 | return -ENOMEM; | |
245 | } | |
1da177e4 | 246 | |
e24b21ec | 247 | pipe = usb_rcvintpipe(data->udev, 0x81); |
1da177e4 | 248 | |
e24b21ec MH |
249 | usb_fill_int_urb(urb, data->udev, pipe, buf, size, |
250 | bpa10x_rx_complete, hdev, 1); | |
1da177e4 | 251 | |
e24b21ec | 252 | urb->transfer_flags |= URB_FREE_BUFFER; |
1da177e4 | 253 | |
e24b21ec | 254 | usb_anchor_urb(urb, &data->rx_anchor); |
1da177e4 | 255 | |
e24b21ec MH |
256 | err = usb_submit_urb(urb, GFP_KERNEL); |
257 | if (err < 0) { | |
258 | BT_ERR("%s urb %p submission failed (%d)", | |
259 | hdev->name, urb, -err); | |
260 | usb_unanchor_urb(urb); | |
261 | kfree(buf); | |
1da177e4 LT |
262 | } |
263 | ||
e24b21ec | 264 | usb_free_urb(urb); |
1da177e4 | 265 | |
e24b21ec | 266 | return err; |
1da177e4 LT |
267 | } |
268 | ||
e24b21ec | 269 | static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev) |
1da177e4 | 270 | { |
e24b21ec | 271 | struct bpa10x_data *data = hdev->driver_data; |
1da177e4 | 272 | struct urb *urb; |
1da177e4 | 273 | unsigned char *buf; |
e24b21ec MH |
274 | unsigned int pipe; |
275 | int err, size = 64; | |
1da177e4 | 276 | |
e24b21ec | 277 | BT_DBG("%s", hdev->name); |
1da177e4 | 278 | |
e24b21ec | 279 | urb = usb_alloc_urb(0, GFP_KERNEL); |
1da177e4 | 280 | if (!urb) |
e24b21ec | 281 | return -ENOMEM; |
1da177e4 | 282 | |
e24b21ec | 283 | buf = kmalloc(size, GFP_KERNEL); |
1da177e4 LT |
284 | if (!buf) { |
285 | usb_free_urb(urb); | |
e24b21ec | 286 | return -ENOMEM; |
1da177e4 LT |
287 | } |
288 | ||
e24b21ec | 289 | pipe = usb_rcvbulkpipe(data->udev, 0x82); |
1da177e4 | 290 | |
e24b21ec MH |
291 | usb_fill_bulk_urb(urb, data->udev, pipe, |
292 | buf, size, bpa10x_rx_complete, hdev); | |
1da177e4 | 293 | |
e24b21ec | 294 | urb->transfer_flags |= URB_FREE_BUFFER; |
1da177e4 | 295 | |
e24b21ec | 296 | usb_anchor_urb(urb, &data->rx_anchor); |
1da177e4 | 297 | |
e24b21ec MH |
298 | err = usb_submit_urb(urb, GFP_KERNEL); |
299 | if (err < 0) { | |
300 | BT_ERR("%s urb %p submission failed (%d)", | |
301 | hdev->name, urb, -err); | |
302 | usb_unanchor_urb(urb); | |
1da177e4 | 303 | kfree(buf); |
1da177e4 LT |
304 | } |
305 | ||
1da177e4 | 306 | usb_free_urb(urb); |
e24b21ec MH |
307 | |
308 | return err; | |
1da177e4 LT |
309 | } |
310 | ||
311 | static int bpa10x_open(struct hci_dev *hdev) | |
312 | { | |
313 | struct bpa10x_data *data = hdev->driver_data; | |
1da177e4 LT |
314 | int err; |
315 | ||
e24b21ec | 316 | BT_DBG("%s", hdev->name); |
1da177e4 LT |
317 | |
318 | if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) | |
319 | return 0; | |
320 | ||
e24b21ec MH |
321 | err = bpa10x_submit_intr_urb(hdev); |
322 | if (err < 0) | |
323 | goto error; | |
1da177e4 | 324 | |
e24b21ec MH |
325 | err = bpa10x_submit_bulk_urb(hdev); |
326 | if (err < 0) | |
327 | goto error; | |
1da177e4 | 328 | |
e24b21ec | 329 | return 0; |
1da177e4 | 330 | |
e24b21ec MH |
331 | error: |
332 | usb_kill_anchored_urbs(&data->rx_anchor); | |
1da177e4 | 333 | |
e24b21ec | 334 | clear_bit(HCI_RUNNING, &hdev->flags); |
1da177e4 LT |
335 | |
336 | return err; | |
337 | } | |
338 | ||
339 | static int bpa10x_close(struct hci_dev *hdev) | |
340 | { | |
341 | struct bpa10x_data *data = hdev->driver_data; | |
1da177e4 | 342 | |
e24b21ec | 343 | BT_DBG("%s", hdev->name); |
1da177e4 LT |
344 | |
345 | if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) | |
346 | return 0; | |
347 | ||
e24b21ec | 348 | usb_kill_anchored_urbs(&data->rx_anchor); |
1da177e4 LT |
349 | |
350 | return 0; | |
351 | } | |
352 | ||
353 | static int bpa10x_flush(struct hci_dev *hdev) | |
354 | { | |
355 | struct bpa10x_data *data = hdev->driver_data; | |
356 | ||
e24b21ec | 357 | BT_DBG("%s", hdev->name); |
1da177e4 | 358 | |
e24b21ec | 359 | usb_kill_anchored_urbs(&data->tx_anchor); |
1da177e4 LT |
360 | |
361 | return 0; | |
362 | } | |
363 | ||
364 | static int bpa10x_send_frame(struct sk_buff *skb) | |
365 | { | |
366 | struct hci_dev *hdev = (struct hci_dev *) skb->dev; | |
e24b21ec MH |
367 | struct bpa10x_data *data = hdev->driver_data; |
368 | struct usb_ctrlrequest *dr; | |
369 | struct urb *urb; | |
370 | unsigned int pipe; | |
371 | int err; | |
1da177e4 | 372 | |
e24b21ec | 373 | BT_DBG("%s", hdev->name); |
1da177e4 LT |
374 | |
375 | if (!test_bit(HCI_RUNNING, &hdev->flags)) | |
376 | return -EBUSY; | |
377 | ||
e24b21ec MH |
378 | urb = usb_alloc_urb(0, GFP_ATOMIC); |
379 | if (!urb) | |
380 | return -ENOMEM; | |
1da177e4 LT |
381 | |
382 | /* Prepend skb with frame type */ | |
e24b21ec | 383 | *skb_push(skb, 1) = bt_cb(skb)->pkt_type; |
1da177e4 | 384 | |
0d48d939 | 385 | switch (bt_cb(skb)->pkt_type) { |
1da177e4 | 386 | case HCI_COMMAND_PKT: |
e24b21ec MH |
387 | dr = kmalloc(sizeof(*dr), GFP_ATOMIC); |
388 | if (!dr) { | |
389 | usb_free_urb(urb); | |
390 | return -ENOMEM; | |
391 | } | |
392 | ||
393 | dr->bRequestType = USB_TYPE_VENDOR; | |
394 | dr->bRequest = 0; | |
395 | dr->wIndex = 0; | |
396 | dr->wValue = 0; | |
397 | dr->wLength = __cpu_to_le16(skb->len); | |
398 | ||
399 | pipe = usb_sndctrlpipe(data->udev, 0x00); | |
400 | ||
401 | usb_fill_control_urb(urb, data->udev, pipe, (void *) dr, | |
402 | skb->data, skb->len, bpa10x_tx_complete, skb); | |
403 | ||
1da177e4 | 404 | hdev->stat.cmd_tx++; |
1da177e4 LT |
405 | break; |
406 | ||
407 | case HCI_ACLDATA_PKT: | |
e24b21ec MH |
408 | pipe = usb_sndbulkpipe(data->udev, 0x02); |
409 | ||
410 | usb_fill_bulk_urb(urb, data->udev, pipe, | |
411 | skb->data, skb->len, bpa10x_tx_complete, skb); | |
412 | ||
1da177e4 | 413 | hdev->stat.acl_tx++; |
1da177e4 LT |
414 | break; |
415 | ||
416 | case HCI_SCODATA_PKT: | |
e24b21ec MH |
417 | pipe = usb_sndbulkpipe(data->udev, 0x02); |
418 | ||
419 | usb_fill_bulk_urb(urb, data->udev, pipe, | |
420 | skb->data, skb->len, bpa10x_tx_complete, skb); | |
421 | ||
1da177e4 | 422 | hdev->stat.sco_tx++; |
1da177e4 | 423 | break; |
1da177e4 | 424 | |
e24b21ec MH |
425 | default: |
426 | return -EILSEQ; | |
427 | } | |
428 | ||
429 | usb_anchor_urb(urb, &data->tx_anchor); | |
1da177e4 | 430 | |
e24b21ec MH |
431 | err = usb_submit_urb(urb, GFP_ATOMIC); |
432 | if (err < 0) { | |
433 | BT_ERR("%s urb %p submission failed", hdev->name, urb); | |
434 | kfree(urb->setup_packet); | |
435 | usb_unanchor_urb(urb); | |
436 | } | |
1da177e4 | 437 | |
e24b21ec | 438 | usb_free_urb(urb); |
1da177e4 LT |
439 | |
440 | return 0; | |
441 | } | |
442 | ||
443 | static void bpa10x_destruct(struct hci_dev *hdev) | |
444 | { | |
445 | struct bpa10x_data *data = hdev->driver_data; | |
446 | ||
e24b21ec | 447 | BT_DBG("%s", hdev->name); |
1da177e4 | 448 | |
e24b21ec MH |
449 | kfree(data->rx_skb[0]); |
450 | kfree(data->rx_skb[1]); | |
1da177e4 LT |
451 | kfree(data); |
452 | } | |
453 | ||
454 | static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id) | |
455 | { | |
1da177e4 | 456 | struct bpa10x_data *data; |
e24b21ec | 457 | struct hci_dev *hdev; |
1da177e4 LT |
458 | int err; |
459 | ||
460 | BT_DBG("intf %p id %p", intf, id); | |
461 | ||
462 | if (ignore) | |
245dc3d1 MH |
463 | return -ENODEV; |
464 | ||
e24b21ec | 465 | if (intf->cur_altsetting->desc.bInterfaceNumber != 0) |
1da177e4 LT |
466 | return -ENODEV; |
467 | ||
089b1dbb | 468 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
e24b21ec | 469 | if (!data) |
1da177e4 | 470 | return -ENOMEM; |
1da177e4 | 471 | |
e24b21ec | 472 | data->udev = interface_to_usbdev(intf); |
1da177e4 | 473 | |
e24b21ec MH |
474 | init_usb_anchor(&data->tx_anchor); |
475 | init_usb_anchor(&data->rx_anchor); | |
1da177e4 LT |
476 | |
477 | hdev = hci_alloc_dev(); | |
478 | if (!hdev) { | |
1da177e4 LT |
479 | kfree(data); |
480 | return -ENOMEM; | |
481 | } | |
482 | ||
1da177e4 LT |
483 | hdev->type = HCI_USB; |
484 | hdev->driver_data = data; | |
e24b21ec MH |
485 | |
486 | data->hdev = hdev; | |
487 | ||
1da177e4 LT |
488 | SET_HCIDEV_DEV(hdev, &intf->dev); |
489 | ||
e24b21ec MH |
490 | hdev->open = bpa10x_open; |
491 | hdev->close = bpa10x_close; | |
492 | hdev->flush = bpa10x_flush; | |
493 | hdev->send = bpa10x_send_frame; | |
494 | hdev->destruct = bpa10x_destruct; | |
1da177e4 LT |
495 | |
496 | hdev->owner = THIS_MODULE; | |
497 | ||
498 | err = hci_register_dev(hdev); | |
499 | if (err < 0) { | |
1da177e4 | 500 | hci_free_dev(hdev); |
e24b21ec | 501 | kfree(data); |
1da177e4 LT |
502 | return err; |
503 | } | |
504 | ||
505 | usb_set_intfdata(intf, data); | |
506 | ||
507 | return 0; | |
508 | } | |
509 | ||
510 | static void bpa10x_disconnect(struct usb_interface *intf) | |
511 | { | |
512 | struct bpa10x_data *data = usb_get_intfdata(intf); | |
1da177e4 LT |
513 | |
514 | BT_DBG("intf %p", intf); | |
515 | ||
e24b21ec | 516 | if (!data) |
1da177e4 LT |
517 | return; |
518 | ||
519 | usb_set_intfdata(intf, NULL); | |
520 | ||
e24b21ec | 521 | hci_unregister_dev(data->hdev); |
1da177e4 | 522 | |
e24b21ec | 523 | hci_free_dev(data->hdev); |
1da177e4 LT |
524 | } |
525 | ||
526 | static struct usb_driver bpa10x_driver = { | |
1da177e4 LT |
527 | .name = "bpa10x", |
528 | .probe = bpa10x_probe, | |
529 | .disconnect = bpa10x_disconnect, | |
530 | .id_table = bpa10x_table, | |
531 | }; | |
532 | ||
533 | static int __init bpa10x_init(void) | |
534 | { | |
1da177e4 LT |
535 | BT_INFO("Digianswer Bluetooth USB driver ver %s", VERSION); |
536 | ||
e24b21ec | 537 | return usb_register(&bpa10x_driver); |
1da177e4 LT |
538 | } |
539 | ||
540 | static void __exit bpa10x_exit(void) | |
541 | { | |
542 | usb_deregister(&bpa10x_driver); | |
543 | } | |
544 | ||
545 | module_init(bpa10x_init); | |
546 | module_exit(bpa10x_exit); | |
547 | ||
548 | module_param(ignore, bool, 0644); | |
549 | MODULE_PARM_DESC(ignore, "Ignore devices from the matching table"); | |
550 | ||
551 | MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); | |
552 | MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION); | |
553 | MODULE_VERSION(VERSION); | |
554 | MODULE_LICENSE("GPL"); |