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 through 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 usb_interface
*intf
;
136 struct video_device videodev
;
137 struct v4l2_device v4l2_dev
;
139 unsigned char *buffer
;
140 struct mutex lock
; /* buffer locking */
147 static inline struct amradio_device
*to_amradio_dev(struct v4l2_device
*v4l2_dev
)
149 return container_of(v4l2_dev
, struct amradio_device
, v4l2_dev
);
152 /* USB Device ID List */
153 static struct usb_device_id usb_amradio_device_table
[] = {
154 {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR
, USB_AMRADIO_PRODUCT
,
155 USB_CLASS_HID
, 0, 0) },
156 { } /* Terminating entry */
159 MODULE_DEVICE_TABLE(usb
, usb_amradio_device_table
);
161 /* USB subsystem interface */
162 static struct usb_driver usb_amradio_driver
= {
163 .name
= MR800_DRIVER_NAME
,
164 .probe
= usb_amradio_probe
,
165 .disconnect
= usb_amradio_disconnect
,
166 .suspend
= usb_amradio_suspend
,
167 .resume
= usb_amradio_resume
,
168 .reset_resume
= usb_amradio_resume
,
169 .id_table
= usb_amradio_device_table
,
170 .supports_autosuspend
= 1,
173 /* switch on/off the radio. Send 8 bytes to device */
174 static int amradio_set_mute(struct amradio_device
*radio
, char argument
)
179 BUG_ON(!mutex_is_locked(&radio
->lock
));
181 radio
->buffer
[0] = 0x00;
182 radio
->buffer
[1] = 0x55;
183 radio
->buffer
[2] = 0xaa;
184 radio
->buffer
[3] = 0x00;
185 radio
->buffer
[4] = AMRADIO_SET_MUTE
;
186 radio
->buffer
[5] = argument
;
187 radio
->buffer
[6] = 0x00;
188 radio
->buffer
[7] = 0x00;
190 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
191 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
193 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
194 amradio_dev_warn(&radio
->videodev
.dev
, "set mute failed\n");
198 radio
->muted
= argument
;
203 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
204 static int amradio_setfreq(struct amradio_device
*radio
, int freq
)
208 unsigned short freq_send
= 0x10 + (freq
>> 3) / 25;
210 BUG_ON(!mutex_is_locked(&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
)
227 /* frequency is calculated from freq_send and placed in first 2 bytes */
228 radio
->buffer
[0] = (freq_send
>> 8) & 0xff;
229 radio
->buffer
[1] = freq_send
& 0xff;
230 radio
->buffer
[2] = 0x01;
231 radio
->buffer
[3] = 0x00;
232 radio
->buffer
[4] = 0x00;
233 /* 5 and 6 bytes of buffer already = 0x00 */
234 radio
->buffer
[7] = 0x00;
236 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
237 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
239 if (retval
< 0 || size
!= BUFFER_LENGTH
)
242 radio
->curfreq
= freq
;
246 amradio_dev_warn(&radio
->videodev
.dev
, "set frequency failed\n");
251 static int amradio_set_stereo(struct amradio_device
*radio
, char argument
)
256 BUG_ON(!mutex_is_locked(&radio
->lock
));
258 radio
->buffer
[0] = 0x00;
259 radio
->buffer
[1] = 0x55;
260 radio
->buffer
[2] = 0xaa;
261 radio
->buffer
[3] = 0x00;
262 radio
->buffer
[4] = AMRADIO_SET_MONO
;
263 radio
->buffer
[5] = argument
;
264 radio
->buffer
[6] = 0x00;
265 radio
->buffer
[7] = 0x00;
267 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
268 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
270 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
271 amradio_dev_warn(&radio
->videodev
.dev
, "set stereo failed\n");
275 if (argument
== WANT_STEREO
)
283 /* Handle unplugging the device.
284 * We call video_unregister_device in any case.
285 * The last function called in this procedure is
286 * usb_amradio_device_release.
288 static void usb_amradio_disconnect(struct usb_interface
*intf
)
290 struct amradio_device
*radio
= to_amradio_dev(usb_get_intfdata(intf
));
292 mutex_lock(&radio
->lock
);
293 radio
->usbdev
= NULL
;
294 mutex_unlock(&radio
->lock
);
296 v4l2_device_disconnect(&radio
->v4l2_dev
);
297 video_unregister_device(&radio
->videodev
);
300 /* vidioc_querycap - query device capabilities */
301 static int vidioc_querycap(struct file
*file
, void *priv
,
302 struct v4l2_capability
*v
)
304 struct amradio_device
*radio
= file
->private_data
;
306 strlcpy(v
->driver
, "radio-mr800", sizeof(v
->driver
));
307 strlcpy(v
->card
, "AverMedia MR 800 USB FM Radio", sizeof(v
->card
));
308 usb_make_path(radio
->usbdev
, v
->bus_info
, sizeof(v
->bus_info
));
309 v
->version
= RADIO_VERSION
;
310 v
->capabilities
= V4L2_CAP_TUNER
;
314 /* vidioc_g_tuner - get tuner attributes */
315 static int vidioc_g_tuner(struct file
*file
, void *priv
,
316 struct v4l2_tuner
*v
)
318 struct amradio_device
*radio
= file
->private_data
;
324 /* TODO: Add function which look is signal stereo or not
325 * amradio_getstat(radio);
328 /* we call amradio_set_stereo to set radio->stereo
329 * Honestly, amradio_getstat should cover this in future and
330 * amradio_set_stereo shouldn't be here
332 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
334 strcpy(v
->name
, "FM");
335 v
->type
= V4L2_TUNER_RADIO
;
336 v
->rangelow
= FREQ_MIN
* FREQ_MUL
;
337 v
->rangehigh
= FREQ_MAX
* FREQ_MUL
;
338 v
->rxsubchans
= V4L2_TUNER_SUB_MONO
| V4L2_TUNER_SUB_STEREO
;
339 v
->capability
= V4L2_TUNER_CAP_LOW
;
341 v
->audmode
= V4L2_TUNER_MODE_STEREO
;
343 v
->audmode
= V4L2_TUNER_MODE_MONO
;
344 v
->signal
= 0xffff; /* Can't get the signal strength, sad.. */
345 v
->afc
= 0; /* Don't know what is this */
350 /* vidioc_s_tuner - set tuner attributes */
351 static int vidioc_s_tuner(struct file
*file
, void *priv
,
352 struct v4l2_tuner
*v
)
354 struct amradio_device
*radio
= file
->private_data
;
355 int retval
= -EINVAL
;
360 /* mono/stereo selector */
361 switch (v
->audmode
) {
362 case V4L2_TUNER_MODE_MONO
:
363 retval
= amradio_set_stereo(radio
, WANT_MONO
);
365 case V4L2_TUNER_MODE_STEREO
:
366 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
373 /* vidioc_s_frequency - set tuner radio frequency */
374 static int vidioc_s_frequency(struct file
*file
, void *priv
,
375 struct v4l2_frequency
*f
)
377 struct amradio_device
*radio
= file
->private_data
;
379 if (f
->tuner
!= 0 || f
->type
!= V4L2_TUNER_RADIO
)
381 return amradio_setfreq(radio
, f
->frequency
);
384 /* vidioc_g_frequency - get tuner radio frequency */
385 static int vidioc_g_frequency(struct file
*file
, void *priv
,
386 struct v4l2_frequency
*f
)
388 struct amradio_device
*radio
= file
->private_data
;
392 f
->type
= V4L2_TUNER_RADIO
;
393 f
->frequency
= radio
->curfreq
;
398 /* vidioc_queryctrl - enumerate control items */
399 static int vidioc_queryctrl(struct file
*file
, void *priv
,
400 struct v4l2_queryctrl
*qc
)
403 case V4L2_CID_AUDIO_MUTE
:
404 return v4l2_ctrl_query_fill(qc
, 0, 1, 1, 1);
410 /* vidioc_g_ctrl - get the value of a control */
411 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
412 struct v4l2_control
*ctrl
)
414 struct amradio_device
*radio
= file
->private_data
;
417 case V4L2_CID_AUDIO_MUTE
:
418 ctrl
->value
= radio
->muted
;
425 /* vidioc_s_ctrl - set the value of a control */
426 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
427 struct v4l2_control
*ctrl
)
429 struct amradio_device
*radio
= file
->private_data
;
430 int retval
= -EINVAL
;
433 case V4L2_CID_AUDIO_MUTE
:
435 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
437 retval
= amradio_set_mute(radio
, AMRADIO_START
);
445 /* vidioc_g_audio - get audio attributes */
446 static int vidioc_g_audio(struct file
*file
, void *priv
,
447 struct v4l2_audio
*a
)
452 strcpy(a
->name
, "Radio");
453 a
->capability
= V4L2_AUDCAP_STEREO
;
457 /* vidioc_s_audio - set audio attributes */
458 static int vidioc_s_audio(struct file
*file
, void *priv
,
459 struct v4l2_audio
*a
)
466 /* vidioc_g_input - get input */
467 static int vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
473 /* vidioc_s_input - set input */
474 static int vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
481 static int usb_amradio_init(struct amradio_device
*radio
)
485 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
489 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
493 radio
->initialized
= 1;
497 amradio_dev_err(&radio
->videodev
.dev
, "initialization failed\n");
502 /* open device - amradio_start() and amradio_setfreq() */
503 static int usb_amradio_open(struct file
*file
)
505 struct amradio_device
*radio
= video_drvdata(file
);
508 mutex_lock(&radio
->lock
);
510 if (!radio
->usbdev
) {
515 file
->private_data
= radio
;
516 retval
= usb_autopm_get_interface(radio
->intf
);
520 if (unlikely(!radio
->initialized
)) {
521 retval
= usb_amradio_init(radio
);
523 usb_autopm_put_interface(radio
->intf
);
527 mutex_unlock(&radio
->lock
);
532 static int usb_amradio_close(struct file
*file
)
534 struct amradio_device
*radio
= file
->private_data
;
537 mutex_lock(&radio
->lock
);
542 usb_autopm_put_interface(radio
->intf
);
544 mutex_unlock(&radio
->lock
);
548 static long usb_amradio_ioctl(struct file
*file
, unsigned int cmd
,
551 struct amradio_device
*radio
= file
->private_data
;
554 mutex_lock(&radio
->lock
);
556 if (!radio
->usbdev
) {
561 retval
= video_ioctl2(file
, cmd
, arg
);
564 mutex_unlock(&radio
->lock
);
568 /* Suspend device - stop device. Need to be checked and fixed */
569 static int usb_amradio_suspend(struct usb_interface
*intf
, pm_message_t message
)
571 struct amradio_device
*radio
= to_amradio_dev(usb_get_intfdata(intf
));
573 mutex_lock(&radio
->lock
);
575 if (!radio
->muted
&& radio
->initialized
) {
576 amradio_set_mute(radio
, AMRADIO_STOP
);
580 dev_info(&intf
->dev
, "going into suspend..\n");
582 mutex_unlock(&radio
->lock
);
586 /* Resume device - start device. Need to be checked and fixed */
587 static int usb_amradio_resume(struct usb_interface
*intf
)
589 struct amradio_device
*radio
= to_amradio_dev(usb_get_intfdata(intf
));
591 mutex_lock(&radio
->lock
);
593 if (unlikely(!radio
->initialized
))
597 amradio_set_stereo(radio
, WANT_STEREO
);
599 amradio_set_stereo(radio
, WANT_MONO
);
601 amradio_setfreq(radio
, radio
->curfreq
);
604 amradio_set_mute(radio
, AMRADIO_START
);
607 dev_info(&intf
->dev
, "coming out of suspend..\n");
609 mutex_unlock(&radio
->lock
);
613 /* File system interface */
614 static const struct v4l2_file_operations usb_amradio_fops
= {
615 .owner
= THIS_MODULE
,
616 .open
= usb_amradio_open
,
617 .release
= usb_amradio_close
,
618 .ioctl
= usb_amradio_ioctl
,
621 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops
= {
622 .vidioc_querycap
= vidioc_querycap
,
623 .vidioc_g_tuner
= vidioc_g_tuner
,
624 .vidioc_s_tuner
= vidioc_s_tuner
,
625 .vidioc_g_frequency
= vidioc_g_frequency
,
626 .vidioc_s_frequency
= vidioc_s_frequency
,
627 .vidioc_queryctrl
= vidioc_queryctrl
,
628 .vidioc_g_ctrl
= vidioc_g_ctrl
,
629 .vidioc_s_ctrl
= vidioc_s_ctrl
,
630 .vidioc_g_audio
= vidioc_g_audio
,
631 .vidioc_s_audio
= vidioc_s_audio
,
632 .vidioc_g_input
= vidioc_g_input
,
633 .vidioc_s_input
= vidioc_s_input
,
636 static void usb_amradio_video_device_release(struct video_device
*videodev
)
638 struct amradio_device
*radio
= video_get_drvdata(videodev
);
640 /* free rest memory */
641 kfree(radio
->buffer
);
645 /* check if the device is present and register with v4l and usb if it is */
646 static int usb_amradio_probe(struct usb_interface
*intf
,
647 const struct usb_device_id
*id
)
649 struct amradio_device
*radio
;
652 radio
= kzalloc(sizeof(struct amradio_device
), GFP_KERNEL
);
655 dev_err(&intf
->dev
, "kmalloc for amradio_device failed\n");
660 radio
->buffer
= kmalloc(BUFFER_LENGTH
, GFP_KERNEL
);
662 if (!radio
->buffer
) {
663 dev_err(&intf
->dev
, "kmalloc for radio->buffer failed\n");
668 retval
= v4l2_device_register(&intf
->dev
, &radio
->v4l2_dev
);
670 dev_err(&intf
->dev
, "couldn't register v4l2_device\n");
674 strlcpy(radio
->videodev
.name
, radio
->v4l2_dev
.name
,
675 sizeof(radio
->videodev
.name
));
676 radio
->videodev
.v4l2_dev
= &radio
->v4l2_dev
;
677 radio
->videodev
.fops
= &usb_amradio_fops
;
678 radio
->videodev
.ioctl_ops
= &usb_amradio_ioctl_ops
;
679 radio
->videodev
.release
= usb_amradio_video_device_release
;
681 radio
->usbdev
= interface_to_usbdev(intf
);
683 radio
->curfreq
= 95.16 * FREQ_MUL
;
685 mutex_init(&radio
->lock
);
687 video_set_drvdata(&radio
->videodev
, radio
);
689 retval
= video_register_device(&radio
->videodev
, VFL_TYPE_RADIO
,
692 dev_err(&intf
->dev
, "could not register video device\n");
699 v4l2_device_unregister(&radio
->v4l2_dev
);
701 kfree(radio
->buffer
);
708 static int __init
amradio_init(void)
710 int retval
= usb_register(&usb_amradio_driver
);
712 pr_info(KBUILD_MODNAME
713 ": version " DRIVER_VERSION
" " DRIVER_DESC
"\n");
716 pr_err(KBUILD_MODNAME
717 ": usb_register failed. Error number %d\n", retval
);
722 static void __exit
amradio_exit(void)
724 usb_deregister(&usb_amradio_driver
);
727 module_init(amradio_init
);
728 module_exit(amradio_exit
);