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