drivers/media/radio/dsbr100.c

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