1 /* A driver for the D-Link DSB-R100 USB radio and Gemtek USB Radio 21. 2 The device plugs into both the USB and an analog audio input, so this thing 3 only deals with initialisation and frequency setting, the 4 audio data has to be handled by a sound driver. 5 6 Major issue: I can't find out where the device reports the signal 7 strength, and indeed the windows software appearantly just looks 8 at the stereo indicator as well. So, scanning will only find 9 stereo stations. Sad, but I can't help it. 10 11 Also, the windows program sends oodles of messages over to the 12 device, and I couldn't figure out their meaning. My suspicion 13 is that they don't have any:-) 14 15 You might find some interesting stuff about this module at 16 http://unimut.fsk.uni-heidelberg.de/unimut/demi/dsbr 17 18 Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de> 19 20 This program is free software; you can redistribute it and/or modify 21 it under the terms of the GNU General Public License as published by 22 the Free Software Foundation; either version 2 of the License, or 23 (at your option) any later version. 24 25 This program is distributed in the hope that it will be useful, 26 but WITHOUT ANY WARRANTY; without even the implied warranty of 27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 28 GNU General Public License for more details. 29 30 You should have received a copy of the GNU General Public License 31 along with this program; if not, write to the Free Software 32 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 33 34 History: 35 36 Version 0.45: 37 Converted to v4l2_device. 38 39 Version 0.44: 40 Add suspend/resume functions, fix unplug of device, 41 a lot of cleanups and fixes by Alexey Klimov <klimov.linux@gmail.com> 42 43 Version 0.43: 44 Oliver Neukum: avoided DMA coherency issue 45 46 Version 0.42: 47 Converted dsbr100 to use video_ioctl2 48 by Douglas Landgraf <dougsland@gmail.com> 49 50 Version 0.41-ac1: 51 Alan Cox: Some cleanups and fixes 52 53 Version 0.41: 54 Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org> 55 56 Version 0.40: 57 Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing 58 59 Version 0.30: 60 Markus: Updates for 2.5.x kernel and more ISO compliant source 61 62 Version 0.25: 63 PSL and Markus: Cleanup, radio now doesn't stop on device close 64 65 Version 0.24: 66 Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally 67 right. Some minor cleanup, improved standalone compilation 68 69 Version 0.23: 70 Markus: Sign extension bug fixed by declaring transfer_buffer unsigned 71 72 Version 0.22: 73 Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns, 74 thanks to Mike Cox for pointing the problem out. 75 76 Version 0.21: 77 Markus: Minor cleanup, warnings if something goes wrong, lame attempt 78 to adhere to Documentation/CodingStyle 79 80 Version 0.2: 81 Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module 82 Markus: Copyright clarification 83 84 Version 0.01: Markus: initial release 85 86 */ 87 88 #include <linux/kernel.h> 89 #include <linux/module.h> 90 #include <linux/init.h> 91 #include <linux/slab.h> 92 #include <linux/input.h> 93 #include <linux/videodev2.h> 94 #include <media/v4l2-device.h> 95 #include <media/v4l2-ioctl.h> 96 #include <linux/usb.h> 97 98 /* 99 * Version Information 100 */ 101 #include <linux/version.h> /* for KERNEL_VERSION MACRO */ 102 103 #define DRIVER_VERSION "v0.45" 104 #define RADIO_VERSION KERNEL_VERSION(0, 4, 5) 105 106 #define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>" 107 #define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver" 108 109 #define DSB100_VENDOR 0x04b4 110 #define DSB100_PRODUCT 0x1002 111 112 /* Commands the device appears to understand */ 113 #define DSB100_TUNE 1 114 #define DSB100_ONOFF 2 115 116 #define TB_LEN 16 117 118 /* Frequency limits in MHz -- these are European values. For Japanese 119 devices, that would be 76 and 91. */ 120 #define FREQ_MIN 87.5 121 #define FREQ_MAX 108.0 122 #define FREQ_MUL 16000 123 124 #define videodev_to_radio(d) container_of(d, struct dsbr100_device, videodev) 125 126 static int usb_dsbr100_probe(struct usb_interface *intf, 127 const struct usb_device_id *id); 128 static void usb_dsbr100_disconnect(struct usb_interface *intf); 129 static int usb_dsbr100_open(struct file *file); 130 static int usb_dsbr100_close(struct file *file); 131 static int usb_dsbr100_suspend(struct usb_interface *intf, 132 pm_message_t message); 133 static int usb_dsbr100_resume(struct usb_interface *intf); 134 135 static int radio_nr = -1; 136 module_param(radio_nr, int, 0); 137 138 /* Data for one (physical) device */ 139 struct dsbr100_device { 140 struct usb_device *usbdev; 141 struct video_device videodev; 142 struct v4l2_device v4l2_dev; 143 144 u8 *transfer_buffer; 145 struct mutex lock; /* buffer locking */ 146 int curfreq; 147 int stereo; 148 int users; 149 int removed; 150 int muted; 151 }; 152 153 static struct usb_device_id usb_dsbr100_device_table [] = { 154 { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) }, 155 { } /* Terminating entry */ 156 }; 157 158 MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table); 159 160 /* USB subsystem interface */ 161 static struct usb_driver usb_dsbr100_driver = { 162 .name = "dsbr100", 163 .probe = usb_dsbr100_probe, 164 .disconnect = usb_dsbr100_disconnect, 165 .id_table = usb_dsbr100_device_table, 166 .suspend = usb_dsbr100_suspend, 167 .resume = usb_dsbr100_resume, 168 .reset_resume = usb_dsbr100_resume, 169 .supports_autosuspend = 0, 170 }; 171 172 /* Low-level device interface begins here */ 173 174 /* switch on radio */ 175 static int dsbr100_start(struct dsbr100_device *radio) 176 { 177 int retval; 178 int request; 179 180 mutex_lock(&radio->lock); 181 182 retval = usb_control_msg(radio->usbdev, 183 usb_rcvctrlpipe(radio->usbdev, 0), 184 USB_REQ_GET_STATUS, 185 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 186 0x00, 0xC7, radio->transfer_buffer, 8, 300); 187 188 if (retval < 0) { 189 request = USB_REQ_GET_STATUS; 190 goto usb_control_msg_failed; 191 } 192 193 retval = usb_control_msg(radio->usbdev, 194 usb_rcvctrlpipe(radio->usbdev, 0), 195 DSB100_ONOFF, 196 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 197 0x01, 0x00, radio->transfer_buffer, 8, 300); 198 199 if (retval < 0) { 200 request = DSB100_ONOFF; 201 goto usb_control_msg_failed; 202 } 203 204 radio->muted = 0; 205 mutex_unlock(&radio->lock); 206 return (radio->transfer_buffer)[0]; 207 208 usb_control_msg_failed: 209 mutex_unlock(&radio->lock); 210 dev_err(&radio->usbdev->dev, 211 "%s - usb_control_msg returned %i, request %i\n", 212 __func__, retval, request); 213 return retval; 214 215 } 216 217 /* switch off radio */ 218 static int dsbr100_stop(struct dsbr100_device *radio) 219 { 220 int retval; 221 int request; 222 223 mutex_lock(&radio->lock); 224 225 retval = usb_control_msg(radio->usbdev, 226 usb_rcvctrlpipe(radio->usbdev, 0), 227 USB_REQ_GET_STATUS, 228 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 229 0x16, 0x1C, radio->transfer_buffer, 8, 300); 230 231 if (retval < 0) { 232 request = USB_REQ_GET_STATUS; 233 goto usb_control_msg_failed; 234 } 235 236 retval = usb_control_msg(radio->usbdev, 237 usb_rcvctrlpipe(radio->usbdev, 0), 238 DSB100_ONOFF, 239 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 240 0x00, 0x00, radio->transfer_buffer, 8, 300); 241 242 if (retval < 0) { 243 request = DSB100_ONOFF; 244 goto usb_control_msg_failed; 245 } 246 247 radio->muted = 1; 248 mutex_unlock(&radio->lock); 249 return (radio->transfer_buffer)[0]; 250 251 usb_control_msg_failed: 252 mutex_unlock(&radio->lock); 253 dev_err(&radio->usbdev->dev, 254 "%s - usb_control_msg returned %i, request %i\n", 255 __func__, retval, request); 256 return retval; 257 258 } 259 260 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */ 261 static int dsbr100_setfreq(struct dsbr100_device *radio, int freq) 262 { 263 int retval; 264 int request; 265 266 freq = (freq / 16 * 80) / 1000 + 856; 267 mutex_lock(&radio->lock); 268 269 retval = usb_control_msg(radio->usbdev, 270 usb_rcvctrlpipe(radio->usbdev, 0), 271 DSB100_TUNE, 272 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 273 (freq >> 8) & 0x00ff, freq & 0xff, 274 radio->transfer_buffer, 8, 300); 275 276 if (retval < 0) { 277 request = DSB100_TUNE; 278 goto usb_control_msg_failed; 279 } 280 281 retval = usb_control_msg(radio->usbdev, 282 usb_rcvctrlpipe(radio->usbdev, 0), 283 USB_REQ_GET_STATUS, 284 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 285 0x96, 0xB7, radio->transfer_buffer, 8, 300); 286 287 if (retval < 0) { 288 request = USB_REQ_GET_STATUS; 289 goto usb_control_msg_failed; 290 } 291 292 retval = usb_control_msg(radio->usbdev, 293 usb_rcvctrlpipe(radio->usbdev, 0), 294 USB_REQ_GET_STATUS, 295 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 296 0x00, 0x24, radio->transfer_buffer, 8, 300); 297 298 if (retval < 0) { 299 request = USB_REQ_GET_STATUS; 300 goto usb_control_msg_failed; 301 } 302 303 radio->stereo = !((radio->transfer_buffer)[0] & 0x01); 304 mutex_unlock(&radio->lock); 305 return (radio->transfer_buffer)[0]; 306 307 usb_control_msg_failed: 308 radio->stereo = -1; 309 mutex_unlock(&radio->lock); 310 dev_err(&radio->usbdev->dev, 311 "%s - usb_control_msg returned %i, request %i\n", 312 __func__, retval, request); 313 return retval; 314 } 315 316 /* return the device status. This is, in effect, just whether it 317 sees a stereo signal or not. Pity. */ 318 static void dsbr100_getstat(struct dsbr100_device *radio) 319 { 320 int retval; 321 322 mutex_lock(&radio->lock); 323 324 retval = usb_control_msg(radio->usbdev, 325 usb_rcvctrlpipe(radio->usbdev, 0), 326 USB_REQ_GET_STATUS, 327 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 328 0x00 , 0x24, radio->transfer_buffer, 8, 300); 329 330 if (retval < 0) { 331 radio->stereo = -1; 332 dev_err(&radio->usbdev->dev, 333 "%s - usb_control_msg returned %i, request %i\n", 334 __func__, retval, USB_REQ_GET_STATUS); 335 } else { 336 radio->stereo = !(radio->transfer_buffer[0] & 0x01); 337 } 338 339 mutex_unlock(&radio->lock); 340 } 341 342 /* USB subsystem interface begins here */ 343 344 /* 345 * Handle unplugging of the device. 346 * We call video_unregister_device in any case. 347 * The last function called in this procedure is 348 * usb_dsbr100_video_device_release 349 */ 350 static void usb_dsbr100_disconnect(struct usb_interface *intf) 351 { 352 struct dsbr100_device *radio = usb_get_intfdata(intf); 353 354 usb_set_intfdata (intf, NULL); 355 356 mutex_lock(&radio->lock); 357 radio->removed = 1; 358 mutex_unlock(&radio->lock); 359 360 video_unregister_device(&radio->videodev); 361 v4l2_device_disconnect(&radio->v4l2_dev); 362 } 363 364 365 static int vidioc_querycap(struct file *file, void *priv, 366 struct v4l2_capability *v) 367 { 368 struct dsbr100_device *radio = video_drvdata(file); 369 370 strlcpy(v->driver, "dsbr100", sizeof(v->driver)); 371 strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card)); 372 usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info)); 373 v->version = RADIO_VERSION; 374 v->capabilities = V4L2_CAP_TUNER; 375 return 0; 376 } 377 378 static int vidioc_g_tuner(struct file *file, void *priv, 379 struct v4l2_tuner *v) 380 { 381 struct dsbr100_device *radio = video_drvdata(file); 382 383 /* safety check */ 384 if (radio->removed) 385 return -EIO; 386 387 if (v->index > 0) 388 return -EINVAL; 389 390 dsbr100_getstat(radio); 391 strcpy(v->name, "FM"); 392 v->type = V4L2_TUNER_RADIO; 393 v->rangelow = FREQ_MIN * FREQ_MUL; 394 v->rangehigh = FREQ_MAX * FREQ_MUL; 395 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 396 v->capability = V4L2_TUNER_CAP_LOW; 397 if(radio->stereo) 398 v->audmode = V4L2_TUNER_MODE_STEREO; 399 else 400 v->audmode = V4L2_TUNER_MODE_MONO; 401 v->signal = 0xffff; /* We can't get the signal strength */ 402 return 0; 403 } 404 405 static int vidioc_s_tuner(struct file *file, void *priv, 406 struct v4l2_tuner *v) 407 { 408 struct dsbr100_device *radio = video_drvdata(file); 409 410 /* safety check */ 411 if (radio->removed) 412 return -EIO; 413 414 if (v->index > 0) 415 return -EINVAL; 416 417 return 0; 418 } 419 420 static int vidioc_s_frequency(struct file *file, void *priv, 421 struct v4l2_frequency *f) 422 { 423 struct dsbr100_device *radio = video_drvdata(file); 424 int retval; 425 426 /* safety check */ 427 if (radio->removed) 428 return -EIO; 429 430 mutex_lock(&radio->lock); 431 radio->curfreq = f->frequency; 432 mutex_unlock(&radio->lock); 433 434 retval = dsbr100_setfreq(radio, radio->curfreq); 435 if (retval < 0) 436 dev_warn(&radio->usbdev->dev, "Set frequency failed\n"); 437 return 0; 438 } 439 440 static int vidioc_g_frequency(struct file *file, void *priv, 441 struct v4l2_frequency *f) 442 { 443 struct dsbr100_device *radio = video_drvdata(file); 444 445 /* safety check */ 446 if (radio->removed) 447 return -EIO; 448 449 f->type = V4L2_TUNER_RADIO; 450 f->frequency = radio->curfreq; 451 return 0; 452 } 453 454 static int vidioc_queryctrl(struct file *file, void *priv, 455 struct v4l2_queryctrl *qc) 456 { 457 switch (qc->id) { 458 case V4L2_CID_AUDIO_MUTE: 459 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1); 460 } 461 462 return -EINVAL; 463 } 464 465 static int vidioc_g_ctrl(struct file *file, void *priv, 466 struct v4l2_control *ctrl) 467 { 468 struct dsbr100_device *radio = video_drvdata(file); 469 470 /* safety check */ 471 if (radio->removed) 472 return -EIO; 473 474 switch (ctrl->id) { 475 case V4L2_CID_AUDIO_MUTE: 476 ctrl->value = radio->muted; 477 return 0; 478 } 479 return -EINVAL; 480 } 481 482 static int vidioc_s_ctrl(struct file *file, void *priv, 483 struct v4l2_control *ctrl) 484 { 485 struct dsbr100_device *radio = video_drvdata(file); 486 int retval; 487 488 /* safety check */ 489 if (radio->removed) 490 return -EIO; 491 492 switch (ctrl->id) { 493 case V4L2_CID_AUDIO_MUTE: 494 if (ctrl->value) { 495 retval = dsbr100_stop(radio); 496 if (retval < 0) { 497 dev_warn(&radio->usbdev->dev, 498 "Radio did not respond properly\n"); 499 return -EBUSY; 500 } 501 } else { 502 retval = dsbr100_start(radio); 503 if (retval < 0) { 504 dev_warn(&radio->usbdev->dev, 505 "Radio did not respond properly\n"); 506 return -EBUSY; 507 } 508 } 509 return 0; 510 } 511 return -EINVAL; 512 } 513 514 static int vidioc_g_audio(struct file *file, void *priv, 515 struct v4l2_audio *a) 516 { 517 if (a->index > 1) 518 return -EINVAL; 519 520 strcpy(a->name, "Radio"); 521 a->capability = V4L2_AUDCAP_STEREO; 522 return 0; 523 } 524 525 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i) 526 { 527 *i = 0; 528 return 0; 529 } 530 531 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i) 532 { 533 if (i != 0) 534 return -EINVAL; 535 return 0; 536 } 537 538 static int vidioc_s_audio(struct file *file, void *priv, 539 struct v4l2_audio *a) 540 { 541 if (a->index != 0) 542 return -EINVAL; 543 return 0; 544 } 545 546 static int usb_dsbr100_open(struct file *file) 547 { 548 struct dsbr100_device *radio = video_drvdata(file); 549 int retval; 550 551 lock_kernel(); 552 radio->users = 1; 553 radio->muted = 1; 554 555 retval = dsbr100_start(radio); 556 if (retval < 0) { 557 dev_warn(&radio->usbdev->dev, 558 "Radio did not start up properly\n"); 559 radio->users = 0; 560 unlock_kernel(); 561 return -EIO; 562 } 563 564 retval = dsbr100_setfreq(radio, radio->curfreq); 565 if (retval < 0) 566 dev_warn(&radio->usbdev->dev, 567 "set frequency failed\n"); 568 569 unlock_kernel(); 570 return 0; 571 } 572 573 static int usb_dsbr100_close(struct file *file) 574 { 575 struct dsbr100_device *radio = video_drvdata(file); 576 int retval; 577 578 if (!radio) 579 return -ENODEV; 580 581 mutex_lock(&radio->lock); 582 radio->users = 0; 583 mutex_unlock(&radio->lock); 584 585 if (!radio->removed) { 586 retval = dsbr100_stop(radio); 587 if (retval < 0) { 588 dev_warn(&radio->usbdev->dev, 589 "dsbr100_stop failed\n"); 590 } 591 592 } 593 return 0; 594 } 595 596 /* Suspend device - stop device. */ 597 static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message) 598 { 599 struct dsbr100_device *radio = usb_get_intfdata(intf); 600 int retval; 601 602 retval = dsbr100_stop(radio); 603 if (retval < 0) 604 dev_warn(&intf->dev, "dsbr100_stop failed\n"); 605 606 dev_info(&intf->dev, "going into suspend..\n"); 607 608 return 0; 609 } 610 611 /* Resume device - start device. */ 612 static int usb_dsbr100_resume(struct usb_interface *intf) 613 { 614 struct dsbr100_device *radio = usb_get_intfdata(intf); 615 int retval; 616 617 retval = dsbr100_start(radio); 618 if (retval < 0) 619 dev_warn(&intf->dev, "dsbr100_start failed\n"); 620 621 dev_info(&intf->dev, "coming out of suspend..\n"); 622 623 return 0; 624 } 625 626 /* free data structures */ 627 static void usb_dsbr100_video_device_release(struct video_device *videodev) 628 { 629 struct dsbr100_device *radio = videodev_to_radio(videodev); 630 631 v4l2_device_unregister(&radio->v4l2_dev); 632 kfree(radio->transfer_buffer); 633 kfree(radio); 634 } 635 636 /* File system interface */ 637 static const struct v4l2_file_operations usb_dsbr100_fops = { 638 .owner = THIS_MODULE, 639 .open = usb_dsbr100_open, 640 .release = usb_dsbr100_close, 641 .ioctl = video_ioctl2, 642 }; 643 644 static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = { 645 .vidioc_querycap = vidioc_querycap, 646 .vidioc_g_tuner = vidioc_g_tuner, 647 .vidioc_s_tuner = vidioc_s_tuner, 648 .vidioc_g_frequency = vidioc_g_frequency, 649 .vidioc_s_frequency = vidioc_s_frequency, 650 .vidioc_queryctrl = vidioc_queryctrl, 651 .vidioc_g_ctrl = vidioc_g_ctrl, 652 .vidioc_s_ctrl = vidioc_s_ctrl, 653 .vidioc_g_audio = vidioc_g_audio, 654 .vidioc_s_audio = vidioc_s_audio, 655 .vidioc_g_input = vidioc_g_input, 656 .vidioc_s_input = vidioc_s_input, 657 }; 658 659 /* check if the device is present and register with v4l and usb if it is */ 660 static int usb_dsbr100_probe(struct usb_interface *intf, 661 const struct usb_device_id *id) 662 { 663 struct dsbr100_device *radio; 664 struct v4l2_device *v4l2_dev; 665 int retval; 666 667 radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL); 668 669 if (!radio) 670 return -ENOMEM; 671 672 radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL); 673 674 if (!(radio->transfer_buffer)) { 675 kfree(radio); 676 return -ENOMEM; 677 } 678 679 v4l2_dev = &radio->v4l2_dev; 680 681 retval = v4l2_device_register(&intf->dev, v4l2_dev); 682 if (retval < 0) { 683 v4l2_err(v4l2_dev, "couldn't register v4l2_device\n"); 684 kfree(radio->transfer_buffer); 685 kfree(radio); 686 return retval; 687 } 688 689 strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name)); 690 radio->videodev.v4l2_dev = v4l2_dev; 691 radio->videodev.fops = &usb_dsbr100_fops; 692 radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops; 693 radio->videodev.release = usb_dsbr100_video_device_release; 694 695 mutex_init(&radio->lock); 696 697 radio->removed = 0; 698 radio->users = 0; 699 radio->usbdev = interface_to_usbdev(intf); 700 radio->curfreq = FREQ_MIN * FREQ_MUL; 701 702 video_set_drvdata(&radio->videodev, radio); 703 704 retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr); 705 if (retval < 0) { 706 v4l2_err(v4l2_dev, "couldn't register video device\n"); 707 v4l2_device_unregister(v4l2_dev); 708 kfree(radio->transfer_buffer); 709 kfree(radio); 710 return -EIO; 711 } 712 usb_set_intfdata(intf, radio); 713 return 0; 714 } 715 716 static int __init dsbr100_init(void) 717 { 718 int retval = usb_register(&usb_dsbr100_driver); 719 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 720 DRIVER_DESC "\n"); 721 return retval; 722 } 723 724 static void __exit dsbr100_exit(void) 725 { 726 usb_deregister(&usb_dsbr100_driver); 727 } 728 729 module_init (dsbr100_init); 730 module_exit (dsbr100_exit); 731 732 MODULE_AUTHOR( DRIVER_AUTHOR ); 733 MODULE_DESCRIPTION( DRIVER_DESC ); 734 MODULE_LICENSE("GPL"); 735