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 radio
->buffer
[0] = 0x00;
180 radio
->buffer
[1] = 0x55;
181 radio
->buffer
[2] = 0xaa;
182 radio
->buffer
[3] = 0x00;
183 radio
->buffer
[4] = AMRADIO_SET_MUTE
;
184 radio
->buffer
[5] = argument
;
185 radio
->buffer
[6] = 0x00;
186 radio
->buffer
[7] = 0x00;
188 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
189 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
191 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
192 amradio_dev_warn(&radio
->videodev
.dev
, "set mute failed\n");
196 radio
->muted
= argument
;
201 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
202 static int amradio_setfreq(struct amradio_device
*radio
, int freq
)
206 unsigned short freq_send
= 0x10 + (freq
>> 3) / 25;
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
)
238 radio
->curfreq
= freq
;
242 amradio_dev_warn(&radio
->videodev
.dev
, "set frequency failed\n");
247 static int amradio_set_stereo(struct amradio_device
*radio
, char argument
)
252 radio
->buffer
[0] = 0x00;
253 radio
->buffer
[1] = 0x55;
254 radio
->buffer
[2] = 0xaa;
255 radio
->buffer
[3] = 0x00;
256 radio
->buffer
[4] = AMRADIO_SET_MONO
;
257 radio
->buffer
[5] = argument
;
258 radio
->buffer
[6] = 0x00;
259 radio
->buffer
[7] = 0x00;
261 retval
= usb_bulk_msg(radio
->usbdev
, usb_sndintpipe(radio
->usbdev
, 2),
262 (void *) (radio
->buffer
), BUFFER_LENGTH
, &size
, USB_TIMEOUT
);
264 if (retval
< 0 || size
!= BUFFER_LENGTH
) {
265 amradio_dev_warn(&radio
->videodev
.dev
, "set stereo failed\n");
269 if (argument
== WANT_STEREO
)
277 /* Handle unplugging the device.
278 * We call video_unregister_device in any case.
279 * The last function called in this procedure is
280 * usb_amradio_device_release.
282 static void usb_amradio_disconnect(struct usb_interface
*intf
)
284 struct amradio_device
*radio
= to_amradio_dev(usb_get_intfdata(intf
));
286 mutex_lock(&radio
->lock
);
287 v4l2_device_disconnect(&radio
->v4l2_dev
);
288 mutex_unlock(&radio
->lock
);
289 video_unregister_device(&radio
->videodev
);
292 /* vidioc_querycap - query device capabilities */
293 static int vidioc_querycap(struct file
*file
, void *priv
,
294 struct v4l2_capability
*v
)
296 struct amradio_device
*radio
= file
->private_data
;
298 strlcpy(v
->driver
, "radio-mr800", sizeof(v
->driver
));
299 strlcpy(v
->card
, "AverMedia MR 800 USB FM Radio", sizeof(v
->card
));
300 usb_make_path(radio
->usbdev
, v
->bus_info
, sizeof(v
->bus_info
));
301 v
->version
= RADIO_VERSION
;
302 v
->capabilities
= V4L2_CAP_TUNER
;
306 /* vidioc_g_tuner - get tuner attributes */
307 static int vidioc_g_tuner(struct file
*file
, void *priv
,
308 struct v4l2_tuner
*v
)
310 struct amradio_device
*radio
= file
->private_data
;
316 /* TODO: Add function which look is signal stereo or not
317 * amradio_getstat(radio);
320 /* we call amradio_set_stereo to set radio->stereo
321 * Honestly, amradio_getstat should cover this in future and
322 * amradio_set_stereo shouldn't be here
324 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
326 strcpy(v
->name
, "FM");
327 v
->type
= V4L2_TUNER_RADIO
;
328 v
->rangelow
= FREQ_MIN
* FREQ_MUL
;
329 v
->rangehigh
= FREQ_MAX
* FREQ_MUL
;
330 v
->rxsubchans
= V4L2_TUNER_SUB_MONO
| V4L2_TUNER_SUB_STEREO
;
331 v
->capability
= V4L2_TUNER_CAP_LOW
;
333 v
->audmode
= V4L2_TUNER_MODE_STEREO
;
335 v
->audmode
= V4L2_TUNER_MODE_MONO
;
336 v
->signal
= 0xffff; /* Can't get the signal strength, sad.. */
337 v
->afc
= 0; /* Don't know what is this */
342 /* vidioc_s_tuner - set tuner attributes */
343 static int vidioc_s_tuner(struct file
*file
, void *priv
,
344 struct v4l2_tuner
*v
)
346 struct amradio_device
*radio
= file
->private_data
;
347 int retval
= -EINVAL
;
352 /* mono/stereo selector */
353 switch (v
->audmode
) {
354 case V4L2_TUNER_MODE_MONO
:
355 retval
= amradio_set_stereo(radio
, WANT_MONO
);
357 case V4L2_TUNER_MODE_STEREO
:
358 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
365 /* vidioc_s_frequency - set tuner radio frequency */
366 static int vidioc_s_frequency(struct file
*file
, void *priv
,
367 struct v4l2_frequency
*f
)
369 struct amradio_device
*radio
= file
->private_data
;
371 if (f
->tuner
!= 0 || f
->type
!= V4L2_TUNER_RADIO
)
373 return amradio_setfreq(radio
, f
->frequency
);
376 /* vidioc_g_frequency - get tuner radio frequency */
377 static int vidioc_g_frequency(struct file
*file
, void *priv
,
378 struct v4l2_frequency
*f
)
380 struct amradio_device
*radio
= file
->private_data
;
384 f
->type
= V4L2_TUNER_RADIO
;
385 f
->frequency
= radio
->curfreq
;
390 /* vidioc_queryctrl - enumerate control items */
391 static int vidioc_queryctrl(struct file
*file
, void *priv
,
392 struct v4l2_queryctrl
*qc
)
395 case V4L2_CID_AUDIO_MUTE
:
396 return v4l2_ctrl_query_fill(qc
, 0, 1, 1, 1);
402 /* vidioc_g_ctrl - get the value of a control */
403 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
404 struct v4l2_control
*ctrl
)
406 struct amradio_device
*radio
= file
->private_data
;
409 case V4L2_CID_AUDIO_MUTE
:
410 ctrl
->value
= radio
->muted
;
417 /* vidioc_s_ctrl - set the value of a control */
418 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
419 struct v4l2_control
*ctrl
)
421 struct amradio_device
*radio
= file
->private_data
;
422 int retval
= -EINVAL
;
425 case V4L2_CID_AUDIO_MUTE
:
427 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
429 retval
= amradio_set_mute(radio
, AMRADIO_START
);
437 /* vidioc_g_audio - get audio attributes */
438 static int vidioc_g_audio(struct file
*file
, void *priv
,
439 struct v4l2_audio
*a
)
444 strcpy(a
->name
, "Radio");
445 a
->capability
= V4L2_AUDCAP_STEREO
;
449 /* vidioc_s_audio - set audio attributes */
450 static int vidioc_s_audio(struct file
*file
, void *priv
,
451 struct v4l2_audio
*a
)
458 /* vidioc_g_input - get input */
459 static int vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
465 /* vidioc_s_input - set input */
466 static int vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
473 static int usb_amradio_init(struct amradio_device
*radio
)
477 retval
= amradio_set_mute(radio
, AMRADIO_STOP
);
481 retval
= amradio_set_stereo(radio
, WANT_STEREO
);
485 radio
->initialized
= 1;
489 amradio_dev_err(&radio
->videodev
.dev
, "initialization failed\n");
494 /* open device - amradio_start() and amradio_setfreq() */
495 static int usb_amradio_open(struct file
*file
)
497 struct amradio_device
*radio
= video_drvdata(file
);
500 file
->private_data
= radio
;
501 retval
= usb_autopm_get_interface(radio
->intf
);
505 if (unlikely(!radio
->initialized
)) {
506 retval
= usb_amradio_init(radio
);
508 usb_autopm_put_interface(radio
->intf
);
514 static int usb_amradio_close(struct file
*file
)
516 struct amradio_device
*radio
= file
->private_data
;
518 usb_autopm_put_interface(radio
->intf
);
522 /* Suspend device - stop device. Need to be checked and fixed */
523 static int usb_amradio_suspend(struct usb_interface
*intf
, pm_message_t message
)
525 struct amradio_device
*radio
= to_amradio_dev(usb_get_intfdata(intf
));
527 if (!radio
->muted
&& radio
->initialized
) {
528 amradio_set_mute(radio
, AMRADIO_STOP
);
532 dev_info(&intf
->dev
, "going into suspend..\n");
536 /* Resume device - start device. Need to be checked and fixed */
537 static int usb_amradio_resume(struct usb_interface
*intf
)
539 struct amradio_device
*radio
= to_amradio_dev(usb_get_intfdata(intf
));
541 if (unlikely(!radio
->initialized
))
545 amradio_set_stereo(radio
, WANT_STEREO
);
547 amradio_set_stereo(radio
, WANT_MONO
);
549 amradio_setfreq(radio
, radio
->curfreq
);
552 amradio_set_mute(radio
, AMRADIO_START
);
554 dev_info(&intf
->dev
, "coming out of suspend..\n");
558 /* File system interface */
559 static const struct v4l2_file_operations usb_amradio_fops
= {
560 .owner
= THIS_MODULE
,
561 .open
= usb_amradio_open
,
562 .release
= usb_amradio_close
,
563 .unlocked_ioctl
= video_ioctl2
,
566 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops
= {
567 .vidioc_querycap
= vidioc_querycap
,
568 .vidioc_g_tuner
= vidioc_g_tuner
,
569 .vidioc_s_tuner
= vidioc_s_tuner
,
570 .vidioc_g_frequency
= vidioc_g_frequency
,
571 .vidioc_s_frequency
= vidioc_s_frequency
,
572 .vidioc_queryctrl
= vidioc_queryctrl
,
573 .vidioc_g_ctrl
= vidioc_g_ctrl
,
574 .vidioc_s_ctrl
= vidioc_s_ctrl
,
575 .vidioc_g_audio
= vidioc_g_audio
,
576 .vidioc_s_audio
= vidioc_s_audio
,
577 .vidioc_g_input
= vidioc_g_input
,
578 .vidioc_s_input
= vidioc_s_input
,
581 static void usb_amradio_video_device_release(struct video_device
*videodev
)
583 struct amradio_device
*radio
= video_get_drvdata(videodev
);
585 /* free rest memory */
586 kfree(radio
->buffer
);
590 /* check if the device is present and register with v4l and usb if it is */
591 static int usb_amradio_probe(struct usb_interface
*intf
,
592 const struct usb_device_id
*id
)
594 struct amradio_device
*radio
;
597 radio
= kzalloc(sizeof(struct amradio_device
), GFP_KERNEL
);
600 dev_err(&intf
->dev
, "kmalloc for amradio_device failed\n");
605 radio
->buffer
= kmalloc(BUFFER_LENGTH
, GFP_KERNEL
);
607 if (!radio
->buffer
) {
608 dev_err(&intf
->dev
, "kmalloc for radio->buffer failed\n");
613 retval
= v4l2_device_register(&intf
->dev
, &radio
->v4l2_dev
);
615 dev_err(&intf
->dev
, "couldn't register v4l2_device\n");
619 mutex_init(&radio
->lock
);
621 strlcpy(radio
->videodev
.name
, radio
->v4l2_dev
.name
,
622 sizeof(radio
->videodev
.name
));
623 radio
->videodev
.v4l2_dev
= &radio
->v4l2_dev
;
624 radio
->videodev
.fops
= &usb_amradio_fops
;
625 radio
->videodev
.ioctl_ops
= &usb_amradio_ioctl_ops
;
626 radio
->videodev
.release
= usb_amradio_video_device_release
;
627 radio
->videodev
.lock
= &radio
->lock
;
629 radio
->usbdev
= interface_to_usbdev(intf
);
631 radio
->curfreq
= 95.16 * FREQ_MUL
;
633 video_set_drvdata(&radio
->videodev
, radio
);
635 retval
= video_register_device(&radio
->videodev
, VFL_TYPE_RADIO
,
638 dev_err(&intf
->dev
, "could not register video device\n");
645 v4l2_device_unregister(&radio
->v4l2_dev
);
647 kfree(radio
->buffer
);
654 static int __init
amradio_init(void)
656 int retval
= usb_register(&usb_amradio_driver
);
658 pr_info(KBUILD_MODNAME
659 ": version " DRIVER_VERSION
" " DRIVER_DESC
"\n");
662 pr_err(KBUILD_MODNAME
663 ": usb_register failed. Error number %d\n", retval
);
668 static void __exit
amradio_exit(void)
670 usb_deregister(&usb_amradio_driver
);
673 module_init(amradio_init
);
674 module_exit(amradio_exit
);