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.
7 * Copyright (c) 2008 Alexey Klimov <klimov.linux@gmail.com>
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.
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.
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
25 * Big thanks to authors and contributors of dsbr100.c and radio-si470x.c
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
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 * Version 0.11: Converted to v4l2_device.
49 * - Correct power managment of device (suspend & resume)
50 * - Add code for scanning and smooth tuning
51 * - Add code for sensitivity value
53 * - In Japan another FREQ_MIN and FREQ_MAX
57 #include <linux/kernel.h>
58 #include <linux/module.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #include <linux/input.h>
62 #include <linux/videodev2.h>
63 #include <media/v4l2-device.h>
64 #include <media/v4l2-ioctl.h>
65 #include <linux/usb.h>
66 #include <linux/version.h> /* for KERNEL_VERSION MACRO */
68 /* driver and module definitions */
69 #define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@gmail.com>"
70 #define DRIVER_DESC "AverMedia MR 800 USB FM radio driver"
71 #define DRIVER_VERSION "0.11"
72 #define RADIO_VERSION KERNEL_VERSION(0, 1, 1)
74 MODULE_AUTHOR(DRIVER_AUTHOR
);
75 MODULE_DESCRIPTION(DRIVER_DESC
);
76 MODULE_LICENSE("GPL");
78 #define USB_AMRADIO_VENDOR 0x07ca
79 #define USB_AMRADIO_PRODUCT 0xb800
81 /* dev_warn macro with driver name */
82 #define MR800_DRIVER_NAME "radio-mr800"
83 #define amradio_dev_warn(dev, fmt, arg...) \
84 dev_warn(dev, MR800_DRIVER_NAME " - " fmt, ##arg)
86 /* Probably USB_TIMEOUT should be modified in module parameter */
87 #define BUFFER_LENGTH 8
88 #define USB_TIMEOUT 500
90 /* Frequency limits in MHz -- these are European values. For Japanese
91 devices, that would be 76 and 91. */
93 #define FREQ_MAX 108.0
94 #define FREQ_MUL 16000
97 * Commands that device should understand
98 * List isnt full and will be updated with implementation of new functions
100 #define AMRADIO_SET_FREQ 0xa4
101 #define AMRADIO_SET_MUTE 0xab
102 #define AMRADIO_SET_MONO 0xae
104 /* Comfortable defines for amradio_set_mute */
105 #define AMRADIO_START 0x00
106 #define AMRADIO_STOP 0x01
108 /* Comfortable defines for amradio_set_stereo */
109 #define WANT_STEREO 0x00
110 #define WANT_MONO 0x01
112 /* module parameter */
113 static int radio_nr
= -1;
114 module_param(radio_nr
, int, 0);
115 MODULE_PARM_DESC(radio_nr
, "Radio Nr");
117 static int usb_amradio_probe(struct usb_interface
*intf
,
118 const struct usb_device_id
*id
);
119 static void usb_amradio_disconnect(struct usb_interface
*intf
);
120 static int usb_amradio_open(struct file
*file
);
121 static int usb_amradio_close(struct file
*file
);
122 static int usb_amradio_suspend(struct usb_interface
*intf
,
123 pm_message_t message
);
124 static int usb_amradio_resume(struct usb_interface
*intf
);
126 /* Data for one (physical) device */
127 struct amradio_device
{
128 /* reference to USB and video device */
129 struct usb_device
*usbdev
;
130 struct video_device
*videodev
;
131 struct v4l2_device v4l2_dev
;
133 unsigned char *buffer
;
134 struct mutex lock
; /* buffer locking */
142 /* USB Device ID List */
143 static struct usb_device_id usb_amradio_device_table
[] = {
144 {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR
, USB_AMRADIO_PRODUCT
,
145 USB_CLASS_HID
, 0, 0) },
146 { } /* Terminating entry */
149 MODULE_DEVICE_TABLE(usb
, usb_amradio_device_table
);
151 /* USB subsystem interface */
152 static struct usb_driver usb_amradio_driver
= {
153 .name
= MR800_DRIVER_NAME
,
154 .probe
= usb_amradio_probe
,
155 .disconnect
= usb_amradio_disconnect
,
156 .suspend
= usb_amradio_suspend
,
157 .resume
= usb_amradio_resume
,
158 .reset_resume
= usb_amradio_resume
,
159 .id_table
= usb_amradio_device_table
,
160 .supports_autosuspend
= 0,
163 /* switch on/off the radio. Send 8 bytes to device */
164 static int amradio_set_mute(struct amradio_device
*radio
, char argument
)
173 mutex_lock(&radio
->lock
);
175 radio
->buffer
[0] = 0x00;
176 radio
->buffer
[1] = 0x55;
177 radio
->buffer
[2] = 0xaa;
178 radio
->buffer
[3] = 0x00;
179 radio
->buffer
[4] = AMRADIO_SET_MUTE
;
180 radio
->buffer
[5] = argument
;
181 radio
->buffer
[6] = 0x00;
182 radio
->buffer
[7] = 0x00;
184 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
185 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
187 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
188 mutex_unlock(&radio
->lock
);
192 radio
->muted
= argument
;
194 mutex_unlock(&radio
->lock
);
199 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
200 static int amradio_setfreq(struct amradio_device
*radio
, int freq
)
204 unsigned short freq_send
= 0x10 + (freq
>> 3) / 25;
210 mutex_lock(&radio
->lock
);
212 radio
->buffer
[0] = 0x00;
213 radio
->buffer
[1] = 0x55;
214 radio
->buffer
[2] = 0xaa;
215 radio
->buffer
[3] = 0x03;
216 radio
->buffer
[4] = AMRADIO_SET_FREQ
;
217 radio
->buffer
[5] = 0x00;
218 radio
->buffer
[6] = 0x00;
219 radio
->buffer
[7] = 0x08;
221 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
222 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
224 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
225 mutex_unlock(&radio
->lock
);
229 /* frequency is calculated from freq_send and placed in first 2 bytes */
230 radio
->buffer
[0] = (freq_send
>> 8) & 0xff;
231 radio
->buffer
[1] = freq_send
& 0xff;
232 radio
->buffer
[2] = 0x01;
233 radio
->buffer
[3] = 0x00;
234 radio
->buffer
[4] = 0x00;
235 /* 5 and 6 bytes of buffer already = 0x00 */
236 radio
->buffer
[7] = 0x00;
238 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
239 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
241 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
242 mutex_unlock(&radio
->lock
);
246 mutex_unlock(&radio
->lock
);
251 static int amradio_set_stereo(struct amradio_device
*radio
, char argument
)
260 mutex_lock(&radio
->lock
);
262 radio
->buffer
[0] = 0x00;
263 radio
->buffer
[1] = 0x55;
264 radio
->buffer
[2] = 0xaa;
265 radio
->buffer
[3] = 0x00;
266 radio
->buffer
[4] = AMRADIO_SET_MONO
;
267 radio
->buffer
[5] = argument
;
268 radio
->buffer
[6] = 0x00;
269 radio
->buffer
[7] = 0x00;
271 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
272 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
274 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
276 mutex_unlock(&radio
->lock
);
282 mutex_unlock(&radio
->lock
);
287 /* Handle unplugging the device.
288 * We call video_unregister_device in any case.
289 * The last function called in this procedure is
290 * usb_amradio_device_release.
292 static void usb_amradio_disconnect(struct usb_interface
*intf
)
294 struct amradio_device
*radio
= usb_get_intfdata(intf
);
296 mutex_lock(&radio
->lock
);
298 mutex_unlock(&radio
->lock
);
300 usb_set_intfdata(intf
, NULL
);
301 video_unregister_device(radio
->videodev
);
302 v4l2_device_disconnect(&radio
->v4l2_dev
);
305 /* vidioc_querycap - query device capabilities */
306 static int vidioc_querycap(struct file
*file
, void *priv
,
307 struct v4l2_capability
*v
)
309 struct amradio_device
*radio
= video_drvdata(file
);
311 strlcpy(v
->driver
, "radio-mr800", sizeof(v
->driver
));
312 strlcpy(v
->card
, "AverMedia MR 800 USB FM Radio", sizeof(v
->card
));
313 usb_make_path(radio
->usbdev
, v
->bus_info
, sizeof(v
->bus_info
));
314 v
->version
= RADIO_VERSION
;
315 v
->capabilities
= V4L2_CAP_TUNER
;
319 /* vidioc_g_tuner - get tuner attributes */
320 static int vidioc_g_tuner(struct file
*file
, void *priv
,
321 struct v4l2_tuner
*v
)
323 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
333 /* TODO: Add function which look is signal stereo or not
334 * amradio_getstat(radio);
337 /* we call amradio_set_stereo to set radio->stereo
338 * Honestly, amradio_getstat should cover this in future and
339 * amradio_set_stereo shouldn't be here
341 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
343 amradio_dev_warn(&radio
->videodev
->dev
,
344 "set stereo failed\n");
346 strcpy(v
->name
, "FM");
347 v
->type
= V4L2_TUNER_RADIO
;
348 v
->rangelow
= FREQ_MIN
* FREQ_MUL
;
349 v
->rangehigh
= FREQ_MAX
* FREQ_MUL
;
350 v
->rxsubchans
= V4L2_TUNER_SUB_MONO
| V4L2_TUNER_SUB_STEREO
;
351 v
->capability
= V4L2_TUNER_CAP_LOW
;
353 v
->audmode
= V4L2_TUNER_MODE_STEREO
;
355 v
->audmode
= V4L2_TUNER_MODE_MONO
;
356 v
->signal
= 0xffff; /* Can't get the signal strength, sad.. */
357 v
->afc
= 0; /* Don't know what is this */
361 /* vidioc_s_tuner - set tuner attributes */
362 static int vidioc_s_tuner(struct file
*file
, void *priv
,
363 struct v4l2_tuner
*v
)
365 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
375 /* mono/stereo selector */
376 switch (v
->audmode
) {
377 case V4L2_TUNER_MODE_MONO
:
378 retval
= amradio_set_stereo(radio
, WANT_MONO
);
380 amradio_dev_warn(&radio
->videodev
->dev
,
381 "set mono failed\n");
383 case V4L2_TUNER_MODE_STEREO
:
384 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
386 amradio_dev_warn(&radio
->videodev
->dev
,
387 "set stereo failed\n");
396 /* vidioc_s_frequency - set tuner radio frequency */
397 static int vidioc_s_frequency(struct file
*file
, void *priv
,
398 struct v4l2_frequency
*f
)
400 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
407 mutex_lock(&radio
->lock
);
408 radio
->curfreq
= f
->frequency
;
409 mutex_unlock(&radio
->lock
);
411 retval
= amradio_setfreq(radio
, radio
->curfreq
);
413 amradio_dev_warn(&radio
->videodev
->dev
,
414 "set frequency failed\n");
418 /* vidioc_g_frequency - get tuner radio frequency */
419 static int vidioc_g_frequency(struct file
*file
, void *priv
,
420 struct v4l2_frequency
*f
)
422 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
428 f
->type
= V4L2_TUNER_RADIO
;
429 f
->frequency
= radio
->curfreq
;
433 /* vidioc_queryctrl - enumerate control items */
434 static int vidioc_queryctrl(struct file
*file
, void *priv
,
435 struct v4l2_queryctrl
*qc
)
438 case V4L2_CID_AUDIO_MUTE
:
439 return v4l2_ctrl_query_fill(qc
, 0, 1, 1, 1);
445 /* vidioc_g_ctrl - get the value of a control */
446 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
447 struct v4l2_control
*ctrl
)
449 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
456 case V4L2_CID_AUDIO_MUTE
:
457 ctrl
->value
= radio
->muted
;
463 /* vidioc_s_ctrl - set the value of a control */
464 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
465 struct v4l2_control
*ctrl
)
467 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
475 case V4L2_CID_AUDIO_MUTE
:
477 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
479 amradio_dev_warn(&radio
->videodev
->dev
,
480 "amradio_stop failed\n");
484 retval
= amradio_set_mute(radio
, AMRADIO_START
);
486 amradio_dev_warn(&radio
->videodev
->dev
,
487 "amradio_start failed\n");
496 /* vidioc_g_audio - get audio attributes */
497 static int vidioc_g_audio(struct file
*file
, void *priv
,
498 struct v4l2_audio
*a
)
503 strcpy(a
->name
, "Radio");
504 a
->capability
= V4L2_AUDCAP_STEREO
;
508 /* vidioc_s_audio - set audio attributes */
509 static int vidioc_s_audio(struct file
*file
, void *priv
,
510 struct v4l2_audio
*a
)
517 /* vidioc_g_input - get input */
518 static int vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
524 /* vidioc_s_input - set input */
525 static int vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
532 /* open device - amradio_start() and amradio_setfreq() */
533 static int usb_amradio_open(struct file
*file
)
535 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
543 retval
= amradio_set_mute(radio
, AMRADIO_START
);
545 amradio_dev_warn(&radio
->videodev
->dev
,
546 "radio did not start up properly\n");
552 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
554 amradio_dev_warn(&radio
->videodev
->dev
,
555 "set stereo failed\n");
557 retval
= amradio_setfreq(radio
, radio
->curfreq
);
559 amradio_dev_warn(&radio
->videodev
->dev
,
560 "set frequency failed\n");
567 static int usb_amradio_close(struct file
*file
)
569 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
575 mutex_lock(&radio
->lock
);
577 mutex_unlock(&radio
->lock
);
579 if (!radio
->removed
) {
580 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
582 amradio_dev_warn(&radio
->videodev
->dev
,
583 "amradio_stop failed\n");
589 /* Suspend device - stop device. Need to be checked and fixed */
590 static int usb_amradio_suspend(struct usb_interface
*intf
, pm_message_t message
)
592 struct amradio_device
*radio
= usb_get_intfdata(intf
);
595 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
597 dev_warn(&intf
->dev
, "amradio_stop failed\n");
599 dev_info(&intf
->dev
, "going into suspend..\n");
604 /* Resume device - start device. Need to be checked and fixed */
605 static int usb_amradio_resume(struct usb_interface
*intf
)
607 struct amradio_device
*radio
= usb_get_intfdata(intf
);
610 retval
= amradio_set_mute(radio
, AMRADIO_START
);
612 dev_warn(&intf
->dev
, "amradio_start failed\n");
614 dev_info(&intf
->dev
, "coming out of suspend..\n");
619 /* File system interface */
620 static const struct v4l2_file_operations usb_amradio_fops
= {
621 .owner
= THIS_MODULE
,
622 .open
= usb_amradio_open
,
623 .release
= usb_amradio_close
,
624 .ioctl
= video_ioctl2
,
627 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops
= {
628 .vidioc_querycap
= vidioc_querycap
,
629 .vidioc_g_tuner
= vidioc_g_tuner
,
630 .vidioc_s_tuner
= vidioc_s_tuner
,
631 .vidioc_g_frequency
= vidioc_g_frequency
,
632 .vidioc_s_frequency
= vidioc_s_frequency
,
633 .vidioc_queryctrl
= vidioc_queryctrl
,
634 .vidioc_g_ctrl
= vidioc_g_ctrl
,
635 .vidioc_s_ctrl
= vidioc_s_ctrl
,
636 .vidioc_g_audio
= vidioc_g_audio
,
637 .vidioc_s_audio
= vidioc_s_audio
,
638 .vidioc_g_input
= vidioc_g_input
,
639 .vidioc_s_input
= vidioc_s_input
,
642 static void usb_amradio_video_device_release(struct video_device
*videodev
)
644 struct amradio_device
*radio
= video_get_drvdata(videodev
);
646 /* we call v4l to free radio->videodev */
647 video_device_release(videodev
);
649 v4l2_device_unregister(&radio
->v4l2_dev
);
651 /* free rest memory */
652 kfree(radio
->buffer
);
656 /* check if the device is present and register with v4l and usb if it is */
657 static int usb_amradio_probe(struct usb_interface
*intf
,
658 const struct usb_device_id
*id
)
660 struct amradio_device
*radio
;
661 struct v4l2_device
*v4l2_dev
;
664 radio
= kzalloc(sizeof(struct amradio_device
), GFP_KERNEL
);
667 dev_err(&intf
->dev
, "kmalloc for amradio_device failed\n");
671 radio
->buffer
= kmalloc(BUFFER_LENGTH
, GFP_KERNEL
);
673 if (!radio
->buffer
) {
674 dev_err(&intf
->dev
, "kmalloc for radio->buffer failed\n");
679 v4l2_dev
= &radio
->v4l2_dev
;
680 retval
= v4l2_device_register(&intf
->dev
, v4l2_dev
);
682 dev_err(&intf
->dev
, "couldn't register v4l2_device\n");
683 kfree(radio
->buffer
);
688 radio
->videodev
= video_device_alloc();
690 if (!radio
->videodev
) {
691 dev_err(&intf
->dev
, "video_device_alloc failed\n");
692 kfree(radio
->buffer
);
697 strlcpy(radio
->videodev
->name
, v4l2_dev
->name
, sizeof(radio
->videodev
->name
));
698 radio
->videodev
->v4l2_dev
= v4l2_dev
;
699 radio
->videodev
->fops
= &usb_amradio_fops
;
700 radio
->videodev
->ioctl_ops
= &usb_amradio_ioctl_ops
;
701 radio
->videodev
->release
= usb_amradio_video_device_release
;
705 radio
->usbdev
= interface_to_usbdev(intf
);
706 radio
->curfreq
= 95.16 * FREQ_MUL
;
709 mutex_init(&radio
->lock
);
711 video_set_drvdata(radio
->videodev
, radio
);
713 retval
= video_register_device(radio
->videodev
, VFL_TYPE_RADIO
, radio_nr
);
715 dev_err(&intf
->dev
, "could not register video device\n");
716 video_device_release(radio
->videodev
);
717 v4l2_device_unregister(v4l2_dev
);
718 kfree(radio
->buffer
);
723 usb_set_intfdata(intf
, radio
);
727 static int __init
amradio_init(void)
729 int retval
= usb_register(&usb_amradio_driver
);
731 pr_info(KBUILD_MODNAME
732 ": version " DRIVER_VERSION
" " DRIVER_DESC
"\n");
735 pr_err(KBUILD_MODNAME
736 ": usb_register failed. Error number %d\n", retval
);
741 static void __exit
amradio_exit(void)
743 usb_deregister(&usb_amradio_driver
);
746 module_init(amradio_init
);
747 module_exit(amradio_exit
);