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 management 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/smp_lock.h>
62 #include <linux/input.h>
63 #include <linux/videodev2.h>
64 #include <media/v4l2-device.h>
65 #include <media/v4l2-ioctl.h>
66 #include <linux/usb.h>
67 #include <linux/version.h> /* for KERNEL_VERSION MACRO */
68 #include <linux/mutex.h>
70 /* driver and module definitions */
71 #define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@gmail.com>"
72 #define DRIVER_DESC "AverMedia MR 800 USB FM radio driver"
73 #define DRIVER_VERSION "0.11"
74 #define RADIO_VERSION KERNEL_VERSION(0, 1, 1)
76 MODULE_AUTHOR(DRIVER_AUTHOR
);
77 MODULE_DESCRIPTION(DRIVER_DESC
);
78 MODULE_LICENSE("GPL");
80 #define USB_AMRADIO_VENDOR 0x07ca
81 #define USB_AMRADIO_PRODUCT 0xb800
83 /* dev_warn macro with driver name */
84 #define MR800_DRIVER_NAME "radio-mr800"
85 #define amradio_dev_warn(dev, fmt, arg...) \
86 dev_warn(dev, MR800_DRIVER_NAME " - " fmt, ##arg)
88 #define amradio_dev_err(dev, fmt, arg...) \
89 dev_err(dev, MR800_DRIVER_NAME " - " fmt, ##arg)
91 /* Probably USB_TIMEOUT should be modified in module parameter */
92 #define BUFFER_LENGTH 8
93 #define USB_TIMEOUT 500
95 /* Frequency limits in MHz -- these are European values. For Japanese
96 devices, that would be 76 and 91. */
98 #define FREQ_MAX 108.0
99 #define FREQ_MUL 16000
102 * Commands that device should understand
103 * List isnt full and will be updated with implementation of new functions
105 #define AMRADIO_SET_FREQ 0xa4
106 #define AMRADIO_SET_MUTE 0xab
107 #define AMRADIO_SET_MONO 0xae
109 /* Comfortable defines for amradio_set_mute */
110 #define AMRADIO_START 0x00
111 #define AMRADIO_STOP 0x01
113 /* Comfortable defines for amradio_set_stereo */
114 #define WANT_STEREO 0x00
115 #define WANT_MONO 0x01
117 /* module parameter */
118 static int radio_nr
= -1;
119 module_param(radio_nr
, int, 0);
120 MODULE_PARM_DESC(radio_nr
, "Radio Nr");
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 file
*file
);
126 static int usb_amradio_close(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
);
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 struct v4l2_device v4l2_dev
;
138 unsigned char *buffer
;
139 struct mutex lock
; /* buffer locking */
146 #define vdev_to_amradio(r) container_of(r, struct amradio_device, videodev)
148 /* USB Device ID List */
149 static struct usb_device_id usb_amradio_device_table
[] = {
150 {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR
, USB_AMRADIO_PRODUCT
,
151 USB_CLASS_HID
, 0, 0) },
152 { } /* Terminating entry */
155 MODULE_DEVICE_TABLE(usb
, usb_amradio_device_table
);
157 /* USB subsystem interface */
158 static struct usb_driver usb_amradio_driver
= {
159 .name
= MR800_DRIVER_NAME
,
160 .probe
= usb_amradio_probe
,
161 .disconnect
= usb_amradio_disconnect
,
162 .suspend
= usb_amradio_suspend
,
163 .resume
= usb_amradio_resume
,
164 .reset_resume
= usb_amradio_resume
,
165 .id_table
= usb_amradio_device_table
,
166 .supports_autosuspend
= 0,
169 /* switch on/off the radio. Send 8 bytes to device */
170 static int amradio_set_mute(struct amradio_device
*radio
, char argument
)
175 BUG_ON(!mutex_is_locked(&radio
->lock
));
177 radio
->buffer
[0] = 0x00;
178 radio
->buffer
[1] = 0x55;
179 radio
->buffer
[2] = 0xaa;
180 radio
->buffer
[3] = 0x00;
181 radio
->buffer
[4] = AMRADIO_SET_MUTE
;
182 radio
->buffer
[5] = argument
;
183 radio
->buffer
[6] = 0x00;
184 radio
->buffer
[7] = 0x00;
186 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
187 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
189 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
190 amradio_dev_warn(&radio
->videodev
.dev
, "set mute failed\n");
194 radio
->muted
= argument
;
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;
206 BUG_ON(!mutex_is_locked(&radio
->lock
));
208 radio
->buffer
[0] = 0x00;
209 radio
->buffer
[1] = 0x55;
210 radio
->buffer
[2] = 0xaa;
211 radio
->buffer
[3] = 0x03;
212 radio
->buffer
[4] = AMRADIO_SET_FREQ
;
213 radio
->buffer
[5] = 0x00;
214 radio
->buffer
[6] = 0x00;
215 radio
->buffer
[7] = 0x08;
217 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
218 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
220 if (retval
< 0 || size
!= BUFFER_LENGTH
)
223 /* frequency is calculated from freq_send and placed in first 2 bytes */
224 radio
->buffer
[0] = (freq_send
>> 8) & 0xff;
225 radio
->buffer
[1] = freq_send
& 0xff;
226 radio
->buffer
[2] = 0x01;
227 radio
->buffer
[3] = 0x00;
228 radio
->buffer
[4] = 0x00;
229 /* 5 and 6 bytes of buffer already = 0x00 */
230 radio
->buffer
[7] = 0x00;
232 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
233 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
235 if (retval
< 0 || size
!= BUFFER_LENGTH
)
241 amradio_dev_warn(&radio
->videodev
.dev
, "set frequency failed\n");
246 static int amradio_set_stereo(struct amradio_device
*radio
, char argument
)
251 BUG_ON(!mutex_is_locked(&radio
->lock
));
253 radio
->buffer
[0] = 0x00;
254 radio
->buffer
[1] = 0x55;
255 radio
->buffer
[2] = 0xaa;
256 radio
->buffer
[3] = 0x00;
257 radio
->buffer
[4] = AMRADIO_SET_MONO
;
258 radio
->buffer
[5] = argument
;
259 radio
->buffer
[6] = 0x00;
260 radio
->buffer
[7] = 0x00;
262 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
263 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
265 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
266 amradio_dev_warn(&radio
->videodev
.dev
, "set stereo failed\n");
270 if (argument
== WANT_STEREO
)
278 /* Handle unplugging the device.
279 * We call video_unregister_device in any case.
280 * The last function called in this procedure is
281 * usb_amradio_device_release.
283 static void usb_amradio_disconnect(struct usb_interface
*intf
)
285 struct amradio_device
*radio
= usb_get_intfdata(intf
);
287 mutex_lock(&radio
->lock
);
288 radio
->usbdev
= NULL
;
289 mutex_unlock(&radio
->lock
);
291 usb_set_intfdata(intf
, NULL
);
292 v4l2_device_disconnect(&radio
->v4l2_dev
);
293 video_unregister_device(&radio
->videodev
);
296 /* vidioc_querycap - query device capabilities */
297 static int vidioc_querycap(struct file
*file
, void *priv
,
298 struct v4l2_capability
*v
)
300 struct amradio_device
*radio
= file
->private_data
;
302 strlcpy(v
->driver
, "radio-mr800", sizeof(v
->driver
));
303 strlcpy(v
->card
, "AverMedia MR 800 USB FM Radio", sizeof(v
->card
));
304 usb_make_path(radio
->usbdev
, v
->bus_info
, sizeof(v
->bus_info
));
305 v
->version
= RADIO_VERSION
;
306 v
->capabilities
= V4L2_CAP_TUNER
;
310 /* vidioc_g_tuner - get tuner attributes */
311 static int vidioc_g_tuner(struct file
*file
, void *priv
,
312 struct v4l2_tuner
*v
)
314 struct amradio_device
*radio
= file
->private_data
;
320 /* TODO: Add function which look is signal stereo or not
321 * amradio_getstat(radio);
324 /* we call amradio_set_stereo to set radio->stereo
325 * Honestly, amradio_getstat should cover this in future and
326 * amradio_set_stereo shouldn't be here
328 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
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
;
337 v
->audmode
= V4L2_TUNER_MODE_STEREO
;
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 */
346 /* vidioc_s_tuner - set tuner attributes */
347 static int vidioc_s_tuner(struct file
*file
, void *priv
,
348 struct v4l2_tuner
*v
)
350 struct amradio_device
*radio
= file
->private_data
;
351 int retval
= -EINVAL
;
356 /* mono/stereo selector */
357 switch (v
->audmode
) {
358 case V4L2_TUNER_MODE_MONO
:
359 retval
= amradio_set_stereo(radio
, WANT_MONO
);
361 case V4L2_TUNER_MODE_STEREO
:
362 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
369 /* vidioc_s_frequency - set tuner radio frequency */
370 static int vidioc_s_frequency(struct file
*file
, void *priv
,
371 struct v4l2_frequency
*f
)
373 struct amradio_device
*radio
= file
->private_data
;
376 radio
->curfreq
= f
->frequency
;
378 retval
= amradio_setfreq(radio
, radio
->curfreq
);
383 /* vidioc_g_frequency - get tuner radio frequency */
384 static int vidioc_g_frequency(struct file
*file
, void *priv
,
385 struct v4l2_frequency
*f
)
387 struct amradio_device
*radio
= file
->private_data
;
389 f
->type
= V4L2_TUNER_RADIO
;
390 f
->frequency
= radio
->curfreq
;
395 /* vidioc_queryctrl - enumerate control items */
396 static int vidioc_queryctrl(struct file
*file
, void *priv
,
397 struct v4l2_queryctrl
*qc
)
400 case V4L2_CID_AUDIO_MUTE
:
401 return v4l2_ctrl_query_fill(qc
, 0, 1, 1, 1);
407 /* vidioc_g_ctrl - get the value of a control */
408 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
409 struct v4l2_control
*ctrl
)
411 struct amradio_device
*radio
= file
->private_data
;
414 case V4L2_CID_AUDIO_MUTE
:
415 ctrl
->value
= radio
->muted
;
422 /* vidioc_s_ctrl - set the value of a control */
423 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
424 struct v4l2_control
*ctrl
)
426 struct amradio_device
*radio
= file
->private_data
;
427 int retval
= -EINVAL
;
430 case V4L2_CID_AUDIO_MUTE
:
432 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
434 retval
= amradio_set_mute(radio
, AMRADIO_START
);
442 /* vidioc_g_audio - get audio attributes */
443 static int vidioc_g_audio(struct file
*file
, void *priv
,
444 struct v4l2_audio
*a
)
449 strcpy(a
->name
, "Radio");
450 a
->capability
= V4L2_AUDCAP_STEREO
;
454 /* vidioc_s_audio - set audio attributes */
455 static int vidioc_s_audio(struct file
*file
, void *priv
,
456 struct v4l2_audio
*a
)
463 /* vidioc_g_input - get input */
464 static int vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
470 /* vidioc_s_input - set input */
471 static int vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
478 static int usb_amradio_init(struct amradio_device
*radio
)
482 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
486 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
490 radio
->initialized
= 1;
494 amradio_dev_err(&radio
->videodev
.dev
, "initialization failed\n");
499 /* open device - amradio_start() and amradio_setfreq() */
500 static int usb_amradio_open(struct file
*file
)
502 struct amradio_device
*radio
= vdev_to_amradio(video_devdata(file
));
505 mutex_lock(&radio
->lock
);
507 if (!radio
->usbdev
) {
512 file
->private_data
= radio
;
514 if (unlikely(!radio
->initialized
))
515 retval
= usb_amradio_init(radio
);
518 mutex_unlock(&radio
->lock
);
523 static int usb_amradio_close(struct file
*file
)
525 struct amradio_device
*radio
= file
->private_data
;
528 mutex_lock(&radio
->lock
);
533 mutex_unlock(&radio
->lock
);
537 static long usb_amradio_ioctl(struct file
*file
, unsigned int cmd
,
540 struct amradio_device
*radio
= file
->private_data
;
543 mutex_lock(&radio
->lock
);
545 if (!radio
->usbdev
) {
550 retval
= video_ioctl2(file
, cmd
, arg
);
553 mutex_unlock(&radio
->lock
);
557 /* Suspend device - stop device. Need to be checked and fixed */
558 static int usb_amradio_suspend(struct usb_interface
*intf
, pm_message_t message
)
560 struct amradio_device
*radio
= usb_get_intfdata(intf
);
562 mutex_lock(&radio
->lock
);
564 if (!radio
->muted
&& radio
->initialized
) {
565 amradio_set_mute(radio
, AMRADIO_STOP
);
569 dev_info(&intf
->dev
, "going into suspend..\n");
571 mutex_unlock(&radio
->lock
);
575 /* Resume device - start device. Need to be checked and fixed */
576 static int usb_amradio_resume(struct usb_interface
*intf
)
578 struct amradio_device
*radio
= usb_get_intfdata(intf
);
580 mutex_lock(&radio
->lock
);
582 if (unlikely(!radio
->initialized
))
586 amradio_set_stereo(radio
, WANT_STEREO
);
588 amradio_set_stereo(radio
, WANT_MONO
);
590 amradio_setfreq(radio
, radio
->curfreq
);
593 amradio_set_mute(radio
, AMRADIO_START
);
596 dev_info(&intf
->dev
, "coming out of suspend..\n");
598 mutex_unlock(&radio
->lock
);
602 /* File system interface */
603 static const struct v4l2_file_operations usb_amradio_fops
= {
604 .owner
= THIS_MODULE
,
605 .open
= usb_amradio_open
,
606 .release
= usb_amradio_close
,
607 .ioctl
= usb_amradio_ioctl
,
610 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops
= {
611 .vidioc_querycap
= vidioc_querycap
,
612 .vidioc_g_tuner
= vidioc_g_tuner
,
613 .vidioc_s_tuner
= vidioc_s_tuner
,
614 .vidioc_g_frequency
= vidioc_g_frequency
,
615 .vidioc_s_frequency
= vidioc_s_frequency
,
616 .vidioc_queryctrl
= vidioc_queryctrl
,
617 .vidioc_g_ctrl
= vidioc_g_ctrl
,
618 .vidioc_s_ctrl
= vidioc_s_ctrl
,
619 .vidioc_g_audio
= vidioc_g_audio
,
620 .vidioc_s_audio
= vidioc_s_audio
,
621 .vidioc_g_input
= vidioc_g_input
,
622 .vidioc_s_input
= vidioc_s_input
,
625 static void usb_amradio_video_device_release(struct video_device
*videodev
)
627 struct amradio_device
*radio
= vdev_to_amradio(videodev
);
629 v4l2_device_unregister(&radio
->v4l2_dev
);
631 /* free rest memory */
632 kfree(radio
->buffer
);
636 /* check if the device is present and register with v4l and usb if it is */
637 static int usb_amradio_probe(struct usb_interface
*intf
,
638 const struct usb_device_id
*id
)
640 struct amradio_device
*radio
;
643 radio
= kzalloc(sizeof(struct amradio_device
), GFP_KERNEL
);
646 dev_err(&intf
->dev
, "kmalloc for amradio_device failed\n");
651 radio
->buffer
= kmalloc(BUFFER_LENGTH
, GFP_KERNEL
);
653 if (!radio
->buffer
) {
654 dev_err(&intf
->dev
, "kmalloc for radio->buffer failed\n");
659 retval
= v4l2_device_register(&intf
->dev
, &radio
->v4l2_dev
);
661 dev_err(&intf
->dev
, "couldn't register v4l2_device\n");
665 strlcpy(radio
->videodev
.name
, radio
->v4l2_dev
.name
,
666 sizeof(radio
->videodev
.name
));
667 radio
->videodev
.v4l2_dev
= &radio
->v4l2_dev
;
668 radio
->videodev
.fops
= &usb_amradio_fops
;
669 radio
->videodev
.ioctl_ops
= &usb_amradio_ioctl_ops
;
670 radio
->videodev
.release
= usb_amradio_video_device_release
;
672 radio
->usbdev
= interface_to_usbdev(intf
);
673 radio
->curfreq
= 95.16 * FREQ_MUL
;
675 mutex_init(&radio
->lock
);
677 video_set_drvdata(&radio
->videodev
, radio
);
679 retval
= video_register_device(&radio
->videodev
, VFL_TYPE_RADIO
,
682 dev_err(&intf
->dev
, "could not register video device\n");
686 usb_set_intfdata(intf
, radio
);
690 v4l2_device_unregister(&radio
->v4l2_dev
);
692 kfree(radio
->buffer
);
699 static int __init
amradio_init(void)
701 int retval
= usb_register(&usb_amradio_driver
);
703 pr_info(KBUILD_MODNAME
704 ": version " DRIVER_VERSION
" " DRIVER_DESC
"\n");
707 pr_err(KBUILD_MODNAME
708 ": usb_register failed. Error number %d\n", retval
);
713 static void __exit
amradio_exit(void)
715 usb_deregister(&usb_amradio_driver
);
718 module_init(amradio_init
);
719 module_exit(amradio_exit
);