git.oblomov.eu Git - linux-2.6/blob - drivers/media/radio/radio-mr800.c

   1 /*
   2  * A driver for the AverMedia MR 800 USB FM radio. This device plugs
   3  * into both the USB and an analog audio input, so this thing
   4  * only deals with initialization and frequency setting, the
   5  * audio data has to be handled by a sound driver.
   6  *
   7  * Copyright (c) 2008 Alexey Klimov <klimov.linux@gmail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 /*
  25  * Big thanks to authors and contributors of dsbr100.c and radio-si470x.c
  26  *
  27  * When work was looked pretty good, i discover this:
  28  * http://av-usbradio.sourceforge.net/index.php
  29  * http://sourceforge.net/projects/av-usbradio/
  30  * Latest release of theirs project was in 2005.
  31  * Probably, this driver could be improved trough using their
  32  * achievements (specifications given).
  33  * Also, Faidon Liambotis <paravoid@debian.org> wrote nice driver for this radio
  34  * in 2007. He allowed to use his driver to improve current mr800 radio driver.
  35  * http://kerneltrap.org/mailarchive/linux-usb-devel/2007/10/11/342492
  36  *
  37  * Version 0.01:        First working version.
  38  *                      It's required to blacklist AverMedia USB Radio
  39  *                      in usbhid/hid-quirks.c
  40  * Version 0.10:        A lot of cleanups and fixes: unpluging the device,
  41  *                      few mutex locks were added, codinstyle issues, etc.
  42  *                      Added stereo support. Thanks to
  43  *                      Douglas Schilling Landgraf <dougsland@gmail.com> and
  44  *                      David Ellingsworth <david@identd.dyndns.org>
  45  *                      for discussion, help and support.
  46  *
  47  * Many things to do:
  48  *      - Correct power managment of device (suspend & resume)
  49  *      - Add code for scanning and smooth tuning
  50  *      - Add code for sensitivity value
  51  *      - Correct mistakes
  52  *      - In Japan another FREQ_MIN and FREQ_MAX
  53  */
  54
  55 /* kernel includes */
  56 #include <linux/kernel.h>
  57 #include <linux/module.h>
  58 #include <linux/init.h>
  59 #include <linux/slab.h>
  60 #include <linux/input.h>
  61 #include <linux/videodev2.h>
  62 #include <media/v4l2-common.h>
  63 #include <media/v4l2-ioctl.h>
  64 #include <linux/usb.h>
  65 #include <linux/version.h>      /* for KERNEL_VERSION MACRO */
  66
  67 /* driver and module definitions */
  68 #define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@gmail.com>"
  69 #define DRIVER_DESC "AverMedia MR 800 USB FM radio driver"
  70 #define DRIVER_VERSION "0.10"
  71 #define RADIO_VERSION KERNEL_VERSION(0, 1, 0)
  72
  73 MODULE_AUTHOR(DRIVER_AUTHOR);
  74 MODULE_DESCRIPTION(DRIVER_DESC);
  75 MODULE_LICENSE("GPL");
  76
  77 #define USB_AMRADIO_VENDOR 0x07ca
  78 #define USB_AMRADIO_PRODUCT 0xb800
  79
  80 /* dev_warn macro with driver name */
  81 #define MR800_DRIVER_NAME "radio-mr800"
  82 #define amradio_dev_warn(dev, fmt, arg...)                              \
  83                 dev_warn(dev, MR800_DRIVER_NAME " - " fmt, ##arg)
  84
  85 /* Probably USB_TIMEOUT should be modified in module parameter */
  86 #define BUFFER_LENGTH 8
  87 #define USB_TIMEOUT 500
  88
  89 /* Frequency limits in MHz -- these are European values.  For Japanese
  90 devices, that would be 76 and 91.  */
  91 #define FREQ_MIN  87.5
  92 #define FREQ_MAX 108.0
  93 #define FREQ_MUL 16000
  94
  95 /*
  96  * Commands that device should understand
  97  * List isnt full and will be updated with implementation of new functions
  98  */
  99 #define AMRADIO_SET_FREQ        0xa4
 100 #define AMRADIO_SET_MUTE        0xab
 101 #define AMRADIO_SET_MONO        0xae
 102
 103 /* Comfortable defines for amradio_set_mute */
 104 #define AMRADIO_START           0x00
 105 #define AMRADIO_STOP            0x01
 106
 107 /* Comfortable defines for amradio_set_stereo */
 108 #define WANT_STEREO             0x00
 109 #define WANT_MONO               0x01
 110
 111 /* module parameter */
 112 static int radio_nr = -1;
 113 module_param(radio_nr, int, 0);
 114 MODULE_PARM_DESC(radio_nr, "Radio Nr");
 115
 116 static struct v4l2_queryctrl radio_qctrl[] = {
 117         {
 118                 .id            = V4L2_CID_AUDIO_MUTE,
 119                 .name          = "Mute",
 120                 .minimum       = 0,
 121                 .maximum       = 1,
 122                 .step          = 1,
 123                 .default_value = 1,
 124                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
 125         },
 126 /* HINT: the disabled controls are only here to satify kradio and such apps */
 127         {       .id             = V4L2_CID_AUDIO_VOLUME,
 128                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 129         },
 130         {
 131                 .id             = V4L2_CID_AUDIO_BALANCE,
 132                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 133         },
 134         {
 135                 .id             = V4L2_CID_AUDIO_BASS,
 136                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 137         },
 138         {
 139                 .id             = V4L2_CID_AUDIO_TREBLE,
 140                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 141         },
 142         {
 143                 .id             = V4L2_CID_AUDIO_LOUDNESS,
 144                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 145         },
 146 };
 147
 148 static int usb_amradio_probe(struct usb_interface *intf,
 149                              const struct usb_device_id *id);
 150 static void usb_amradio_disconnect(struct usb_interface *intf);
 151 static int usb_amradio_open(struct file *file);
 152 static int usb_amradio_close(struct file *file);
 153 static int usb_amradio_suspend(struct usb_interface *intf,
 154                                 pm_message_t message);
 155 static int usb_amradio_resume(struct usb_interface *intf);
 156
 157 /* Data for one (physical) device */
 158 struct amradio_device {
 159         /* reference to USB and video device */
 160         struct usb_device *usbdev;
 161         struct video_device *videodev;
 162
 163         unsigned char *buffer;
 164         struct mutex lock;      /* buffer locking */
 165         int curfreq;
 166         int stereo;
 167         int users;
 168         int removed;
 169         int muted;
 170 };
 171
 172 /* USB Device ID List */
 173 static struct usb_device_id usb_amradio_device_table[] = {
 174         {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR, USB_AMRADIO_PRODUCT,
 175                                                         USB_CLASS_HID, 0, 0) },
 176         { }                                             /* Terminating entry */
 177 };
 178
 179 MODULE_DEVICE_TABLE(usb, usb_amradio_device_table);
 180
 181 /* USB subsystem interface */
 182 static struct usb_driver usb_amradio_driver = {
 183         .name                   = MR800_DRIVER_NAME,
 184         .probe                  = usb_amradio_probe,
 185         .disconnect             = usb_amradio_disconnect,
 186         .suspend                = usb_amradio_suspend,
 187         .resume                 = usb_amradio_resume,
 188         .reset_resume           = usb_amradio_resume,
 189         .id_table               = usb_amradio_device_table,
 190         .supports_autosuspend   = 0,
 191 };
 192
 193 /* switch on/off the radio. Send 8 bytes to device */
 194 static int amradio_set_mute(struct amradio_device *radio, char argument)
 195 {
 196         int retval;
 197         int size;
 198
 199         /* safety check */
 200         if (radio->removed)
 201                 return -EIO;
 202
 203         mutex_lock(&radio->lock);
 204
 205         radio->buffer[0] = 0x00;
 206         radio->buffer[1] = 0x55;
 207         radio->buffer[2] = 0xaa;
 208         radio->buffer[3] = 0x00;
 209         radio->buffer[4] = AMRADIO_SET_MUTE;
 210         radio->buffer[5] = argument;
 211         radio->buffer[6] = 0x00;
 212         radio->buffer[7] = 0x00;
 213
 214         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 215                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 216
 217         if (retval < 0 || size != BUFFER_LENGTH) {
 218                 mutex_unlock(&radio->lock);
 219                 return retval;
 220         }
 221
 222         radio->muted = argument;
 223
 224         mutex_unlock(&radio->lock);
 225
 226         return retval;
 227 }
 228
 229 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
 230 static int amradio_setfreq(struct amradio_device *radio, int freq)
 231 {
 232         int retval;
 233         int size;
 234         unsigned short freq_send = 0x10 + (freq >> 3) / 25;
 235
 236         /* safety check */
 237         if (radio->removed)
 238                 return -EIO;
 239
 240         mutex_lock(&radio->lock);
 241
 242         radio->buffer[0] = 0x00;
 243         radio->buffer[1] = 0x55;
 244         radio->buffer[2] = 0xaa;
 245         radio->buffer[3] = 0x03;
 246         radio->buffer[4] = AMRADIO_SET_FREQ;
 247         radio->buffer[5] = 0x00;
 248         radio->buffer[6] = 0x00;
 249         radio->buffer[7] = 0x08;
 250
 251         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 252                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 253
 254         if (retval < 0 || size != BUFFER_LENGTH) {
 255                 mutex_unlock(&radio->lock);
 256                 return retval;
 257         }
 258
 259         /* frequency is calculated from freq_send and placed in first 2 bytes */
 260         radio->buffer[0] = (freq_send >> 8) & 0xff;
 261         radio->buffer[1] = freq_send & 0xff;
 262         radio->buffer[2] = 0x01;
 263         radio->buffer[3] = 0x00;
 264         radio->buffer[4] = 0x00;
 265         /* 5 and 6 bytes of buffer already = 0x00 */
 266         radio->buffer[7] = 0x00;
 267
 268         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 269                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 270
 271         if (retval < 0 || size != BUFFER_LENGTH) {
 272                 mutex_unlock(&radio->lock);
 273                 return retval;
 274         }
 275
 276         mutex_unlock(&radio->lock);
 277
 278         return retval;
 279 }
 280
 281 static int amradio_set_stereo(struct amradio_device *radio, char argument)
 282 {
 283         int retval;
 284         int size;
 285
 286         /* safety check */
 287         if (radio->removed)
 288                 return -EIO;
 289
 290         mutex_lock(&radio->lock);
 291
 292         radio->buffer[0] = 0x00;
 293         radio->buffer[1] = 0x55;
 294         radio->buffer[2] = 0xaa;
 295         radio->buffer[3] = 0x00;
 296         radio->buffer[4] = AMRADIO_SET_MONO;
 297         radio->buffer[5] = argument;
 298         radio->buffer[6] = 0x00;
 299         radio->buffer[7] = 0x00;
 300
 301         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 302                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 303
 304         if (retval < 0 || size != BUFFER_LENGTH) {
 305                 radio->stereo = -1;
 306                 mutex_unlock(&radio->lock);
 307                 return retval;
 308         }
 309
 310         radio->stereo = 1;
 311
 312         mutex_unlock(&radio->lock);
 313
 314         return retval;
 315 }
 316
 317 /* Handle unplugging the device.
 318  * We call video_unregister_device in any case.
 319  * The last function called in this procedure is
 320  * usb_amradio_device_release.
 321  */
 322 static void usb_amradio_disconnect(struct usb_interface *intf)
 323 {
 324         struct amradio_device *radio = usb_get_intfdata(intf);
 325
 326         mutex_lock(&radio->lock);
 327         radio->removed = 1;
 328         mutex_unlock(&radio->lock);
 329
 330         usb_set_intfdata(intf, NULL);
 331         video_unregister_device(radio->videodev);
 332 }
 333
 334 /* vidioc_querycap - query device capabilities */
 335 static int vidioc_querycap(struct file *file, void *priv,
 336                                         struct v4l2_capability *v)
 337 {
 338         struct amradio_device *radio = video_drvdata(file);
 339
 340         strlcpy(v->driver, "radio-mr800", sizeof(v->driver));
 341         strlcpy(v->card, "AverMedia MR 800 USB FM Radio", sizeof(v->card));
 342         usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
 343         v->version = RADIO_VERSION;
 344         v->capabilities = V4L2_CAP_TUNER;
 345         return 0;
 346 }
 347
 348 /* vidioc_g_tuner - get tuner attributes */
 349 static int vidioc_g_tuner(struct file *file, void *priv,
 350                                 struct v4l2_tuner *v)
 351 {
 352         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 353         int retval;
 354
 355         /* safety check */
 356         if (radio->removed)
 357                 return -EIO;
 358
 359         if (v->index > 0)
 360                 return -EINVAL;
 361
 362 /* TODO: Add function which look is signal stereo or not
 363  *      amradio_getstat(radio);
 364  */
 365
 366 /* we call amradio_set_stereo to set radio->stereo
 367  * Honestly, amradio_getstat should cover this in future and
 368  * amradio_set_stereo shouldn't be here
 369  */
 370         retval = amradio_set_stereo(radio, WANT_STEREO);
 371         if (retval < 0)
 372                 amradio_dev_warn(&radio->videodev->dev,
 373                         "set stereo failed\n");
 374
 375         strcpy(v->name, "FM");
 376         v->type = V4L2_TUNER_RADIO;
 377         v->rangelow = FREQ_MIN * FREQ_MUL;
 378         v->rangehigh = FREQ_MAX * FREQ_MUL;
 379         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 380         v->capability = V4L2_TUNER_CAP_LOW;
 381         if (radio->stereo)
 382                 v->audmode = V4L2_TUNER_MODE_STEREO;
 383         else
 384                 v->audmode = V4L2_TUNER_MODE_MONO;
 385         v->signal = 0xffff;     /* Can't get the signal strength, sad.. */
 386         v->afc = 0; /* Don't know what is this */
 387         return 0;
 388 }
 389
 390 /* vidioc_s_tuner - set tuner attributes */
 391 static int vidioc_s_tuner(struct file *file, void *priv,
 392                                 struct v4l2_tuner *v)
 393 {
 394         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 395         int retval;
 396
 397         /* safety check */
 398         if (radio->removed)
 399                 return -EIO;
 400
 401         if (v->index > 0)
 402                 return -EINVAL;
 403
 404         /* mono/stereo selector */
 405         switch (v->audmode) {
 406         case V4L2_TUNER_MODE_MONO:
 407                 retval = amradio_set_stereo(radio, WANT_MONO);
 408                 if (retval < 0)
 409                         amradio_dev_warn(&radio->videodev->dev,
 410                                 "set mono failed\n");
 411                 break;
 412         case V4L2_TUNER_MODE_STEREO:
 413                 retval = amradio_set_stereo(radio, WANT_STEREO);
 414                 if (retval < 0)
 415                         amradio_dev_warn(&radio->videodev->dev,
 416                                 "set stereo failed\n");
 417                 break;
 418         default:
 419                 return -EINVAL;
 420         }
 421
 422         return 0;
 423 }
 424
 425 /* vidioc_s_frequency - set tuner radio frequency */
 426 static int vidioc_s_frequency(struct file *file, void *priv,
 427                                 struct v4l2_frequency *f)
 428 {
 429         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 430         int retval;
 431
 432         /* safety check */
 433         if (radio->removed)
 434                 return -EIO;
 435
 436         mutex_lock(&radio->lock);
 437         radio->curfreq = f->frequency;
 438         mutex_unlock(&radio->lock);
 439
 440         retval = amradio_setfreq(radio, radio->curfreq);
 441         if (retval < 0)
 442                 amradio_dev_warn(&radio->videodev->dev,
 443                         "set frequency failed\n");
 444         return 0;
 445 }
 446
 447 /* vidioc_g_frequency - get tuner radio frequency */
 448 static int vidioc_g_frequency(struct file *file, void *priv,
 449                                 struct v4l2_frequency *f)
 450 {
 451         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 452
 453         /* safety check */
 454         if (radio->removed)
 455                 return -EIO;
 456
 457         f->type = V4L2_TUNER_RADIO;
 458         f->frequency = radio->curfreq;
 459         return 0;
 460 }
 461
 462 /* vidioc_queryctrl - enumerate control items */
 463 static int vidioc_queryctrl(struct file *file, void *priv,
 464                                 struct v4l2_queryctrl *qc)
 465 {
 466         int i;
 467
 468         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
 469                 if (qc->id && qc->id == radio_qctrl[i].id) {
 470                         memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));
 471                         return 0;
 472                 }
 473         }
 474         return -EINVAL;
 475 }
 476
 477 /* vidioc_g_ctrl - get the value of a control */
 478 static int vidioc_g_ctrl(struct file *file, void *priv,
 479                                 struct v4l2_control *ctrl)
 480 {
 481         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 482
 483         /* safety check */
 484         if (radio->removed)
 485                 return -EIO;
 486
 487         switch (ctrl->id) {
 488         case V4L2_CID_AUDIO_MUTE:
 489                 ctrl->value = radio->muted;
 490                 return 0;
 491         }
 492         return -EINVAL;
 493 }
 494
 495 /* vidioc_s_ctrl - set the value of a control */
 496 static int vidioc_s_ctrl(struct file *file, void *priv,
 497                                 struct v4l2_control *ctrl)
 498 {
 499         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 500         int retval;
 501
 502         /* safety check */
 503         if (radio->removed)
 504                 return -EIO;
 505
 506         switch (ctrl->id) {
 507         case V4L2_CID_AUDIO_MUTE:
 508                 if (ctrl->value) {
 509                         retval = amradio_set_mute(radio, AMRADIO_STOP);
 510                         if (retval < 0) {
 511                                 amradio_dev_warn(&radio->videodev->dev,
 512                                         "amradio_stop failed\n");
 513                                 return -1;
 514                         }
 515                 } else {
 516                         retval = amradio_set_mute(radio, AMRADIO_START);
 517                         if (retval < 0) {
 518                                 amradio_dev_warn(&radio->videodev->dev,
 519                                         "amradio_start failed\n");
 520                                 return -1;
 521                         }
 522                 }
 523                 return 0;
 524         }
 525         return -EINVAL;
 526 }
 527
 528 /* vidioc_g_audio - get audio attributes */
 529 static int vidioc_g_audio(struct file *file, void *priv,
 530                                 struct v4l2_audio *a)
 531 {
 532         if (a->index > 1)
 533                 return -EINVAL;
 534
 535         strcpy(a->name, "Radio");
 536         a->capability = V4L2_AUDCAP_STEREO;
 537         return 0;
 538 }
 539
 540 /* vidioc_s_audio - set audio attributes  */
 541 static int vidioc_s_audio(struct file *file, void *priv,
 542                                         struct v4l2_audio *a)
 543 {
 544         if (a->index != 0)
 545                 return -EINVAL;
 546         return 0;
 547 }
 548
 549 /* vidioc_g_input - get input */
 550 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 551 {
 552         *i = 0;
 553         return 0;
 554 }
 555
 556 /* vidioc_s_input - set input */
 557 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 558 {
 559         if (i != 0)
 560                 return -EINVAL;
 561         return 0;
 562 }
 563
 564 /* open device - amradio_start() and amradio_setfreq() */
 565 static int usb_amradio_open(struct file *file)
 566 {
 567         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 568         int retval;
 569
 570         lock_kernel();
 571
 572         radio->users = 1;
 573         radio->muted = 1;
 574
 575         retval = amradio_set_mute(radio, AMRADIO_START);
 576         if (retval < 0) {
 577                 amradio_dev_warn(&radio->videodev->dev,
 578                         "radio did not start up properly\n");
 579                 radio->users = 0;
 580                 unlock_kernel();
 581                 return -EIO;
 582         }
 583
 584         retval = amradio_set_stereo(radio, WANT_STEREO);
 585         if (retval < 0)
 586                 amradio_dev_warn(&radio->videodev->dev,
 587                         "set stereo failed\n");
 588
 589         retval = amradio_setfreq(radio, radio->curfreq);
 590         if (retval < 0)
 591                 amradio_dev_warn(&radio->videodev->dev,
 592                         "set frequency failed\n");
 593
 594         unlock_kernel();
 595         return 0;
 596 }
 597
 598 /*close device */
 599 static int usb_amradio_close(struct file *file)
 600 {
 601         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 602         int retval;
 603
 604         if (!radio)
 605                 return -ENODEV;
 606
 607         mutex_lock(&radio->lock);
 608         radio->users = 0;
 609         mutex_unlock(&radio->lock);
 610
 611         if (!radio->removed) {
 612                 retval = amradio_set_mute(radio, AMRADIO_STOP);
 613                 if (retval < 0)
 614                         amradio_dev_warn(&radio->videodev->dev,
 615                                 "amradio_stop failed\n");
 616         }
 617
 618         return 0;
 619 }
 620
 621 /* Suspend device - stop device. Need to be checked and fixed */
 622 static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message)
 623 {
 624         struct amradio_device *radio = usb_get_intfdata(intf);
 625         int retval;
 626
 627         retval = amradio_set_mute(radio, AMRADIO_STOP);
 628         if (retval < 0)
 629                 dev_warn(&intf->dev, "amradio_stop failed\n");
 630
 631         dev_info(&intf->dev, "going into suspend..\n");
 632
 633         return 0;
 634 }
 635
 636 /* Resume device - start device. Need to be checked and fixed */
 637 static int usb_amradio_resume(struct usb_interface *intf)
 638 {
 639         struct amradio_device *radio = usb_get_intfdata(intf);
 640         int retval;
 641
 642         retval = amradio_set_mute(radio, AMRADIO_START);
 643         if (retval < 0)
 644                 dev_warn(&intf->dev, "amradio_start failed\n");
 645
 646         dev_info(&intf->dev, "coming out of suspend..\n");
 647
 648         return 0;
 649 }
 650
 651 /* File system interface */
 652 static const struct v4l2_file_operations usb_amradio_fops = {
 653         .owner          = THIS_MODULE,
 654         .open           = usb_amradio_open,
 655         .release        = usb_amradio_close,
 656         .ioctl          = video_ioctl2,
 657 };
 658
 659 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
 660         .vidioc_querycap    = vidioc_querycap,
 661         .vidioc_g_tuner     = vidioc_g_tuner,
 662         .vidioc_s_tuner     = vidioc_s_tuner,
 663         .vidioc_g_frequency = vidioc_g_frequency,
 664         .vidioc_s_frequency = vidioc_s_frequency,
 665         .vidioc_queryctrl   = vidioc_queryctrl,
 666         .vidioc_g_ctrl      = vidioc_g_ctrl,
 667         .vidioc_s_ctrl      = vidioc_s_ctrl,
 668         .vidioc_g_audio     = vidioc_g_audio,
 669         .vidioc_s_audio     = vidioc_s_audio,
 670         .vidioc_g_input     = vidioc_g_input,
 671         .vidioc_s_input     = vidioc_s_input,
 672 };
 673
 674 static void usb_amradio_device_release(struct video_device *videodev)
 675 {
 676         struct amradio_device *radio = video_get_drvdata(videodev);
 677
 678         /* we call v4l to free radio->videodev */
 679         video_device_release(videodev);
 680
 681         /* free rest memory */
 682         kfree(radio->buffer);
 683         kfree(radio);
 684 }
 685
 686 /* V4L2 interface */
 687 static struct video_device amradio_videodev_template = {
 688         .name           = "AverMedia MR 800 USB FM Radio",
 689         .fops           = &usb_amradio_fops,
 690         .ioctl_ops      = &usb_amradio_ioctl_ops,
 691         .release        = usb_amradio_device_release,
 692 };
 693
 694 /* check if the device is present and register with v4l and usb if it is */
 695 static int usb_amradio_probe(struct usb_interface *intf,
 696                                 const struct usb_device_id *id)
 697 {
 698         struct amradio_device *radio;
 699         int retval;
 700
 701         radio = kmalloc(sizeof(struct amradio_device), GFP_KERNEL);
 702
 703         if (!radio) {
 704                 dev_err(&intf->dev, "kmalloc for amradio_device failed\n");
 705                 return -ENOMEM;
 706         }
 707
 708         radio->buffer = kmalloc(BUFFER_LENGTH, GFP_KERNEL);
 709
 710         if (!radio->buffer) {
 711                 dev_err(&intf->dev, "kmalloc for radio->buffer failed\n");
 712                 kfree(radio);
 713                 return -ENOMEM;
 714         }
 715
 716         radio->videodev = video_device_alloc();
 717
 718         if (!radio->videodev) {
 719                 dev_err(&intf->dev, "video_device_alloc failed\n");
 720                 kfree(radio->buffer);
 721                 kfree(radio);
 722                 return -ENOMEM;
 723         }
 724
 725         memcpy(radio->videodev, &amradio_videodev_template,
 726                 sizeof(amradio_videodev_template));
 727
 728         radio->removed = 0;
 729         radio->users = 0;
 730         radio->usbdev = interface_to_usbdev(intf);
 731         radio->curfreq = 95.16 * FREQ_MUL;
 732         radio->stereo = -1;
 733
 734         mutex_init(&radio->lock);
 735
 736         video_set_drvdata(radio->videodev, radio);
 737         retval = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr);
 738         if (retval < 0) {
 739                 dev_err(&intf->dev, "could not register video device\n");
 740                 video_device_release(radio->videodev);
 741                 kfree(radio->buffer);
 742                 kfree(radio);
 743                 return -EIO;
 744         }
 745
 746         usb_set_intfdata(intf, radio);
 747         return 0;
 748 }
 749
 750 static int __init amradio_init(void)
 751 {
 752         int retval = usb_register(&usb_amradio_driver);
 753
 754         pr_info(KBUILD_MODNAME
 755                 ": version " DRIVER_VERSION " " DRIVER_DESC "\n");
 756
 757         if (retval)
 758                 pr_err(KBUILD_MODNAME
 759                         ": usb_register failed. Error number %d\n", retval);
 760
 761         return retval;
 762 }
 763
 764 static void __exit amradio_exit(void)
 765 {
 766         usb_deregister(&usb_amradio_driver);
 767 }
 768
 769 module_init(amradio_init);
 770 module_exit(amradio_exit);
 771