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.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 file *file);
 158 static int usb_dsbr100_close(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 retval;
 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 retval;
 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 retval;
 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         struct dsbr100_device *radio = video_drvdata(file);
 394
 395         strlcpy(v->driver, "dsbr100", sizeof(v->driver));
 396         strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
 397         usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
 398         v->version = RADIO_VERSION;
 399         v->capabilities = V4L2_CAP_TUNER;
 400         return 0;
 401 }
 402
 403 static int vidioc_g_tuner(struct file *file, void *priv,
 404                                 struct v4l2_tuner *v)
 405 {
 406         struct dsbr100_device *radio = video_drvdata(file);
 407
 408         /* safety check */
 409         if (radio->removed)
 410                 return -EIO;
 411
 412         if (v->index > 0)
 413                 return -EINVAL;
 414
 415         dsbr100_getstat(radio);
 416         strcpy(v->name, "FM");
 417         v->type = V4L2_TUNER_RADIO;
 418         v->rangelow = FREQ_MIN * FREQ_MUL;
 419         v->rangehigh = FREQ_MAX * FREQ_MUL;
 420         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 421         v->capability = V4L2_TUNER_CAP_LOW;
 422         if(radio->stereo)
 423                 v->audmode = V4L2_TUNER_MODE_STEREO;
 424         else
 425                 v->audmode = V4L2_TUNER_MODE_MONO;
 426         v->signal = 0xffff;     /* We can't get the signal strength */
 427         return 0;
 428 }
 429
 430 static int vidioc_s_tuner(struct file *file, void *priv,
 431                                 struct v4l2_tuner *v)
 432 {
 433         struct dsbr100_device *radio = video_drvdata(file);
 434
 435         /* safety check */
 436         if (radio->removed)
 437                 return -EIO;
 438
 439         if (v->index > 0)
 440                 return -EINVAL;
 441
 442         return 0;
 443 }
 444
 445 static int vidioc_s_frequency(struct file *file, void *priv,
 446                                 struct v4l2_frequency *f)
 447 {
 448         struct dsbr100_device *radio = video_drvdata(file);
 449         int retval;
 450
 451         /* safety check */
 452         if (radio->removed)
 453                 return -EIO;
 454
 455         mutex_lock(&radio->lock);
 456         radio->curfreq = f->frequency;
 457         mutex_unlock(&radio->lock);
 458
 459         retval = dsbr100_setfreq(radio, radio->curfreq);
 460         if (retval < 0)
 461                 dev_warn(&radio->usbdev->dev, "Set frequency failed\n");
 462         return 0;
 463 }
 464
 465 static int vidioc_g_frequency(struct file *file, void *priv,
 466                                 struct v4l2_frequency *f)
 467 {
 468         struct dsbr100_device *radio = video_drvdata(file);
 469
 470         /* safety check */
 471         if (radio->removed)
 472                 return -EIO;
 473
 474         f->type = V4L2_TUNER_RADIO;
 475         f->frequency = radio->curfreq;
 476         return 0;
 477 }
 478
 479 static int vidioc_queryctrl(struct file *file, void *priv,
 480                                 struct v4l2_queryctrl *qc)
 481 {
 482         int i;
 483
 484         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
 485                 if (qc->id && qc->id == radio_qctrl[i].id) {
 486                         memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));
 487                         return 0;
 488                 }
 489         }
 490         return -EINVAL;
 491 }
 492
 493 static int vidioc_g_ctrl(struct file *file, void *priv,
 494                                 struct v4l2_control *ctrl)
 495 {
 496         struct dsbr100_device *radio = video_drvdata(file);
 497
 498         /* safety check */
 499         if (radio->removed)
 500                 return -EIO;
 501
 502         switch (ctrl->id) {
 503         case V4L2_CID_AUDIO_MUTE:
 504                 ctrl->value = radio->muted;
 505                 return 0;
 506         }
 507         return -EINVAL;
 508 }
 509
 510 static int vidioc_s_ctrl(struct file *file, void *priv,
 511                                 struct v4l2_control *ctrl)
 512 {
 513         struct dsbr100_device *radio = video_drvdata(file);
 514         int retval;
 515
 516         /* safety check */
 517         if (radio->removed)
 518                 return -EIO;
 519
 520         switch (ctrl->id) {
 521         case V4L2_CID_AUDIO_MUTE:
 522                 if (ctrl->value) {
 523                         retval = dsbr100_stop(radio);
 524                         if (retval < 0) {
 525                                 dev_warn(&radio->usbdev->dev,
 526                                          "Radio did not respond properly\n");
 527                                 return -EBUSY;
 528                         }
 529                 } else {
 530                         retval = dsbr100_start(radio);
 531                         if (retval < 0) {
 532                                 dev_warn(&radio->usbdev->dev,
 533                                          "Radio did not respond properly\n");
 534                                 return -EBUSY;
 535                         }
 536                 }
 537                 return 0;
 538         }
 539         return -EINVAL;
 540 }
 541
 542 static int vidioc_g_audio(struct file *file, void *priv,
 543                                 struct v4l2_audio *a)
 544 {
 545         if (a->index > 1)
 546                 return -EINVAL;
 547
 548         strcpy(a->name, "Radio");
 549         a->capability = V4L2_AUDCAP_STEREO;
 550         return 0;
 551 }
 552
 553 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 554 {
 555         *i = 0;
 556         return 0;
 557 }
 558
 559 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 560 {
 561         if (i != 0)
 562                 return -EINVAL;
 563         return 0;
 564 }
 565
 566 static int vidioc_s_audio(struct file *file, void *priv,
 567                                         struct v4l2_audio *a)
 568 {
 569         if (a->index != 0)
 570                 return -EINVAL;
 571         return 0;
 572 }
 573
 574 static int usb_dsbr100_open(struct file *file)
 575 {
 576         struct dsbr100_device *radio = video_drvdata(file);
 577         int retval;
 578
 579         lock_kernel();
 580         radio->users = 1;
 581         radio->muted = 1;
 582
 583         retval = dsbr100_start(radio);
 584         if (retval < 0) {
 585                 dev_warn(&radio->usbdev->dev,
 586                          "Radio did not start up properly\n");
 587                 radio->users = 0;
 588                 unlock_kernel();
 589                 return -EIO;
 590         }
 591
 592         retval = dsbr100_setfreq(radio, radio->curfreq);
 593         if (retval < 0)
 594                 dev_warn(&radio->usbdev->dev,
 595                         "set frequency failed\n");
 596
 597         unlock_kernel();
 598         return 0;
 599 }
 600
 601 static int usb_dsbr100_close(struct file *file)
 602 {
 603         struct dsbr100_device *radio = video_drvdata(file);
 604         int retval;
 605
 606         if (!radio)
 607                 return -ENODEV;
 608
 609         mutex_lock(&radio->lock);
 610         radio->users = 0;
 611         mutex_unlock(&radio->lock);
 612
 613         if (!radio->removed) {
 614                 retval = dsbr100_stop(radio);
 615                 if (retval < 0) {
 616                         dev_warn(&radio->usbdev->dev,
 617                                 "dsbr100_stop failed\n");
 618                 }
 619
 620         }
 621         return 0;
 622 }
 623
 624 /* Suspend device - stop device. */
 625 static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message)
 626 {
 627         struct dsbr100_device *radio = usb_get_intfdata(intf);
 628         int retval;
 629
 630         retval = dsbr100_stop(radio);
 631         if (retval < 0)
 632                 dev_warn(&intf->dev, "dsbr100_stop failed\n");
 633
 634         dev_info(&intf->dev, "going into suspend..\n");
 635
 636         return 0;
 637 }
 638
 639 /* Resume device - start device. */
 640 static int usb_dsbr100_resume(struct usb_interface *intf)
 641 {
 642         struct dsbr100_device *radio = usb_get_intfdata(intf);
 643         int retval;
 644
 645         retval = dsbr100_start(radio);
 646         if (retval < 0)
 647                 dev_warn(&intf->dev, "dsbr100_start failed\n");
 648
 649         dev_info(&intf->dev, "coming out of suspend..\n");
 650
 651         return 0;
 652 }
 653
 654 /* free data structures */
 655 static void usb_dsbr100_video_device_release(struct video_device *videodev)
 656 {
 657         struct dsbr100_device *radio = videodev_to_radio(videodev);
 658
 659         kfree(radio->transfer_buffer);
 660         kfree(radio);
 661 }
 662
 663 /* File system interface */
 664 static const struct v4l2_file_operations usb_dsbr100_fops = {
 665         .owner          = THIS_MODULE,
 666         .open           = usb_dsbr100_open,
 667         .release        = usb_dsbr100_close,
 668         .ioctl          = video_ioctl2,
 669 };
 670
 671 static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
 672         .vidioc_querycap    = vidioc_querycap,
 673         .vidioc_g_tuner     = vidioc_g_tuner,
 674         .vidioc_s_tuner     = vidioc_s_tuner,
 675         .vidioc_g_frequency = vidioc_g_frequency,
 676         .vidioc_s_frequency = vidioc_s_frequency,
 677         .vidioc_queryctrl   = vidioc_queryctrl,
 678         .vidioc_g_ctrl      = vidioc_g_ctrl,
 679         .vidioc_s_ctrl      = vidioc_s_ctrl,
 680         .vidioc_g_audio     = vidioc_g_audio,
 681         .vidioc_s_audio     = vidioc_s_audio,
 682         .vidioc_g_input     = vidioc_g_input,
 683         .vidioc_s_input     = vidioc_s_input,
 684 };
 685
 686 /* V4L2 interface */
 687 static struct video_device dsbr100_videodev_data = {
 688         .name           = "D-Link DSB-R 100",
 689         .fops           = &usb_dsbr100_fops,
 690         .ioctl_ops      = &usb_dsbr100_ioctl_ops,
 691         .release        = usb_dsbr100_video_device_release,
 692 };
 693
 694 /* check if the device is present and register with v4l and usb if it is */
 695 static int usb_dsbr100_probe(struct usb_interface *intf,
 696                                 const struct usb_device_id *id)
 697 {
 698         struct dsbr100_device *radio;
 699         int retval;
 700
 701         radio = kmalloc(sizeof(struct dsbr100_device), GFP_KERNEL);
 702
 703         if (!radio)
 704                 return -ENOMEM;
 705
 706         radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);
 707
 708         if (!(radio->transfer_buffer)) {
 709                 kfree(radio);
 710                 return -ENOMEM;
 711         }
 712
 713         mutex_init(&radio->lock);
 714         radio->videodev = dsbr100_videodev_data;
 715
 716         radio->removed = 0;
 717         radio->users = 0;
 718         radio->usbdev = interface_to_usbdev(intf);
 719         radio->curfreq = FREQ_MIN * FREQ_MUL;
 720         video_set_drvdata(&radio->videodev, radio);
 721         retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
 722         if (retval < 0) {
 723                 dev_err(&intf->dev, "couldn't register video device\n");
 724                 kfree(radio->transfer_buffer);
 725                 kfree(radio);
 726                 return -EIO;
 727         }
 728         usb_set_intfdata(intf, radio);
 729         return 0;
 730 }
 731
 732 static int __init dsbr100_init(void)
 733 {
 734         int retval = usb_register(&usb_dsbr100_driver);
 735         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 736                DRIVER_DESC "\n");
 737         return retval;
 738 }
 739
 740 static void __exit dsbr100_exit(void)
 741 {
 742         usb_deregister(&usb_dsbr100_driver);
 743 }
 744
 745 module_init (dsbr100_init);
 746 module_exit (dsbr100_exit);
 747
 748 MODULE_AUTHOR( DRIVER_AUTHOR );
 749 MODULE_DESCRIPTION( DRIVER_DESC );
 750 MODULE_LICENSE("GPL");