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