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.
48 * - Correct power managment of device (suspend & resume)
49 * - Add code for scanning and smooth tuning
50 * - Add code for sensitivity value
52 * - In Japan another FREQ_MIN and FREQ_MAX
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 */
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)
73 MODULE_AUTHOR(DRIVER_AUTHOR
);
74 MODULE_DESCRIPTION(DRIVER_DESC
);
75 MODULE_LICENSE("GPL");
77 #define USB_AMRADIO_VENDOR 0x07ca
78 #define USB_AMRADIO_PRODUCT 0xb800
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)
85 /* Probably USB_TIMEOUT should be modified in module parameter */
86 #define BUFFER_LENGTH 8
87 #define USB_TIMEOUT 500
89 /* Frequency limits in MHz -- these are European values. For Japanese
90 devices, that would be 76 and 91. */
92 #define FREQ_MAX 108.0
93 #define FREQ_MUL 16000
96 * Commands that device should understand
97 * List isnt full and will be updated with implementation of new functions
99 #define AMRADIO_SET_FREQ 0xa4
100 #define AMRADIO_SET_MUTE 0xab
101 #define AMRADIO_SET_MONO 0xae
103 /* Comfortable defines for amradio_set_mute */
104 #define AMRADIO_START 0x00
105 #define AMRADIO_STOP 0x01
107 /* Comfortable defines for amradio_set_stereo */
108 #define WANT_STEREO 0x00
109 #define WANT_MONO 0x01
111 /* module parameter */
112 static int radio_nr
= -1;
113 module_param(radio_nr
, int, 0);
114 MODULE_PARM_DESC(radio_nr
, "Radio Nr");
116 static struct v4l2_queryctrl radio_qctrl
[] = {
118 .id
= V4L2_CID_AUDIO_MUTE
,
124 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
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
,
131 .id
= V4L2_CID_AUDIO_BALANCE
,
132 .flags
= V4L2_CTRL_FLAG_DISABLED
,
135 .id
= V4L2_CID_AUDIO_BASS
,
136 .flags
= V4L2_CTRL_FLAG_DISABLED
,
139 .id
= V4L2_CID_AUDIO_TREBLE
,
140 .flags
= V4L2_CTRL_FLAG_DISABLED
,
143 .id
= V4L2_CID_AUDIO_LOUDNESS
,
144 .flags
= V4L2_CTRL_FLAG_DISABLED
,
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
);
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
;
163 unsigned char *buffer
;
164 struct mutex lock
; /* buffer locking */
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 */
179 MODULE_DEVICE_TABLE(usb
, usb_amradio_device_table
);
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,
193 /* switch on/off the radio. Send 8 bytes to device */
194 static int amradio_set_mute(struct amradio_device
*radio
, char argument
)
203 mutex_lock(&radio
->lock
);
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;
214 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
215 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
217 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
218 mutex_unlock(&radio
->lock
);
222 radio
->muted
= argument
;
224 mutex_unlock(&radio
->lock
);
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
)
234 unsigned short freq_send
= 0x10 + (freq
>> 3) / 25;
240 mutex_lock(&radio
->lock
);
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;
251 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
252 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
254 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
255 mutex_unlock(&radio
->lock
);
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;
268 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
269 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
271 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
272 mutex_unlock(&radio
->lock
);
276 mutex_unlock(&radio
->lock
);
281 static int amradio_set_stereo(struct amradio_device
*radio
, char argument
)
290 mutex_lock(&radio
->lock
);
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;
301 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
302 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
304 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
306 mutex_unlock(&radio
->lock
);
312 mutex_unlock(&radio
->lock
);
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.
322 static void usb_amradio_disconnect(struct usb_interface
*intf
)
324 struct amradio_device
*radio
= usb_get_intfdata(intf
);
326 mutex_lock(&radio
->lock
);
328 mutex_unlock(&radio
->lock
);
330 usb_set_intfdata(intf
, NULL
);
331 video_unregister_device(radio
->videodev
);
334 /* vidioc_querycap - query device capabilities */
335 static int vidioc_querycap(struct file
*file
, void *priv
,
336 struct v4l2_capability
*v
)
338 struct amradio_device
*radio
= video_drvdata(file
);
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
;
348 /* vidioc_g_tuner - get tuner attributes */
349 static int vidioc_g_tuner(struct file
*file
, void *priv
,
350 struct v4l2_tuner
*v
)
352 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
362 /* TODO: Add function which look is signal stereo or not
363 * amradio_getstat(radio);
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
370 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
372 amradio_dev_warn(&radio
->videodev
->dev
,
373 "set stereo failed\n");
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
;
382 v
->audmode
= V4L2_TUNER_MODE_STEREO
;
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 */
390 /* vidioc_s_tuner - set tuner attributes */
391 static int vidioc_s_tuner(struct file
*file
, void *priv
,
392 struct v4l2_tuner
*v
)
394 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
404 /* mono/stereo selector */
405 switch (v
->audmode
) {
406 case V4L2_TUNER_MODE_MONO
:
407 retval
= amradio_set_stereo(radio
, WANT_MONO
);
409 amradio_dev_warn(&radio
->videodev
->dev
,
410 "set mono failed\n");
412 case V4L2_TUNER_MODE_STEREO
:
413 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
415 amradio_dev_warn(&radio
->videodev
->dev
,
416 "set stereo failed\n");
425 /* vidioc_s_frequency - set tuner radio frequency */
426 static int vidioc_s_frequency(struct file
*file
, void *priv
,
427 struct v4l2_frequency
*f
)
429 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
436 mutex_lock(&radio
->lock
);
437 radio
->curfreq
= f
->frequency
;
438 mutex_unlock(&radio
->lock
);
440 retval
= amradio_setfreq(radio
, radio
->curfreq
);
442 amradio_dev_warn(&radio
->videodev
->dev
,
443 "set frequency failed\n");
447 /* vidioc_g_frequency - get tuner radio frequency */
448 static int vidioc_g_frequency(struct file
*file
, void *priv
,
449 struct v4l2_frequency
*f
)
451 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
457 f
->type
= V4L2_TUNER_RADIO
;
458 f
->frequency
= radio
->curfreq
;
462 /* vidioc_queryctrl - enumerate control items */
463 static int vidioc_queryctrl(struct file
*file
, void *priv
,
464 struct v4l2_queryctrl
*qc
)
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
));
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
)
481 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
488 case V4L2_CID_AUDIO_MUTE
:
489 ctrl
->value
= radio
->muted
;
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
)
499 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
507 case V4L2_CID_AUDIO_MUTE
:
509 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
511 amradio_dev_warn(&radio
->videodev
->dev
,
512 "amradio_stop failed\n");
516 retval
= amradio_set_mute(radio
, AMRADIO_START
);
518 amradio_dev_warn(&radio
->videodev
->dev
,
519 "amradio_start failed\n");
528 /* vidioc_g_audio - get audio attributes */
529 static int vidioc_g_audio(struct file
*file
, void *priv
,
530 struct v4l2_audio
*a
)
535 strcpy(a
->name
, "Radio");
536 a
->capability
= V4L2_AUDCAP_STEREO
;
540 /* vidioc_s_audio - set audio attributes */
541 static int vidioc_s_audio(struct file
*file
, void *priv
,
542 struct v4l2_audio
*a
)
549 /* vidioc_g_input - get input */
550 static int vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
556 /* vidioc_s_input - set input */
557 static int vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
564 /* open device - amradio_start() and amradio_setfreq() */
565 static int usb_amradio_open(struct file
*file
)
567 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
575 retval
= amradio_set_mute(radio
, AMRADIO_START
);
577 amradio_dev_warn(&radio
->videodev
->dev
,
578 "radio did not start up properly\n");
584 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
586 amradio_dev_warn(&radio
->videodev
->dev
,
587 "set stereo failed\n");
589 retval
= amradio_setfreq(radio
, radio
->curfreq
);
591 amradio_dev_warn(&radio
->videodev
->dev
,
592 "set frequency failed\n");
599 static int usb_amradio_close(struct file
*file
)
601 struct amradio_device
*radio
= video_get_drvdata(video_devdata(file
));
607 mutex_lock(&radio
->lock
);
609 mutex_unlock(&radio
->lock
);
611 if (!radio
->removed
) {
612 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
614 amradio_dev_warn(&radio
->videodev
->dev
,
615 "amradio_stop failed\n");
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
)
624 struct amradio_device
*radio
= usb_get_intfdata(intf
);
627 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
629 dev_warn(&intf
->dev
, "amradio_stop failed\n");
631 dev_info(&intf
->dev
, "going into suspend..\n");
636 /* Resume device - start device. Need to be checked and fixed */
637 static int usb_amradio_resume(struct usb_interface
*intf
)
639 struct amradio_device
*radio
= usb_get_intfdata(intf
);
642 retval
= amradio_set_mute(radio
, AMRADIO_START
);
644 dev_warn(&intf
->dev
, "amradio_start failed\n");
646 dev_info(&intf
->dev
, "coming out of suspend..\n");
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
,
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
,
674 static void usb_amradio_device_release(struct video_device
*videodev
)
676 struct amradio_device
*radio
= video_get_drvdata(videodev
);
678 /* we call v4l to free radio->videodev */
679 video_device_release(videodev
);
681 /* free rest memory */
682 kfree(radio
->buffer
);
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
,
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
)
698 struct amradio_device
*radio
;
701 radio
= kmalloc(sizeof(struct amradio_device
), GFP_KERNEL
);
704 dev_err(&intf
->dev
, "kmalloc for amradio_device failed\n");
708 radio
->buffer
= kmalloc(BUFFER_LENGTH
, GFP_KERNEL
);
710 if (!radio
->buffer
) {
711 dev_err(&intf
->dev
, "kmalloc for radio->buffer failed\n");
716 radio
->videodev
= video_device_alloc();
718 if (!radio
->videodev
) {
719 dev_err(&intf
->dev
, "video_device_alloc failed\n");
720 kfree(radio
->buffer
);
725 memcpy(radio
->videodev
, &amradio_videodev_template
,
726 sizeof(amradio_videodev_template
));
730 radio
->usbdev
= interface_to_usbdev(intf
);
731 radio
->curfreq
= 95.16 * FREQ_MUL
;
734 mutex_init(&radio
->lock
);
736 video_set_drvdata(radio
->videodev
, radio
);
737 retval
= video_register_device(radio
->videodev
, VFL_TYPE_RADIO
, radio_nr
);
739 dev_err(&intf
->dev
, "could not register video device\n");
740 video_device_release(radio
->videodev
);
741 kfree(radio
->buffer
);
746 usb_set_intfdata(intf
, radio
);
750 static int __init
amradio_init(void)
752 int retval
= usb_register(&usb_amradio_driver
);
754 pr_info(KBUILD_MODNAME
755 ": version " DRIVER_VERSION
" " DRIVER_DESC
"\n");
758 pr_err(KBUILD_MODNAME
759 ": usb_register failed. Error number %d\n", retval
);
764 static void __exit
amradio_exit(void)
766 usb_deregister(&usb_amradio_driver
);
769 module_init(amradio_init
);
770 module_exit(amradio_exit
);