Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / 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         radio->users = 1;
473         radio->muted = 1;
474
475         if (amradio_start(radio) < 0) {
476                 warn("Radio did not start up properly");
477                 radio->users = 0;
478                 return -EIO;
479         }
480         if (amradio_setfreq(radio, radio->curfreq) < 0)
481                 warn("Set frequency failed");
482         return 0;
483 }
484
485 /*close device - free driver structures */
486 static int usb_amradio_close(struct inode *inode, struct file *file)
487 {
488         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
489
490         if (!radio)
491                 return -ENODEV;
492         radio->users = 0;
493         if (radio->removed) {
494                 kfree(radio->buffer);
495                 kfree(radio);
496         }
497         return 0;
498 }
499
500 /* Suspend device - stop device. Need to be checked and fixed */
501 static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message)
502 {
503         struct amradio_device *radio = usb_get_intfdata(intf);
504
505         if (amradio_stop(radio) < 0)
506                 warn("amradio_stop() failed");
507
508         info("radio-mr800: Going into suspend..");
509
510         return 0;
511 }
512
513 /* Resume device - start device. Need to be checked and fixed */
514 static int usb_amradio_resume(struct usb_interface *intf)
515 {
516         struct amradio_device *radio = usb_get_intfdata(intf);
517
518         if (amradio_start(radio) < 0)
519                 warn("amradio_start() failed");
520
521         info("radio-mr800: Coming out of suspend..");
522
523         return 0;
524 }
525
526 /* File system interface */
527 static const struct file_operations usb_amradio_fops = {
528         .owner          = THIS_MODULE,
529         .open           = usb_amradio_open,
530         .release        = usb_amradio_close,
531         .ioctl          = video_ioctl2,
532 #ifdef CONFIG_COMPAT
533         .compat_ioctl   = v4l_compat_ioctl32,
534 #endif
535         .llseek         = no_llseek,
536 };
537
538 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
539         .vidioc_querycap    = vidioc_querycap,
540         .vidioc_g_tuner     = vidioc_g_tuner,
541         .vidioc_s_tuner     = vidioc_s_tuner,
542         .vidioc_g_frequency = vidioc_g_frequency,
543         .vidioc_s_frequency = vidioc_s_frequency,
544         .vidioc_queryctrl   = vidioc_queryctrl,
545         .vidioc_g_ctrl      = vidioc_g_ctrl,
546         .vidioc_s_ctrl      = vidioc_s_ctrl,
547         .vidioc_g_audio     = vidioc_g_audio,
548         .vidioc_s_audio     = vidioc_s_audio,
549         .vidioc_g_input     = vidioc_g_input,
550         .vidioc_s_input     = vidioc_s_input,
551 };
552
553 /* V4L2 interface */
554 static struct video_device amradio_videodev_template = {
555         .name           = "AverMedia MR 800 USB FM Radio",
556         .fops           = &usb_amradio_fops,
557         .ioctl_ops      = &usb_amradio_ioctl_ops,
558         .release        = video_device_release,
559 };
560
561 /* check if the device is present and register with v4l and
562 usb if it is */
563 static int usb_amradio_probe(struct usb_interface *intf,
564                                 const struct usb_device_id *id)
565 {
566         struct amradio_device *radio;
567
568         radio = kmalloc(sizeof(struct amradio_device), GFP_KERNEL);
569
570         if (!(radio))
571                 return -ENOMEM;
572
573         radio->buffer = kmalloc(BUFFER_LENGTH, GFP_KERNEL);
574
575         if (!(radio->buffer)) {
576                 kfree(radio);
577                 return -ENOMEM;
578         }
579
580         radio->videodev = video_device_alloc();
581
582         if (!(radio->videodev)) {
583                 kfree(radio->buffer);
584                 kfree(radio);
585                 return -ENOMEM;
586         }
587
588         memcpy(radio->videodev, &amradio_videodev_template,
589                 sizeof(amradio_videodev_template));
590
591         radio->removed = 0;
592         radio->users = 0;
593         radio->usbdev = interface_to_usbdev(intf);
594         radio->curfreq = 95.16 * FREQ_MUL;
595
596         mutex_init(&radio->lock);
597
598         video_set_drvdata(radio->videodev, radio);
599         if (video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr)) {
600                 warn("Could not register video device");
601                 video_device_release(radio->videodev);
602                 kfree(radio->buffer);
603                 kfree(radio);
604                 return -EIO;
605         }
606
607         usb_set_intfdata(intf, radio);
608         return 0;
609 }
610
611 static int __init amradio_init(void)
612 {
613         int retval = usb_register(&usb_amradio_driver);
614
615         info(DRIVER_VERSION " " DRIVER_DESC);
616         if (retval)
617                 err("usb_register failed. Error number %d", retval);
618         return retval;
619 }
620
621 static void __exit amradio_exit(void)
622 {
623         usb_deregister(&usb_amradio_driver);
624 }
625
626 module_init(amradio_init);
627 module_exit(amradio_exit);
628