Merge branch 'linus' into cpus4096
[linux-2.6] / drivers / bluetooth / bfusb.c
1 /*
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,
570                                const unsigned char *firmware, int count)
571 {
572         unsigned char *buf;
573         int err, pipe, len, size, sent = 0;
574
575         BT_DBG("bfusb %p udev %p", data, data->udev);
576
577         BT_INFO("BlueFRITZ! USB loading firmware");
578
579         pipe = usb_sndctrlpipe(data->udev, 0);
580
581         if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
582                                 0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {
583                 BT_ERR("Can't change to loading configuration");
584                 return -EBUSY;
585         }
586
587         data->udev->toggle[0] = data->udev->toggle[1] = 0;
588
589         buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);
590         if (!buf) {
591                 BT_ERR("Can't allocate memory chunk for firmware");
592                 return -ENOMEM;
593         }
594
595         pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);
596
597         while (count) {
598                 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);
599
600                 memcpy(buf, firmware + sent, size);
601
602                 err = usb_bulk_msg(data->udev, pipe, buf, size,
603                                         &len, BFUSB_BLOCK_TIMEOUT);
604
605                 if (err || (len != size)) {
606                         BT_ERR("Error in firmware loading");
607                         goto error;
608                 }
609
610                 sent  += size;
611                 count -= size;
612         }
613
614         err = usb_bulk_msg(data->udev, pipe, NULL, 0,
615                                         &len, BFUSB_BLOCK_TIMEOUT);
616         if (err < 0) {
617                 BT_ERR("Error in null packet request");
618                 goto error;
619         }
620
621         pipe = usb_sndctrlpipe(data->udev, 0);
622
623         err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
624                                 0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
625         if (err < 0) {
626                 BT_ERR("Can't change to running configuration");
627                 goto error;
628         }
629
630         data->udev->toggle[0] = data->udev->toggle[1] = 0;
631
632         BT_INFO("BlueFRITZ! USB device ready");
633
634         kfree(buf);
635         return 0;
636
637 error:
638         kfree(buf);
639
640         pipe = usb_sndctrlpipe(data->udev, 0);
641
642         usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
643                                 0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
644
645         return err;
646 }
647
648 static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
649 {
650         const struct firmware *firmware;
651         struct usb_device *udev = interface_to_usbdev(intf);
652         struct usb_host_endpoint *bulk_out_ep;
653         struct usb_host_endpoint *bulk_in_ep;
654         struct hci_dev *hdev;
655         struct bfusb_data *data;
656
657         BT_DBG("intf %p id %p", intf, id);
658
659         if (ignore)
660                 return -ENODEV;
661
662         /* Check number of endpoints */
663         if (intf->cur_altsetting->desc.bNumEndpoints < 2)
664                 return -EIO;
665
666         bulk_out_ep = &intf->cur_altsetting->endpoint[0];
667         bulk_in_ep  = &intf->cur_altsetting->endpoint[1];
668
669         if (!bulk_out_ep || !bulk_in_ep) {
670                 BT_ERR("Bulk endpoints not found");
671                 goto done;
672         }
673
674         /* Initialize control structure and load firmware */
675         data = kzalloc(sizeof(struct bfusb_data), GFP_KERNEL);
676         if (!data) {
677                 BT_ERR("Can't allocate memory for control structure");
678                 goto done;
679         }
680
681         data->udev = udev;
682         data->bulk_in_ep    = bulk_in_ep->desc.bEndpointAddress;
683         data->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;
684         data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
685
686         rwlock_init(&data->lock);
687
688         data->reassembly = NULL;
689
690         skb_queue_head_init(&data->transmit_q);
691         skb_queue_head_init(&data->pending_q);
692         skb_queue_head_init(&data->completed_q);
693
694         if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {
695                 BT_ERR("Firmware request failed");
696                 goto error;
697         }
698
699         BT_DBG("firmware data %p size %d", firmware->data, firmware->size);
700
701         if (bfusb_load_firmware(data, firmware->data, firmware->size) < 0) {
702                 BT_ERR("Firmware loading failed");
703                 goto release;
704         }
705
706         release_firmware(firmware);
707
708         /* Initialize and register HCI device */
709         hdev = hci_alloc_dev();
710         if (!hdev) {
711                 BT_ERR("Can't allocate HCI device");
712                 goto error;
713         }
714
715         data->hdev = hdev;
716
717         hdev->type = HCI_USB;
718         hdev->driver_data = data;
719         SET_HCIDEV_DEV(hdev, &intf->dev);
720
721         hdev->open     = bfusb_open;
722         hdev->close    = bfusb_close;
723         hdev->flush    = bfusb_flush;
724         hdev->send     = bfusb_send_frame;
725         hdev->destruct = bfusb_destruct;
726         hdev->ioctl    = bfusb_ioctl;
727
728         hdev->owner = THIS_MODULE;
729
730         if (hci_register_dev(hdev) < 0) {
731                 BT_ERR("Can't register HCI device");
732                 hci_free_dev(hdev);
733                 goto error;
734         }
735
736         usb_set_intfdata(intf, data);
737
738         return 0;
739
740 release:
741         release_firmware(firmware);
742
743 error:
744         kfree(data);
745
746 done:
747         return -EIO;
748 }
749
750 static void bfusb_disconnect(struct usb_interface *intf)
751 {
752         struct bfusb_data *data = usb_get_intfdata(intf);
753         struct hci_dev *hdev = data->hdev;
754
755         BT_DBG("intf %p", intf);
756
757         if (!hdev)
758                 return;
759
760         usb_set_intfdata(intf, NULL);
761
762         bfusb_close(hdev);
763
764         if (hci_unregister_dev(hdev) < 0)
765                 BT_ERR("Can't unregister HCI device %s", hdev->name);
766
767         hci_free_dev(hdev);
768 }
769
770 static struct usb_driver bfusb_driver = {
771         .name           = "bfusb",
772         .probe          = bfusb_probe,
773         .disconnect     = bfusb_disconnect,
774         .id_table       = bfusb_table,
775 };
776
777 static int __init bfusb_init(void)
778 {
779         int err;
780
781         BT_INFO("BlueFRITZ! USB driver ver %s", VERSION);
782
783         err = usb_register(&bfusb_driver);
784         if (err < 0)
785                 BT_ERR("Failed to register BlueFRITZ! USB driver");
786
787         return err;
788 }
789
790 static void __exit bfusb_exit(void)
791 {
792         usb_deregister(&bfusb_driver);
793 }
794
795 module_init(bfusb_init);
796 module_exit(bfusb_exit);
797
798 module_param(ignore, bool, 0644);
799 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
800
801 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
802 MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION);
803 MODULE_VERSION(VERSION);
804 MODULE_LICENSE("GPL");
805 MODULE_FIRMWARE("bfubase.frm");