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 #define VERSION "1.2" 42 43 static struct usb_driver bfusb_driver; 44 45 static struct usb_device_id bfusb_table[] = { 46 /* AVM BlueFRITZ! USB */ 47 { USB_DEVICE(0x057c, 0x2200) }, 48 49 { } /* Terminating entry */ 50 }; 51 52 MODULE_DEVICE_TABLE(usb, bfusb_table); 53 54 #define BFUSB_MAX_BLOCK_SIZE 256 55 56 #define BFUSB_BLOCK_TIMEOUT 3000 57 58 #define BFUSB_TX_PROCESS 1 59 #define BFUSB_TX_WAKEUP 2 60 61 #define BFUSB_MAX_BULK_TX 2 62 #define BFUSB_MAX_BULK_RX 2 63 64 struct bfusb_data { 65 struct hci_dev *hdev; 66 67 unsigned long state; 68 69 struct usb_device *udev; 70 71 unsigned int bulk_in_ep; 72 unsigned int bulk_out_ep; 73 unsigned int bulk_pkt_size; 74 75 rwlock_t lock; 76 77 struct sk_buff_head transmit_q; 78 79 struct sk_buff *reassembly; 80 81 atomic_t pending_tx; 82 struct sk_buff_head pending_q; 83 struct sk_buff_head completed_q; 84 }; 85 86 struct bfusb_data_scb { 87 struct urb *urb; 88 }; 89 90 static void bfusb_tx_complete(struct urb *urb); 91 static void bfusb_rx_complete(struct urb *urb); 92 93 static struct urb *bfusb_get_completed(struct bfusb_data *data) 94 { 95 struct sk_buff *skb; 96 struct urb *urb = NULL; 97 98 BT_DBG("bfusb %p", data); 99 100 skb = skb_dequeue(&data->completed_q); 101 if (skb) { 102 urb = ((struct bfusb_data_scb *) skb->cb)->urb; 103 kfree_skb(skb); 104 } 105 106 return urb; 107 } 108 109 static void bfusb_unlink_urbs(struct bfusb_data *data) 110 { 111 struct sk_buff *skb; 112 struct urb *urb; 113 114 BT_DBG("bfusb %p", data); 115 116 while ((skb = skb_dequeue(&data->pending_q))) { 117 urb = ((struct bfusb_data_scb *) skb->cb)->urb; 118 usb_kill_urb(urb); 119 skb_queue_tail(&data->completed_q, skb); 120 } 121 122 while ((urb = bfusb_get_completed(data))) 123 usb_free_urb(urb); 124 } 125 126 static int bfusb_send_bulk(struct bfusb_data *data, struct sk_buff *skb) 127 { 128 struct bfusb_data_scb *scb = (void *) skb->cb; 129 struct urb *urb = bfusb_get_completed(data); 130 int err, pipe; 131 132 BT_DBG("bfusb %p skb %p len %d", data, skb, skb->len); 133 134 if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC))) 135 return -ENOMEM; 136 137 pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep); 138 139 usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, skb->len, 140 bfusb_tx_complete, skb); 141 142 scb->urb = urb; 143 144 skb_queue_tail(&data->pending_q, skb); 145 146 err = usb_submit_urb(urb, GFP_ATOMIC); 147 if (err) { 148 BT_ERR("%s bulk tx submit failed urb %p err %d", 149 data->hdev->name, urb, err); 150 skb_unlink(skb, &data->pending_q); 151 usb_free_urb(urb); 152 } else 153 atomic_inc(&data->pending_tx); 154 155 return err; 156 } 157 158 static void bfusb_tx_wakeup(struct bfusb_data *data) 159 { 160 struct sk_buff *skb; 161 162 BT_DBG("bfusb %p", data); 163 164 if (test_and_set_bit(BFUSB_TX_PROCESS, &data->state)) { 165 set_bit(BFUSB_TX_WAKEUP, &data->state); 166 return; 167 } 168 169 do { 170 clear_bit(BFUSB_TX_WAKEUP, &data->state); 171 172 while ((atomic_read(&data->pending_tx) < BFUSB_MAX_BULK_TX) && 173 (skb = skb_dequeue(&data->transmit_q))) { 174 if (bfusb_send_bulk(data, skb) < 0) { 175 skb_queue_head(&data->transmit_q, skb); 176 break; 177 } 178 } 179 180 } while (test_bit(BFUSB_TX_WAKEUP, &data->state)); 181 182 clear_bit(BFUSB_TX_PROCESS, &data->state); 183 } 184 185 static void bfusb_tx_complete(struct urb *urb) 186 { 187 struct sk_buff *skb = (struct sk_buff *) urb->context; 188 struct bfusb_data *data = (struct bfusb_data *) skb->dev; 189 190 BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len); 191 192 atomic_dec(&data->pending_tx); 193 194 if (!test_bit(HCI_RUNNING, &data->hdev->flags)) 195 return; 196 197 if (!urb->status) 198 data->hdev->stat.byte_tx += skb->len; 199 else 200 data->hdev->stat.err_tx++; 201 202 read_lock(&data->lock); 203 204 skb_unlink(skb, &data->pending_q); 205 skb_queue_tail(&data->completed_q, skb); 206 207 bfusb_tx_wakeup(data); 208 209 read_unlock(&data->lock); 210 } 211 212 213 static int bfusb_rx_submit(struct bfusb_data *data, struct urb *urb) 214 { 215 struct bfusb_data_scb *scb; 216 struct sk_buff *skb; 217 int err, pipe, size = HCI_MAX_FRAME_SIZE + 32; 218 219 BT_DBG("bfusb %p urb %p", data, urb); 220 221 if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC))) 222 return -ENOMEM; 223 224 skb = bt_skb_alloc(size, GFP_ATOMIC); 225 if (!skb) { 226 usb_free_urb(urb); 227 return -ENOMEM; 228 } 229 230 skb->dev = (void *) data; 231 232 scb = (struct bfusb_data_scb *) skb->cb; 233 scb->urb = urb; 234 235 pipe = usb_rcvbulkpipe(data->udev, data->bulk_in_ep); 236 237 usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, size, 238 bfusb_rx_complete, skb); 239 240 skb_queue_tail(&data->pending_q, skb); 241 242 err = usb_submit_urb(urb, GFP_ATOMIC); 243 if (err) { 244 BT_ERR("%s bulk rx submit failed urb %p err %d", 245 data->hdev->name, urb, err); 246 skb_unlink(skb, &data->pending_q); 247 kfree_skb(skb); 248 usb_free_urb(urb); 249 } 250 251 return err; 252 } 253 254 static inline int bfusb_recv_block(struct bfusb_data *data, int hdr, unsigned char *buf, int len) 255 { 256 BT_DBG("bfusb %p hdr 0x%02x data %p len %d", data, hdr, buf, len); 257 258 if (hdr & 0x10) { 259 BT_ERR("%s error in block", data->hdev->name); 260 if (data->reassembly) 261 kfree_skb(data->reassembly); 262 data->reassembly = NULL; 263 return -EIO; 264 } 265 266 if (hdr & 0x04) { 267 struct sk_buff *skb; 268 unsigned char pkt_type; 269 int pkt_len = 0; 270 271 if (data->reassembly) { 272 BT_ERR("%s unexpected start block", data->hdev->name); 273 kfree_skb(data->reassembly); 274 data->reassembly = NULL; 275 } 276 277 if (len < 1) { 278 BT_ERR("%s no packet type found", data->hdev->name); 279 return -EPROTO; 280 } 281 282 pkt_type = *buf++; len--; 283 284 switch (pkt_type) { 285 case HCI_EVENT_PKT: 286 if (len >= HCI_EVENT_HDR_SIZE) { 287 struct hci_event_hdr *hdr = (struct hci_event_hdr *) buf; 288 pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen; 289 } else { 290 BT_ERR("%s event block is too short", data->hdev->name); 291 return -EILSEQ; 292 } 293 break; 294 295 case HCI_ACLDATA_PKT: 296 if (len >= HCI_ACL_HDR_SIZE) { 297 struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) buf; 298 pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen); 299 } else { 300 BT_ERR("%s data block is too short", data->hdev->name); 301 return -EILSEQ; 302 } 303 break; 304 305 case HCI_SCODATA_PKT: 306 if (len >= HCI_SCO_HDR_SIZE) { 307 struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) buf; 308 pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen; 309 } else { 310 BT_ERR("%s audio block is too short", data->hdev->name); 311 return -EILSEQ; 312 } 313 break; 314 } 315 316 skb = bt_skb_alloc(pkt_len, GFP_ATOMIC); 317 if (!skb) { 318 BT_ERR("%s no memory for the packet", data->hdev->name); 319 return -ENOMEM; 320 } 321 322 skb->dev = (void *) data->hdev; 323 bt_cb(skb)->pkt_type = pkt_type; 324 325 data->reassembly = skb; 326 } else { 327 if (!data->reassembly) { 328 BT_ERR("%s unexpected continuation block", data->hdev->name); 329 return -EIO; 330 } 331 } 332 333 if (len > 0) 334 memcpy(skb_put(data->reassembly, len), buf, len); 335 336 if (hdr & 0x08) { 337 hci_recv_frame(data->reassembly); 338 data->reassembly = NULL; 339 } 340 341 return 0; 342 } 343 344 static void bfusb_rx_complete(struct urb *urb) 345 { 346 struct sk_buff *skb = (struct sk_buff *) urb->context; 347 struct bfusb_data *data = (struct bfusb_data *) skb->dev; 348 unsigned char *buf = urb->transfer_buffer; 349 int count = urb->actual_length; 350 int err, hdr, len; 351 352 BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len); 353 354 read_lock(&data->lock); 355 356 if (!test_bit(HCI_RUNNING, &data->hdev->flags)) 357 goto unlock; 358 359 if (urb->status || !count) 360 goto resubmit; 361 362 data->hdev->stat.byte_rx += count; 363 364 skb_put(skb, count); 365 366 while (count) { 367 hdr = buf[0] | (buf[1] << 8); 368 369 if (hdr & 0x4000) { 370 len = 0; 371 count -= 2; 372 buf += 2; 373 } else { 374 len = (buf[2] == 0) ? 256 : buf[2]; 375 count -= 3; 376 buf += 3; 377 } 378 379 if (count < len) { 380 BT_ERR("%s block extends over URB buffer ranges", 381 data->hdev->name); 382 } 383 384 if ((hdr & 0xe1) == 0xc1) 385 bfusb_recv_block(data, hdr, buf, len); 386 387 count -= len; 388 buf += len; 389 } 390 391 skb_unlink(skb, &data->pending_q); 392 kfree_skb(skb); 393 394 bfusb_rx_submit(data, urb); 395 396 read_unlock(&data->lock); 397 398 return; 399 400 resubmit: 401 urb->dev = data->udev; 402 403 err = usb_submit_urb(urb, GFP_ATOMIC); 404 if (err) { 405 BT_ERR("%s bulk resubmit failed urb %p err %d", 406 data->hdev->name, urb, err); 407 } 408 409 unlock: 410 read_unlock(&data->lock); 411 } 412 413 static int bfusb_open(struct hci_dev *hdev) 414 { 415 struct bfusb_data *data = hdev->driver_data; 416 unsigned long flags; 417 int i, err; 418 419 BT_DBG("hdev %p bfusb %p", hdev, data); 420 421 if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) 422 return 0; 423 424 write_lock_irqsave(&data->lock, flags); 425 426 err = bfusb_rx_submit(data, NULL); 427 if (!err) { 428 for (i = 1; i < BFUSB_MAX_BULK_RX; i++) 429 bfusb_rx_submit(data, NULL); 430 } else { 431 clear_bit(HCI_RUNNING, &hdev->flags); 432 } 433 434 write_unlock_irqrestore(&data->lock, flags); 435 436 return err; 437 } 438 439 static int bfusb_flush(struct hci_dev *hdev) 440 { 441 struct bfusb_data *data = hdev->driver_data; 442 443 BT_DBG("hdev %p bfusb %p", hdev, data); 444 445 skb_queue_purge(&data->transmit_q); 446 447 return 0; 448 } 449 450 static int bfusb_close(struct hci_dev *hdev) 451 { 452 struct bfusb_data *data = hdev->driver_data; 453 unsigned long flags; 454 455 BT_DBG("hdev %p bfusb %p", hdev, data); 456 457 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 458 return 0; 459 460 write_lock_irqsave(&data->lock, flags); 461 write_unlock_irqrestore(&data->lock, flags); 462 463 bfusb_unlink_urbs(data); 464 bfusb_flush(hdev); 465 466 return 0; 467 } 468 469 static int bfusb_send_frame(struct sk_buff *skb) 470 { 471 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 472 struct bfusb_data *data; 473 struct sk_buff *nskb; 474 unsigned char buf[3]; 475 int sent = 0, size, count; 476 477 BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len); 478 479 if (!hdev) { 480 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 481 return -ENODEV; 482 } 483 484 if (!test_bit(HCI_RUNNING, &hdev->flags)) 485 return -EBUSY; 486 487 data = hdev->driver_data; 488 489 switch (bt_cb(skb)->pkt_type) { 490 case HCI_COMMAND_PKT: 491 hdev->stat.cmd_tx++; 492 break; 493 case HCI_ACLDATA_PKT: 494 hdev->stat.acl_tx++; 495 break; 496 case HCI_SCODATA_PKT: 497 hdev->stat.sco_tx++; 498 break; 499 }; 500 501 /* Prepend skb with frame type */ 502 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 503 504 count = skb->len; 505 506 /* Max HCI frame size seems to be 1511 + 1 */ 507 nskb = bt_skb_alloc(count + 32, GFP_ATOMIC); 508 if (!nskb) { 509 BT_ERR("Can't allocate memory for new packet"); 510 return -ENOMEM; 511 } 512 513 nskb->dev = (void *) data; 514 515 while (count) { 516 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE); 517 518 buf[0] = 0xc1 | ((sent == 0) ? 0x04 : 0) | ((count == size) ? 0x08 : 0); 519 buf[1] = 0x00; 520 buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size; 521 522 memcpy(skb_put(nskb, 3), buf, 3); 523 skb_copy_from_linear_data_offset(skb, sent, skb_put(nskb, size), size); 524 525 sent += size; 526 count -= size; 527 } 528 529 /* Don't send frame with multiple size of bulk max packet */ 530 if ((nskb->len % data->bulk_pkt_size) == 0) { 531 buf[0] = 0xdd; 532 buf[1] = 0x00; 533 memcpy(skb_put(nskb, 2), buf, 2); 534 } 535 536 read_lock(&data->lock); 537 538 skb_queue_tail(&data->transmit_q, nskb); 539 bfusb_tx_wakeup(data); 540 541 read_unlock(&data->lock); 542 543 kfree_skb(skb); 544 545 return 0; 546 } 547 548 static void bfusb_destruct(struct hci_dev *hdev) 549 { 550 struct bfusb_data *data = hdev->driver_data; 551 552 BT_DBG("hdev %p bfusb %p", hdev, data); 553 554 kfree(data); 555 } 556 557 static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 558 { 559 return -ENOIOCTLCMD; 560 } 561 562 static int bfusb_load_firmware(struct bfusb_data *data, 563 const unsigned char *firmware, int count) 564 { 565 unsigned char *buf; 566 int err, pipe, len, size, sent = 0; 567 568 BT_DBG("bfusb %p udev %p", data, data->udev); 569 570 BT_INFO("BlueFRITZ! USB loading firmware"); 571 572 pipe = usb_sndctrlpipe(data->udev, 0); 573 574 if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION, 575 0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) { 576 BT_ERR("Can't change to loading configuration"); 577 return -EBUSY; 578 } 579 580 data->udev->toggle[0] = data->udev->toggle[1] = 0; 581 582 buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC); 583 if (!buf) { 584 BT_ERR("Can't allocate memory chunk for firmware"); 585 return -ENOMEM; 586 } 587 588 pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep); 589 590 while (count) { 591 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3); 592 593 memcpy(buf, firmware + sent, size); 594 595 err = usb_bulk_msg(data->udev, pipe, buf, size, 596 &len, BFUSB_BLOCK_TIMEOUT); 597 598 if (err || (len != size)) { 599 BT_ERR("Error in firmware loading"); 600 goto error; 601 } 602 603 sent += size; 604 count -= size; 605 } 606 607 err = usb_bulk_msg(data->udev, pipe, NULL, 0, 608 &len, BFUSB_BLOCK_TIMEOUT); 609 if (err < 0) { 610 BT_ERR("Error in null packet request"); 611 goto error; 612 } 613 614 pipe = usb_sndctrlpipe(data->udev, 0); 615 616 err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION, 617 0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 618 if (err < 0) { 619 BT_ERR("Can't change to running configuration"); 620 goto error; 621 } 622 623 data->udev->toggle[0] = data->udev->toggle[1] = 0; 624 625 BT_INFO("BlueFRITZ! USB device ready"); 626 627 kfree(buf); 628 return 0; 629 630 error: 631 kfree(buf); 632 633 pipe = usb_sndctrlpipe(data->udev, 0); 634 635 usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION, 636 0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 637 638 return err; 639 } 640 641 static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *id) 642 { 643 const struct firmware *firmware; 644 struct usb_device *udev = interface_to_usbdev(intf); 645 struct usb_host_endpoint *bulk_out_ep; 646 struct usb_host_endpoint *bulk_in_ep; 647 struct hci_dev *hdev; 648 struct bfusb_data *data; 649 650 BT_DBG("intf %p id %p", intf, id); 651 652 /* Check number of endpoints */ 653 if (intf->cur_altsetting->desc.bNumEndpoints < 2) 654 return -EIO; 655 656 bulk_out_ep = &intf->cur_altsetting->endpoint[0]; 657 bulk_in_ep = &intf->cur_altsetting->endpoint[1]; 658 659 if (!bulk_out_ep || !bulk_in_ep) { 660 BT_ERR("Bulk endpoints not found"); 661 goto done; 662 } 663 664 /* Initialize control structure and load firmware */ 665 data = kzalloc(sizeof(struct bfusb_data), GFP_KERNEL); 666 if (!data) { 667 BT_ERR("Can't allocate memory for control structure"); 668 goto done; 669 } 670 671 data->udev = udev; 672 data->bulk_in_ep = bulk_in_ep->desc.bEndpointAddress; 673 data->bulk_out_ep = bulk_out_ep->desc.bEndpointAddress; 674 data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize); 675 676 rwlock_init(&data->lock); 677 678 data->reassembly = NULL; 679 680 skb_queue_head_init(&data->transmit_q); 681 skb_queue_head_init(&data->pending_q); 682 skb_queue_head_init(&data->completed_q); 683 684 if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) { 685 BT_ERR("Firmware request failed"); 686 goto error; 687 } 688 689 BT_DBG("firmware data %p size %zu", firmware->data, firmware->size); 690 691 if (bfusb_load_firmware(data, firmware->data, firmware->size) < 0) { 692 BT_ERR("Firmware loading failed"); 693 goto release; 694 } 695 696 release_firmware(firmware); 697 698 /* Initialize and register HCI device */ 699 hdev = hci_alloc_dev(); 700 if (!hdev) { 701 BT_ERR("Can't allocate HCI device"); 702 goto error; 703 } 704 705 data->hdev = hdev; 706 707 hdev->type = HCI_USB; 708 hdev->driver_data = data; 709 SET_HCIDEV_DEV(hdev, &intf->dev); 710 711 hdev->open = bfusb_open; 712 hdev->close = bfusb_close; 713 hdev->flush = bfusb_flush; 714 hdev->send = bfusb_send_frame; 715 hdev->destruct = bfusb_destruct; 716 hdev->ioctl = bfusb_ioctl; 717 718 hdev->owner = THIS_MODULE; 719 720 if (hci_register_dev(hdev) < 0) { 721 BT_ERR("Can't register HCI device"); 722 hci_free_dev(hdev); 723 goto error; 724 } 725 726 usb_set_intfdata(intf, data); 727 728 return 0; 729 730 release: 731 release_firmware(firmware); 732 733 error: 734 kfree(data); 735 736 done: 737 return -EIO; 738 } 739 740 static void bfusb_disconnect(struct usb_interface *intf) 741 { 742 struct bfusb_data *data = usb_get_intfdata(intf); 743 struct hci_dev *hdev = data->hdev; 744 745 BT_DBG("intf %p", intf); 746 747 if (!hdev) 748 return; 749 750 usb_set_intfdata(intf, NULL); 751 752 bfusb_close(hdev); 753 754 if (hci_unregister_dev(hdev) < 0) 755 BT_ERR("Can't unregister HCI device %s", hdev->name); 756 757 hci_free_dev(hdev); 758 } 759 760 static struct usb_driver bfusb_driver = { 761 .name = "bfusb", 762 .probe = bfusb_probe, 763 .disconnect = bfusb_disconnect, 764 .id_table = bfusb_table, 765 }; 766 767 static int __init bfusb_init(void) 768 { 769 int err; 770 771 BT_INFO("BlueFRITZ! USB driver ver %s", VERSION); 772 773 err = usb_register(&bfusb_driver); 774 if (err < 0) 775 BT_ERR("Failed to register BlueFRITZ! USB driver"); 776 777 return err; 778 } 779 780 static void __exit bfusb_exit(void) 781 { 782 usb_deregister(&bfusb_driver); 783 } 784 785 module_init(bfusb_init); 786 module_exit(bfusb_exit); 787 788 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 789 MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION); 790 MODULE_VERSION(VERSION); 791 MODULE_LICENSE("GPL"); 792 MODULE_FIRMWARE("bfubase.frm"); 793