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