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 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  * So, we have smth to begin with.
  34  *
  35  * History:
  36  * Version 0.01:        First working version.
  37  *                      It's required to blacklist AverMedia USB Radio
  38  *                      in usbhid/hid-quirks.c
  39  *
  40  * Many things to do:
  41  *      - Correct power managment of device (suspend & resume)
  42  *      - Make x86 independance (little-endian and big-endian stuff)
  43  *      - Add code for scanning and smooth tuning
  44  *      - Checked and add stereo&mono stuff
  45  *      - Add code for sensitivity value
  46  *      - Correct mistakes
  47  *      - In Japan another FREQ_MIN and FREQ_MAX
  48  */
  49
  50 /* kernel includes */
  51 #include <linux/kernel.h>
  52 #include <linux/module.h>
  53 #include <linux/init.h>
  54 #include <linux/slab.h>
  55 #include <linux/input.h>
  56 #include <linux/videodev2.h>
  57 #include <media/v4l2-common.h>
  58 #include <media/v4l2-ioctl.h>
  59 #include <linux/usb.h>
  60 #include <linux/version.h>      /* for KERNEL_VERSION MACRO */
  61
  62 /* driver and module definitions */
  63 #define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@gmail.com>"
  64 #define DRIVER_DESC "AverMedia MR 800 USB FM radio driver"
  65 #define DRIVER_VERSION "0.01"
  66 #define RADIO_VERSION KERNEL_VERSION(0, 0, 1)
  67
  68 MODULE_AUTHOR(DRIVER_AUTHOR);
  69 MODULE_DESCRIPTION(DRIVER_DESC);
  70 MODULE_LICENSE("GPL");
  71
  72 #define USB_AMRADIO_VENDOR 0x07ca
  73 #define USB_AMRADIO_PRODUCT 0xb800
  74
  75 /* Probably USB_TIMEOUT should be modified in module parameter */
  76 #define BUFFER_LENGTH 8
  77 #define USB_TIMEOUT 500
  78
  79 /* Frequency limits in MHz -- these are European values.  For Japanese
  80 devices, that would be 76 and 91.  */
  81 #define FREQ_MIN  87.5
  82 #define FREQ_MAX 108.0
  83 #define FREQ_MUL 16000
  84
  85 /* module parameter */
  86 static int radio_nr = -1;
  87 module_param(radio_nr, int, 0);
  88 MODULE_PARM_DESC(radio_nr, "Radio Nr");
  89
  90 static struct v4l2_queryctrl radio_qctrl[] = {
  91         {
  92                 .id            = V4L2_CID_AUDIO_MUTE,
  93                 .name          = "Mute",
  94                 .minimum       = 0,
  95                 .maximum       = 1,
  96                 .step          = 1,
  97                 .default_value = 1,
  98                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
  99         },
 100 /* HINT: the disabled controls are only here to satify kradio and such apps */
 101         {       .id             = V4L2_CID_AUDIO_VOLUME,
 102                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 103         },
 104         {
 105                 .id             = V4L2_CID_AUDIO_BALANCE,
 106                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 107         },
 108         {
 109                 .id             = V4L2_CID_AUDIO_BASS,
 110                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 111         },
 112         {
 113                 .id             = V4L2_CID_AUDIO_TREBLE,
 114                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 115         },
 116         {
 117                 .id             = V4L2_CID_AUDIO_LOUDNESS,
 118                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 119         },
 120 };
 121
 122 static int usb_amradio_probe(struct usb_interface *intf,
 123                              const struct usb_device_id *id);
 124 static void usb_amradio_disconnect(struct usb_interface *intf);
 125 static int usb_amradio_open(struct inode *inode, struct file *file);
 126 static int usb_amradio_close(struct inode *inode, struct file *file);
 127 static int usb_amradio_suspend(struct usb_interface *intf,
 128                                 pm_message_t message);
 129 static int usb_amradio_resume(struct usb_interface *intf);
 130
 131 /* Data for one (physical) device */
 132 struct amradio_device {
 133         /* reference to USB and video device */
 134         struct usb_device *usbdev;
 135         struct video_device *videodev;
 136
 137         unsigned char *buffer;
 138         struct mutex lock;      /* buffer locking */
 139         int curfreq;
 140         int stereo;
 141         int users;
 142         int removed;
 143         int muted;
 144 };
 145
 146 /* USB Device ID List */
 147 static struct usb_device_id usb_amradio_device_table[] = {
 148         {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR, USB_AMRADIO_PRODUCT,
 149                                                         USB_CLASS_HID, 0, 0) },
 150         { }                                             /* Terminating entry */
 151 };
 152
 153 MODULE_DEVICE_TABLE(usb, usb_amradio_device_table);
 154
 155 /* USB subsystem interface */
 156 static struct usb_driver usb_amradio_driver = {
 157         .name                   = "radio-mr800",
 158         .probe                  = usb_amradio_probe,
 159         .disconnect             = usb_amradio_disconnect,
 160         .suspend                = usb_amradio_suspend,
 161         .resume                 = usb_amradio_resume,
 162         .reset_resume           = usb_amradio_resume,
 163         .id_table               = usb_amradio_device_table,
 164         .supports_autosuspend   = 1,
 165 };
 166
 167 /* switch on radio. Send 8 bytes to device. */
 168 static int amradio_start(struct amradio_device *radio)
 169 {
 170         int retval;
 171         int size;
 172
 173         mutex_lock(&radio->lock);
 174
 175         radio->buffer[0] = 0x00;
 176         radio->buffer[1] = 0x55;
 177         radio->buffer[2] = 0xaa;
 178         radio->buffer[3] = 0x00;
 179         radio->buffer[4] = 0xab;
 180         radio->buffer[5] = 0x00;
 181         radio->buffer[6] = 0x00;
 182         radio->buffer[7] = 0x00;
 183
 184         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 185                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 186
 187         if (retval) {
 188                 mutex_unlock(&radio->lock);
 189                 return retval;
 190         }
 191
 192         mutex_unlock(&radio->lock);
 193
 194         radio->muted = 0;
 195
 196         return retval;
 197 }
 198
 199 /* switch off radio */
 200 static int amradio_stop(struct amradio_device *radio)
 201 {
 202         int retval;
 203         int size;
 204
 205         mutex_lock(&radio->lock);
 206
 207         radio->buffer[0] = 0x00;
 208         radio->buffer[1] = 0x55;
 209         radio->buffer[2] = 0xaa;
 210         radio->buffer[3] = 0x00;
 211         radio->buffer[4] = 0xab;
 212         radio->buffer[5] = 0x01;
 213         radio->buffer[6] = 0x00;
 214         radio->buffer[7] = 0x00;
 215
 216         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 217                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 218
 219         if (retval) {
 220                 mutex_unlock(&radio->lock);
 221                 return retval;
 222         }
 223
 224         mutex_unlock(&radio->lock);
 225
 226         radio->muted = 1;
 227
 228         return retval;
 229 }
 230
 231 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
 232 static int amradio_setfreq(struct amradio_device *radio, int freq)
 233 {
 234         int retval;
 235         int size;
 236         unsigned short freq_send = 0x13 + (freq >> 3) / 25;
 237
 238         mutex_lock(&radio->lock);
 239
 240         radio->buffer[0] = 0x00;
 241         radio->buffer[1] = 0x55;
 242         radio->buffer[2] = 0xaa;
 243         radio->buffer[3] = 0x03;
 244         radio->buffer[4] = 0xa4;
 245         radio->buffer[5] = 0x00;
 246         radio->buffer[6] = 0x00;
 247         radio->buffer[7] = 0x08;
 248
 249         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 250                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 251
 252         if (retval) {
 253                 mutex_unlock(&radio->lock);
 254                 return retval;
 255         }
 256
 257         /* frequency is calculated from freq_send and placed in first 2 bytes */
 258         radio->buffer[0] = (freq_send >> 8) & 0xff;
 259         radio->buffer[1] = freq_send & 0xff;
 260         radio->buffer[2] = 0x01;
 261         radio->buffer[3] = 0x00;
 262         radio->buffer[4] = 0x00;
 263         /* 5 and 6 bytes of buffer already = 0x00 */
 264         radio->buffer[7] = 0x00;
 265
 266         retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
 267                 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
 268
 269         if (retval) {
 270                 mutex_unlock(&radio->lock);
 271                 return retval;
 272         }
 273
 274         mutex_unlock(&radio->lock);
 275
 276         radio->stereo = 0;
 277
 278         return retval;
 279 }
 280
 281 /* USB subsystem interface begins here */
 282
 283 /* handle unplugging of the device, release data structures
 284 if nothing keeps us from doing it.  If something is still
 285 keeping us busy, the release callback of v4l will take care
 286 of releasing it. */
 287 static void usb_amradio_disconnect(struct usb_interface *intf)
 288 {
 289         struct amradio_device *radio = usb_get_intfdata(intf);
 290
 291         usb_set_intfdata(intf, NULL);
 292
 293         if (radio) {
 294                 video_unregister_device(radio->videodev);
 295                 radio->videodev = NULL;
 296                 if (radio->users) {
 297                         kfree(radio->buffer);
 298                         kfree(radio);
 299                 } else {
 300                         radio->removed = 1;
 301                 }
 302         }
 303 }
 304
 305 /* vidioc_querycap - query device capabilities */
 306 static int vidioc_querycap(struct file *file, void *priv,
 307                                         struct v4l2_capability *v)
 308 {
 309         strlcpy(v->driver, "radio-mr800", sizeof(v->driver));
 310         strlcpy(v->card, "AverMedia MR 800 USB FM Radio", sizeof(v->card));
 311         sprintf(v->bus_info, "USB");
 312         v->version = RADIO_VERSION;
 313         v->capabilities = V4L2_CAP_TUNER;
 314         return 0;
 315 }
 316
 317 /* vidioc_g_tuner - get tuner attributes */
 318 static int vidioc_g_tuner(struct file *file, void *priv,
 319                                 struct v4l2_tuner *v)
 320 {
 321         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 322
 323         if (v->index > 0)
 324                 return -EINVAL;
 325
 326 /* TODO: Add function which look is signal stereo or not
 327  *      amradio_getstat(radio);
 328  */
 329         radio->stereo = -1;
 330         strcpy(v->name, "FM");
 331         v->type = V4L2_TUNER_RADIO;
 332         v->rangelow = FREQ_MIN * FREQ_MUL;
 333         v->rangehigh = FREQ_MAX * FREQ_MUL;
 334         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
 335         v->capability = V4L2_TUNER_CAP_LOW;
 336         if (radio->stereo)
 337                 v->audmode = V4L2_TUNER_MODE_STEREO;
 338         else
 339                 v->audmode = V4L2_TUNER_MODE_MONO;
 340         v->signal = 0xffff;     /* Can't get the signal strength, sad.. */
 341         v->afc = 0; /* Don't know what is this */
 342         return 0;
 343 }
 344
 345 /* vidioc_s_tuner - set tuner attributes */
 346 static int vidioc_s_tuner(struct file *file, void *priv,
 347                                 struct v4l2_tuner *v)
 348 {
 349         if (v->index > 0)
 350                 return -EINVAL;
 351         return 0;
 352 }
 353
 354 /* vidioc_s_frequency - set tuner radio frequency */
 355 static int vidioc_s_frequency(struct file *file, void *priv,
 356                                 struct v4l2_frequency *f)
 357 {
 358         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 359
 360         radio->curfreq = f->frequency;
 361         if (amradio_setfreq(radio, radio->curfreq) < 0)
 362                 warn("Set frequency failed");
 363         return 0;
 364 }
 365
 366 /* vidioc_g_frequency - get tuner radio frequency */
 367 static int vidioc_g_frequency(struct file *file, void *priv,
 368                                 struct v4l2_frequency *f)
 369 {
 370         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 371
 372         f->type = V4L2_TUNER_RADIO;
 373         f->frequency = radio->curfreq;
 374         return 0;
 375 }
 376
 377 /* vidioc_queryctrl - enumerate control items */
 378 static int vidioc_queryctrl(struct file *file, void *priv,
 379                                 struct v4l2_queryctrl *qc)
 380 {
 381         int i;
 382
 383         for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
 384                 if (qc->id && qc->id == radio_qctrl[i].id) {
 385                         memcpy(qc, &(radio_qctrl[i]),
 386                                                 sizeof(*qc));
 387                         return 0;
 388                 }
 389         }
 390         return -EINVAL;
 391 }
 392
 393 /* vidioc_g_ctrl - get the value of a control */
 394 static int vidioc_g_ctrl(struct file *file, void *priv,
 395                                 struct v4l2_control *ctrl)
 396 {
 397         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 398
 399         switch (ctrl->id) {
 400         case V4L2_CID_AUDIO_MUTE:
 401                 ctrl->value = radio->muted;
 402                 return 0;
 403         }
 404         return -EINVAL;
 405 }
 406
 407 /* vidioc_s_ctrl - set the value of a control */
 408 static int vidioc_s_ctrl(struct file *file, void *priv,
 409                                 struct v4l2_control *ctrl)
 410 {
 411         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 412
 413         switch (ctrl->id) {
 414         case V4L2_CID_AUDIO_MUTE:
 415                 if (ctrl->value) {
 416                         if (amradio_stop(radio) < 0) {
 417                                 warn("amradio_stop() failed");
 418                                 return -1;
 419                         }
 420                 } else {
 421                         if (amradio_start(radio) < 0) {
 422                                 warn("amradio_start() failed");
 423                                 return -1;
 424                         }
 425                 }
 426                 return 0;
 427         }
 428         return -EINVAL;
 429 }
 430
 431 /* vidioc_g_audio - get audio attributes */
 432 static int vidioc_g_audio(struct file *file, void *priv,
 433                                 struct v4l2_audio *a)
 434 {
 435         if (a->index > 1)
 436                 return -EINVAL;
 437
 438         strcpy(a->name, "Radio");
 439         a->capability = V4L2_AUDCAP_STEREO;
 440         return 0;
 441 }
 442
 443 /* vidioc_s_audio - set audio attributes  */
 444 static int vidioc_s_audio(struct file *file, void *priv,
 445                                         struct v4l2_audio *a)
 446 {
 447         if (a->index != 0)
 448                 return -EINVAL;
 449         return 0;
 450 }
 451
 452 /* vidioc_g_input - get input */
 453 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
 454 {
 455         *i = 0;
 456         return 0;
 457 }
 458
 459 /* vidioc_s_input - set input */
 460 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 461 {
 462         if (i != 0)
 463                 return -EINVAL;
 464         return 0;
 465 }
 466
 467 /* open device - amradio_start() and amradio_setfreq() */
 468 static int usb_amradio_open(struct inode *inode, struct file *file)
 469 {
 470         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 471
 472         lock_kernel();
 473
 474         radio->users = 1;
 475         radio->muted = 1;
 476
 477         if (amradio_start(radio) < 0) {
 478                 warn("Radio did not start up properly");
 479                 radio->users = 0;
 480                 unlock_kernel();
 481                 return -EIO;
 482         }
 483         if (amradio_setfreq(radio, radio->curfreq) < 0)
 484                 warn("Set frequency failed");
 485
 486         unlock_kernel();
 487         return 0;
 488 }
 489
 490 /*close device - free driver structures */
 491 static int usb_amradio_close(struct inode *inode, struct file *file)
 492 {
 493         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 494
 495         if (!radio)
 496                 return -ENODEV;
 497         radio->users = 0;
 498         if (radio->removed) {
 499                 kfree(radio->buffer);
 500                 kfree(radio);
 501         }
 502         return 0;
 503 }
 504
 505 /* Suspend device - stop device. Need to be checked and fixed */
 506 static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message)
 507 {
 508         struct amradio_device *radio = usb_get_intfdata(intf);
 509
 510         if (amradio_stop(radio) < 0)
 511                 warn("amradio_stop() failed");
 512
 513         info("radio-mr800: Going into suspend..");
 514
 515         return 0;
 516 }
 517
 518 /* Resume device - start device. Need to be checked and fixed */
 519 static int usb_amradio_resume(struct usb_interface *intf)
 520 {
 521         struct amradio_device *radio = usb_get_intfdata(intf);
 522
 523         if (amradio_start(radio) < 0)
 524                 warn("amradio_start() failed");
 525
 526         info("radio-mr800: Coming out of suspend..");
 527
 528         return 0;
 529 }
 530
 531 /* File system interface */
 532 static const struct file_operations usb_amradio_fops = {
 533         .owner          = THIS_MODULE,
 534         .open           = usb_amradio_open,
 535         .release        = usb_amradio_close,
 536         .ioctl          = video_ioctl2,
 537 #ifdef CONFIG_COMPAT
 538         .compat_ioctl   = v4l_compat_ioctl32,
 539 #endif
 540         .llseek         = no_llseek,
 541 };
 542
 543 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
 544         .vidioc_querycap    = vidioc_querycap,
 545         .vidioc_g_tuner     = vidioc_g_tuner,
 546         .vidioc_s_tuner     = vidioc_s_tuner,
 547         .vidioc_g_frequency = vidioc_g_frequency,
 548         .vidioc_s_frequency = vidioc_s_frequency,
 549         .vidioc_queryctrl   = vidioc_queryctrl,
 550         .vidioc_g_ctrl      = vidioc_g_ctrl,
 551         .vidioc_s_ctrl      = vidioc_s_ctrl,
 552         .vidioc_g_audio     = vidioc_g_audio,
 553         .vidioc_s_audio     = vidioc_s_audio,
 554         .vidioc_g_input     = vidioc_g_input,
 555         .vidioc_s_input     = vidioc_s_input,
 556 };
 557
 558 /* V4L2 interface */
 559 static struct video_device amradio_videodev_template = {
 560         .name           = "AverMedia MR 800 USB FM Radio",
 561         .fops           = &usb_amradio_fops,
 562         .ioctl_ops      = &usb_amradio_ioctl_ops,
 563         .release        = video_device_release,
 564 };
 565
 566 /* check if the device is present and register with v4l and
 567 usb if it is */
 568 static int usb_amradio_probe(struct usb_interface *intf,
 569                                 const struct usb_device_id *id)
 570 {
 571         struct amradio_device *radio;
 572
 573         radio = kmalloc(sizeof(struct amradio_device), GFP_KERNEL);
 574
 575         if (!(radio))
 576                 return -ENOMEM;
 577
 578         radio->buffer = kmalloc(BUFFER_LENGTH, GFP_KERNEL);
 579
 580         if (!(radio->buffer)) {
 581                 kfree(radio);
 582                 return -ENOMEM;
 583         }
 584
 585         radio->videodev = video_device_alloc();
 586
 587         if (!(radio->videodev)) {
 588                 kfree(radio->buffer);
 589                 kfree(radio);
 590                 return -ENOMEM;
 591         }
 592
 593         memcpy(radio->videodev, &amradio_videodev_template,
 594                 sizeof(amradio_videodev_template));
 595
 596         radio->removed = 0;
 597         radio->users = 0;
 598         radio->usbdev = interface_to_usbdev(intf);
 599         radio->curfreq = 95.16 * FREQ_MUL;
 600
 601         mutex_init(&radio->lock);
 602
 603         video_set_drvdata(radio->videodev, radio);
 604         if (video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr)) {
 605                 warn("Could not register video device");
 606                 video_device_release(radio->videodev);
 607                 kfree(radio->buffer);
 608                 kfree(radio);
 609                 return -EIO;
 610         }
 611
 612         usb_set_intfdata(intf, radio);
 613         return 0;
 614 }
 615
 616 static int __init amradio_init(void)
 617 {
 618         int retval = usb_register(&usb_amradio_driver);
 619
 620         info(DRIVER_VERSION " " DRIVER_DESC);
 621         if (retval)
 622                 err("usb_register failed. Error number %d", retval);
 623         return retval;
 624 }
 625
 626 static void __exit amradio_exit(void)
 627 {
 628         usb_deregister(&usb_amradio_driver);
 629 }
 630
 631 module_init(amradio_init);
 632 module_exit(amradio_exit);
 633