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/sched.h> 31 #include <linux/errno.h> 32 #include <linux/skbuff.h> 33 34 #include <linux/device.h> 35 #include <linux/firmware.h> 36 37 #include <linux/usb.h> 38 39 #include <net/bluetooth/bluetooth.h> 40 #include <net/bluetooth/hci_core.h> 41 42 #ifndef CONFIG_BT_HCIBFUSB_DEBUG 43 #undef BT_DBG 44 #define BT_DBG(D...) 45 #endif 46 47 #define VERSION "1.1" 48 49 static int ignore = 0; 50 51 static struct usb_driver bfusb_driver; 52 53 static struct usb_device_id bfusb_table[] = { 54 /* AVM BlueFRITZ! USB */ 55 { USB_DEVICE(0x057c, 0x2200) }, 56 57 { } /* Terminating entry */ 58 }; 59 60 MODULE_DEVICE_TABLE(usb, bfusb_table); 61 62 #define BFUSB_MAX_BLOCK_SIZE 256 63 64 #define BFUSB_BLOCK_TIMEOUT 3000 65 66 #define BFUSB_TX_PROCESS 1 67 #define BFUSB_TX_WAKEUP 2 68 69 #define BFUSB_MAX_BULK_TX 2 70 #define BFUSB_MAX_BULK_RX 2 71 72 struct bfusb_data { 73 struct hci_dev *hdev; 74 75 unsigned long state; 76 77 struct usb_device *udev; 78 79 unsigned int bulk_in_ep; 80 unsigned int bulk_out_ep; 81 unsigned int bulk_pkt_size; 82 83 rwlock_t lock; 84 85 struct sk_buff_head transmit_q; 86 87 struct sk_buff *reassembly; 88 89 atomic_t pending_tx; 90 struct sk_buff_head pending_q; 91 struct sk_buff_head completed_q; 92 }; 93 94 struct bfusb_data_scb { 95 struct urb *urb; 96 }; 97 98 static void bfusb_tx_complete(struct urb *urb); 99 static void bfusb_rx_complete(struct urb *urb); 100 101 static struct urb *bfusb_get_completed(struct bfusb_data *data) 102 { 103 struct sk_buff *skb; 104 struct urb *urb = NULL; 105 106 BT_DBG("bfusb %p", data); 107 108 skb = skb_dequeue(&data->completed_q); 109 if (skb) { 110 urb = ((struct bfusb_data_scb *) skb->cb)->urb; 111 kfree_skb(skb); 112 } 113 114 return urb; 115 } 116 117 static void bfusb_unlink_urbs(struct bfusb_data *data) 118 { 119 struct sk_buff *skb; 120 struct urb *urb; 121 122 BT_DBG("bfusb %p", data); 123 124 while ((skb = skb_dequeue(&data->pending_q))) { 125 urb = ((struct bfusb_data_scb *) skb->cb)->urb; 126 usb_kill_urb(urb); 127 skb_queue_tail(&data->completed_q, skb); 128 } 129 130 while ((urb = bfusb_get_completed(data))) 131 usb_free_urb(urb); 132 } 133 134 static int bfusb_send_bulk(struct bfusb_data *data, struct sk_buff *skb) 135 { 136 struct bfusb_data_scb *scb = (void *) skb->cb; 137 struct urb *urb = bfusb_get_completed(data); 138 int err, pipe; 139 140 BT_DBG("bfusb %p skb %p len %d", data, skb, skb->len); 141 142 if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC))) 143 return -ENOMEM; 144 145 pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep); 146 147 usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, skb->len, 148 bfusb_tx_complete, skb); 149 150 scb->urb = urb; 151 152 skb_queue_tail(&data->pending_q, skb); 153 154 err = usb_submit_urb(urb, GFP_ATOMIC); 155 if (err) { 156 BT_ERR("%s bulk tx submit failed urb %p err %d", 157 data->hdev->name, urb, err); 158 skb_unlink(skb, &data->pending_q); 159 usb_free_urb(urb); 160 } else 161 atomic_inc(&data->pending_tx); 162 163 return err; 164 } 165 166 static void bfusb_tx_wakeup(struct bfusb_data *data) 167 { 168 struct sk_buff *skb; 169 170 BT_DBG("bfusb %p", data); 171 172 if (test_and_set_bit(BFUSB_TX_PROCESS, &data->state)) { 173 set_bit(BFUSB_TX_WAKEUP, &data->state); 174 return; 175 } 176 177 do { 178 clear_bit(BFUSB_TX_WAKEUP, &data->state); 179 180 while ((atomic_read(&data->pending_tx) < BFUSB_MAX_BULK_TX) && 181 (skb = skb_dequeue(&data->transmit_q))) { 182 if (bfusb_send_bulk(data, skb) < 0) { 183 skb_queue_head(&data->transmit_q, skb); 184 break; 185 } 186 } 187 188 } while (test_bit(BFUSB_TX_WAKEUP, &data->state)); 189 190 clear_bit(BFUSB_TX_PROCESS, &data->state); 191 } 192 193 static void bfusb_tx_complete(struct urb *urb) 194 { 195 struct sk_buff *skb = (struct sk_buff *) urb->context; 196 struct bfusb_data *data = (struct bfusb_data *) skb->dev; 197 198 BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len); 199 200 atomic_dec(&data->pending_tx); 201 202 if (!test_bit(HCI_RUNNING, &data->hdev->flags)) 203 return; 204 205 if (!urb->status) 206 data->hdev->stat.byte_tx += skb->len; 207 else 208 data->hdev->stat.err_tx++; 209 210 read_lock(&data->lock); 211 212 skb_unlink(skb, &data->pending_q); 213 skb_queue_tail(&data->completed_q, skb); 214 215 bfusb_tx_wakeup(data); 216 217 read_unlock(&data->lock); 218 } 219 220 221 static int bfusb_rx_submit(struct bfusb_data *data, struct urb *urb) 222 { 223 struct bfusb_data_scb *scb; 224 struct sk_buff *skb; 225 int err, pipe, size = HCI_MAX_FRAME_SIZE + 32; 226 227 BT_DBG("bfusb %p urb %p", bfusb, urb); 228 229 if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC))) 230 return -ENOMEM; 231 232 skb = bt_skb_alloc(size, GFP_ATOMIC); 233 if (!skb) { 234 usb_free_urb(urb); 235 return -ENOMEM; 236 } 237 238 skb->dev = (void *) data; 239 240 scb = (struct bfusb_data_scb *) skb->cb; 241 scb->urb = urb; 242 243 pipe = usb_rcvbulkpipe(data->udev, data->bulk_in_ep); 244 245 usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, size, 246 bfusb_rx_complete, skb); 247 248 skb_queue_tail(&data->pending_q, skb); 249 250 err = usb_submit_urb(urb, GFP_ATOMIC); 251 if (err) { 252 BT_ERR("%s bulk rx submit failed urb %p err %d", 253 data->hdev->name, urb, err); 254 skb_unlink(skb, &data->pending_q); 255 kfree_skb(skb); 256 usb_free_urb(urb); 257 } 258 259 return err; 260 } 261 262 static inline int bfusb_recv_block(struct bfusb_data *data, int hdr, unsigned char *buf, int len) 263 { 264 BT_DBG("bfusb %p hdr 0x%02x data %p len %d", data, hdr, buf, len); 265 266 if (hdr & 0x10) { 267 BT_ERR("%s error in block", data->hdev->name); 268 if (data->reassembly) 269 kfree_skb(data->reassembly); 270 data->reassembly = NULL; 271 return -EIO; 272 } 273 274 if (hdr & 0x04) { 275 struct sk_buff *skb; 276 unsigned char pkt_type; 277 int pkt_len = 0; 278 279 if (data->reassembly) { 280 BT_ERR("%s unexpected start block", data->hdev->name); 281 kfree_skb(data->reassembly); 282 data->reassembly = NULL; 283 } 284 285 if (len < 1) { 286 BT_ERR("%s no packet type found", data->hdev->name); 287 return -EPROTO; 288 } 289 290 pkt_type = *buf++; len--; 291 292 switch (pkt_type) { 293 case HCI_EVENT_PKT: 294 if (len >= HCI_EVENT_HDR_SIZE) { 295 struct hci_event_hdr *hdr = (struct hci_event_hdr *) buf; 296 pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen; 297 } else { 298 BT_ERR("%s event block is too short", data->hdev->name); 299 return -EILSEQ; 300 } 301 break; 302 303 case HCI_ACLDATA_PKT: 304 if (len >= HCI_ACL_HDR_SIZE) { 305 struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) buf; 306 pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen); 307 } else { 308 BT_ERR("%s data block is too short", data->hdev->name); 309 return -EILSEQ; 310 } 311 break; 312 313 case HCI_SCODATA_PKT: 314 if (len >= HCI_SCO_HDR_SIZE) { 315 struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) buf; 316 pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen; 317 } else { 318 BT_ERR("%s audio block is too short", data->hdev->name); 319 return -EILSEQ; 320 } 321 break; 322 } 323 324 skb = bt_skb_alloc(pkt_len, GFP_ATOMIC); 325 if (!skb) { 326 BT_ERR("%s no memory for the packet", data->hdev->name); 327 return -ENOMEM; 328 } 329 330 skb->dev = (void *) data->hdev; 331 bt_cb(skb)->pkt_type = pkt_type; 332 333 data->reassembly = skb; 334 } else { 335 if (!data->reassembly) { 336 BT_ERR("%s unexpected continuation block", data->hdev->name); 337 return -EIO; 338 } 339 } 340 341 if (len > 0) 342 memcpy(skb_put(data->reassembly, len), buf, len); 343 344 if (hdr & 0x08) { 345 hci_recv_frame(data->reassembly); 346 data->reassembly = NULL; 347 } 348 349 return 0; 350 } 351 352 static void bfusb_rx_complete(struct urb *urb) 353 { 354 struct sk_buff *skb = (struct sk_buff *) urb->context; 355 struct bfusb_data *data = (struct bfusb_data *) skb->dev; 356 unsigned char *buf = urb->transfer_buffer; 357 int count = urb->actual_length; 358 int err, hdr, len; 359 360 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len); 361 362 read_lock(&data->lock); 363 364 if (!test_bit(HCI_RUNNING, &data->hdev->flags)) 365 goto unlock; 366 367 if (urb->status || !count) 368 goto resubmit; 369 370 data->hdev->stat.byte_rx += count; 371 372 skb_put(skb, count); 373 374 while (count) { 375 hdr = buf[0] | (buf[1] << 8); 376 377 if (hdr & 0x4000) { 378 len = 0; 379 count -= 2; 380 buf += 2; 381 } else { 382 len = (buf[2] == 0) ? 256 : buf[2]; 383 count -= 3; 384 buf += 3; 385 } 386 387 if (count < len) { 388 BT_ERR("%s block extends over URB buffer ranges", 389 data->hdev->name); 390 } 391 392 if ((hdr & 0xe1) == 0xc1) 393 bfusb_recv_block(data, hdr, buf, len); 394 395 count -= len; 396 buf += len; 397 } 398 399 skb_unlink(skb, &data->pending_q); 400 kfree_skb(skb); 401 402 bfusb_rx_submit(data, urb); 403 404 read_unlock(&data->lock); 405 406 return; 407 408 resubmit: 409 urb->dev = data->udev; 410 411 err = usb_submit_urb(urb, GFP_ATOMIC); 412 if (err) { 413 BT_ERR("%s bulk resubmit failed urb %p err %d", 414 data->hdev->name, urb, err); 415 } 416 417 unlock: 418 read_unlock(&data->lock); 419 } 420 421 static int bfusb_open(struct hci_dev *hdev) 422 { 423 struct bfusb_data *data = hdev->driver_data; 424 unsigned long flags; 425 int i, err; 426 427 BT_DBG("hdev %p bfusb %p", hdev, data); 428 429 if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) 430 return 0; 431 432 write_lock_irqsave(&data->lock, flags); 433 434 err = bfusb_rx_submit(data, NULL); 435 if (!err) { 436 for (i = 1; i < BFUSB_MAX_BULK_RX; i++) 437 bfusb_rx_submit(data, NULL); 438 } else { 439 clear_bit(HCI_RUNNING, &hdev->flags); 440 } 441 442 write_unlock_irqrestore(&data->lock, flags); 443 444 return err; 445 } 446 447 static int bfusb_flush(struct hci_dev *hdev) 448 { 449 struct bfusb_data *data = hdev->driver_data; 450 451 BT_DBG("hdev %p bfusb %p", hdev, data); 452 453 skb_queue_purge(&data->transmit_q); 454 455 return 0; 456 } 457 458 static int bfusb_close(struct hci_dev *hdev) 459 { 460 struct bfusb_data *data = hdev->driver_data; 461 unsigned long flags; 462 463 BT_DBG("hdev %p bfusb %p", hdev, data); 464 465 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 466 return 0; 467 468 write_lock_irqsave(&data->lock, flags); 469 write_unlock_irqrestore(&data->lock, flags); 470 471 bfusb_unlink_urbs(data); 472 bfusb_flush(hdev); 473 474 return 0; 475 } 476 477 static int bfusb_send_frame(struct sk_buff *skb) 478 { 479 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 480 struct bfusb_data *data; 481 struct sk_buff *nskb; 482 unsigned char buf[3]; 483 int sent = 0, size, count; 484 485 BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len); 486 487 if (!hdev) { 488 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 489 return -ENODEV; 490 } 491 492 if (!test_bit(HCI_RUNNING, &hdev->flags)) 493 return -EBUSY; 494 495 data = hdev->driver_data; 496 497 switch (bt_cb(skb)->pkt_type) { 498 case HCI_COMMAND_PKT: 499 hdev->stat.cmd_tx++; 500 break; 501 case HCI_ACLDATA_PKT: 502 hdev->stat.acl_tx++; 503 break; 504 case HCI_SCODATA_PKT: 505 hdev->stat.sco_tx++; 506 break; 507 }; 508 509 /* Prepend skb with frame type */ 510 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 511 512 count = skb->len; 513 514 /* Max HCI frame size seems to be 1511 + 1 */ 515 nskb = bt_skb_alloc(count + 32, GFP_ATOMIC); 516 if (!nskb) { 517 BT_ERR("Can't allocate memory for new packet"); 518 return -ENOMEM; 519 } 520 521 nskb->dev = (void *) data; 522 523 while (count) { 524 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE); 525 526 buf[0] = 0xc1 | ((sent == 0) ? 0x04 : 0) | ((count == size) ? 0x08 : 0); 527 buf[1] = 0x00; 528 buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size; 529 530 memcpy(skb_put(nskb, 3), buf, 3); 531 memcpy(skb_put(nskb, size), skb->data + sent, size); 532 533 sent += size; 534 count -= size; 535 } 536 537 /* Don't send frame with multiple size of bulk max packet */ 538 if ((nskb->len % data->bulk_pkt_size) == 0) { 539 buf[0] = 0xdd; 540 buf[1] = 0x00; 541 memcpy(skb_put(nskb, 2), buf, 2); 542 } 543 544 read_lock(&data->lock); 545 546 skb_queue_tail(&data->transmit_q, nskb); 547 bfusb_tx_wakeup(data); 548 549 read_unlock(&data->lock); 550 551 kfree_skb(skb); 552 553 return 0; 554 } 555 556 static void bfusb_destruct(struct hci_dev *hdev) 557 { 558 struct bfusb_data *data = hdev->driver_data; 559 560 BT_DBG("hdev %p bfusb %p", hdev, data); 561 562 kfree(data); 563 } 564 565 static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 566 { 567 return -ENOIOCTLCMD; 568 } 569 570 static int bfusb_load_firmware(struct bfusb_data *data, 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