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