1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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>
68#include <linux/mutex.h>
69
70
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)
75
76MODULE_AUTHOR(DRIVER_AUTHOR);
77MODULE_DESCRIPTION(DRIVER_DESC);
78MODULE_LICENSE("GPL");
79
80#define USB_AMRADIO_VENDOR 0x07ca
81#define USB_AMRADIO_PRODUCT 0xb800
82
83
84#define MR800_DRIVER_NAME "radio-mr800"
85#define amradio_dev_warn(dev, fmt, arg...) \
86 dev_warn(dev, MR800_DRIVER_NAME " - " fmt, ##arg)
87
88
89#define BUFFER_LENGTH 8
90#define USB_TIMEOUT 500
91
92
93
94#define FREQ_MIN 87.5
95#define FREQ_MAX 108.0
96#define FREQ_MUL 16000
97
98
99
100
101
102#define AMRADIO_SET_FREQ 0xa4
103#define AMRADIO_SET_MUTE 0xab
104#define AMRADIO_SET_MONO 0xae
105
106
107#define AMRADIO_START 0x00
108#define AMRADIO_STOP 0x01
109
110
111#define WANT_STEREO 0x00
112#define WANT_MONO 0x01
113
114
115static int radio_nr = -1;
116module_param(radio_nr, int, 0);
117MODULE_PARM_DESC(radio_nr, "Radio Nr");
118
119static int usb_amradio_probe(struct usb_interface *intf,
120 const struct usb_device_id *id);
121static void usb_amradio_disconnect(struct usb_interface *intf);
122static int usb_amradio_open(struct file *file);
123static int usb_amradio_close(struct file *file);
124static int usb_amradio_suspend(struct usb_interface *intf,
125 pm_message_t message);
126static int usb_amradio_resume(struct usb_interface *intf);
127
128
129struct amradio_device {
130
131 struct usb_device *usbdev;
132 struct video_device *videodev;
133 struct v4l2_device v4l2_dev;
134
135 unsigned char *buffer;
136 struct mutex lock;
137 int curfreq;
138 int stereo;
139 int users;
140 int removed;
141 int muted;
142};
143
144
145static struct usb_device_id usb_amradio_device_table[] = {
146 {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR, USB_AMRADIO_PRODUCT,
147 USB_CLASS_HID, 0, 0) },
148 { }
149};
150
151MODULE_DEVICE_TABLE(usb, usb_amradio_device_table);
152
153
154static struct usb_driver usb_amradio_driver = {
155 .name = MR800_DRIVER_NAME,
156 .probe = usb_amradio_probe,
157 .disconnect = usb_amradio_disconnect,
158 .suspend = usb_amradio_suspend,
159 .resume = usb_amradio_resume,
160 .reset_resume = usb_amradio_resume,
161 .id_table = usb_amradio_device_table,
162 .supports_autosuspend = 0,
163};
164
165
166static int amradio_set_mute(struct amradio_device *radio, char argument)
167{
168 int retval;
169 int size;
170
171
172 if (radio->removed)
173 return -EIO;
174
175 mutex_lock(&radio->lock);
176
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;
185
186 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
187 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
188
189 if (retval < 0 || size != BUFFER_LENGTH) {
190 mutex_unlock(&radio->lock);
191 return retval;
192 }
193
194 radio->muted = argument;
195
196 mutex_unlock(&radio->lock);
197
198 return retval;
199}
200
201
202static int amradio_setfreq(struct amradio_device *radio, int freq)
203{
204 int retval;
205 int size;
206 unsigned short freq_send = 0x10 + (freq >> 3) / 25;
207
208
209 if (radio->removed)
210 return -EIO;
211
212 mutex_lock(&radio->lock);
213
214 radio->buffer[0] = 0x00;
215 radio->buffer[1] = 0x55;
216 radio->buffer[2] = 0xaa;
217 radio->buffer[3] = 0x03;
218 radio->buffer[4] = AMRADIO_SET_FREQ;
219 radio->buffer[5] = 0x00;
220 radio->buffer[6] = 0x00;
221 radio->buffer[7] = 0x08;
222
223 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
224 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
225
226 if (retval < 0 || size != BUFFER_LENGTH) {
227 mutex_unlock(&radio->lock);
228 return retval;
229 }
230
231
232 radio->buffer[0] = (freq_send >> 8) & 0xff;
233 radio->buffer[1] = freq_send & 0xff;
234 radio->buffer[2] = 0x01;
235 radio->buffer[3] = 0x00;
236 radio->buffer[4] = 0x00;
237
238 radio->buffer[7] = 0x00;
239
240 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
241 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
242
243 if (retval < 0 || size != BUFFER_LENGTH) {
244 mutex_unlock(&radio->lock);
245 return retval;
246 }
247
248 mutex_unlock(&radio->lock);
249
250 return retval;
251}
252
253static int amradio_set_stereo(struct amradio_device *radio, char argument)
254{
255 int retval;
256 int size;
257
258
259 if (radio->removed)
260 return -EIO;
261
262 mutex_lock(&radio->lock);
263
264 radio->buffer[0] = 0x00;
265 radio->buffer[1] = 0x55;
266 radio->buffer[2] = 0xaa;
267 radio->buffer[3] = 0x00;
268 radio->buffer[4] = AMRADIO_SET_MONO;
269 radio->buffer[5] = argument;
270 radio->buffer[6] = 0x00;
271 radio->buffer[7] = 0x00;
272
273 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2),
274 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT);
275
276 if (retval < 0 || size != BUFFER_LENGTH) {
277 radio->stereo = -1;
278 mutex_unlock(&radio->lock);
279 return retval;
280 }
281
282 radio->stereo = 1;
283
284 mutex_unlock(&radio->lock);
285
286 return retval;
287}
288
289
290
291
292
293
294static void usb_amradio_disconnect(struct usb_interface *intf)
295{
296 struct amradio_device *radio = usb_get_intfdata(intf);
297
298 mutex_lock(&radio->lock);
299 radio->removed = 1;
300 mutex_unlock(&radio->lock);
301
302 usb_set_intfdata(intf, NULL);
303 video_unregister_device(radio->videodev);
304 v4l2_device_disconnect(&radio->v4l2_dev);
305}
306
307
308static int vidioc_querycap(struct file *file, void *priv,
309 struct v4l2_capability *v)
310{
311 struct amradio_device *radio = video_drvdata(file);
312
313 strlcpy(v->driver, "radio-mr800", sizeof(v->driver));
314 strlcpy(v->card, "AverMedia MR 800 USB FM Radio", sizeof(v->card));
315 usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
316 v->version = RADIO_VERSION;
317 v->capabilities = V4L2_CAP_TUNER;
318 return 0;
319}
320
321
322static int vidioc_g_tuner(struct file *file, void *priv,
323 struct v4l2_tuner *v)
324{
325 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
326 int retval;
327
328
329 if (radio->removed)
330 return -EIO;
331
332 if (v->index > 0)
333 return -EINVAL;
334
335
336
337
338
339
340
341
342
343 retval = amradio_set_stereo(radio, WANT_STEREO);
344 if (retval < 0)
345 amradio_dev_warn(&radio->videodev->dev,
346 "set stereo failed\n");
347
348 strcpy(v->name, "FM");
349 v->type = V4L2_TUNER_RADIO;
350 v->rangelow = FREQ_MIN * FREQ_MUL;
351 v->rangehigh = FREQ_MAX * FREQ_MUL;
352 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
353 v->capability = V4L2_TUNER_CAP_LOW;
354 if (radio->stereo)
355 v->audmode = V4L2_TUNER_MODE_STEREO;
356 else
357 v->audmode = V4L2_TUNER_MODE_MONO;
358 v->signal = 0xffff;
359 v->afc = 0;
360 return 0;
361}
362
363
364static int vidioc_s_tuner(struct file *file, void *priv,
365 struct v4l2_tuner *v)
366{
367 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
368 int retval;
369
370
371 if (radio->removed)
372 return -EIO;
373
374 if (v->index > 0)
375 return -EINVAL;
376
377
378 switch (v->audmode) {
379 case V4L2_TUNER_MODE_MONO:
380 retval = amradio_set_stereo(radio, WANT_MONO);
381 if (retval < 0)
382 amradio_dev_warn(&radio->videodev->dev,
383 "set mono failed\n");
384 break;
385 case V4L2_TUNER_MODE_STEREO:
386 retval = amradio_set_stereo(radio, WANT_STEREO);
387 if (retval < 0)
388 amradio_dev_warn(&radio->videodev->dev,
389 "set stereo failed\n");
390 break;
391 default:
392 return -EINVAL;
393 }
394
395 return 0;
396}
397
398
399static int vidioc_s_frequency(struct file *file, void *priv,
400 struct v4l2_frequency *f)
401{
402 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
403 int retval;
404
405
406 if (radio->removed)
407 return -EIO;
408
409 mutex_lock(&radio->lock);
410 radio->curfreq = f->frequency;
411 mutex_unlock(&radio->lock);
412
413 retval = amradio_setfreq(radio, radio->curfreq);
414 if (retval < 0)
415 amradio_dev_warn(&radio->videodev->dev,
416 "set frequency failed\n");
417 return 0;
418}
419
420
421static int vidioc_g_frequency(struct file *file, void *priv,
422 struct v4l2_frequency *f)
423{
424 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
425
426
427 if (radio->removed)
428 return -EIO;
429
430 f->type = V4L2_TUNER_RADIO;
431 f->frequency = radio->curfreq;
432 return 0;
433}
434
435
436static int vidioc_queryctrl(struct file *file, void *priv,
437 struct v4l2_queryctrl *qc)
438{
439 switch (qc->id) {
440 case V4L2_CID_AUDIO_MUTE:
441 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
442 }
443
444 return -EINVAL;
445}
446
447
448static int vidioc_g_ctrl(struct file *file, void *priv,
449 struct v4l2_control *ctrl)
450{
451 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
452
453
454 if (radio->removed)
455 return -EIO;
456
457 switch (ctrl->id) {
458 case V4L2_CID_AUDIO_MUTE:
459 ctrl->value = radio->muted;
460 return 0;
461 }
462 return -EINVAL;
463}
464
465
466static int vidioc_s_ctrl(struct file *file, void *priv,
467 struct v4l2_control *ctrl)
468{
469 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
470 int retval;
471
472
473 if (radio->removed)
474 return -EIO;
475
476 switch (ctrl->id) {
477 case V4L2_CID_AUDIO_MUTE:
478 if (ctrl->value) {
479 retval = amradio_set_mute(radio, AMRADIO_STOP);
480 if (retval < 0) {
481 amradio_dev_warn(&radio->videodev->dev,
482 "amradio_stop failed\n");
483 return -1;
484 }
485 } else {
486 retval = amradio_set_mute(radio, AMRADIO_START);
487 if (retval < 0) {
488 amradio_dev_warn(&radio->videodev->dev,
489 "amradio_start failed\n");
490 return -1;
491 }
492 }
493 return 0;
494 }
495 return -EINVAL;
496}
497
498
499static int vidioc_g_audio(struct file *file, void *priv,
500 struct v4l2_audio *a)
501{
502 if (a->index > 1)
503 return -EINVAL;
504
505 strcpy(a->name, "Radio");
506 a->capability = V4L2_AUDCAP_STEREO;
507 return 0;
508}
509
510
511static int vidioc_s_audio(struct file *file, void *priv,
512 struct v4l2_audio *a)
513{
514 if (a->index != 0)
515 return -EINVAL;
516 return 0;
517}
518
519
520static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
521{
522 *i = 0;
523 return 0;
524}
525
526
527static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
528{
529 if (i != 0)
530 return -EINVAL;
531 return 0;
532}
533
534
535static int usb_amradio_open(struct file *file)
536{
537 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
538 int retval;
539
540 lock_kernel();
541
542 radio->users = 1;
543 radio->muted = 1;
544
545 retval = amradio_set_mute(radio, AMRADIO_START);
546 if (retval < 0) {
547 amradio_dev_warn(&radio->videodev->dev,
548 "radio did not start up properly\n");
549 radio->users = 0;
550 unlock_kernel();
551 return -EIO;
552 }
553
554 retval = amradio_set_stereo(radio, WANT_STEREO);
555 if (retval < 0)
556 amradio_dev_warn(&radio->videodev->dev,
557 "set stereo failed\n");
558
559 retval = amradio_setfreq(radio, radio->curfreq);
560 if (retval < 0)
561 amradio_dev_warn(&radio->videodev->dev,
562 "set frequency failed\n");
563
564 unlock_kernel();
565 return 0;
566}
567
568
569static int usb_amradio_close(struct file *file)
570{
571 struct amradio_device *radio = video_get_drvdata(video_devdata(file));
572 int retval;
573
574 if (!radio)
575 return -ENODEV;
576
577 mutex_lock(&radio->lock);
578 radio->users = 0;
579 mutex_unlock(&radio->lock);
580
581 if (!radio->removed) {
582 retval = amradio_set_mute(radio, AMRADIO_STOP);
583 if (retval < 0)
584 amradio_dev_warn(&radio->videodev->dev,
585 "amradio_stop failed\n");
586 }
587
588 return 0;
589}
590
591
592static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message)
593{
594 struct amradio_device *radio = usb_get_intfdata(intf);
595 int retval;
596
597 retval = amradio_set_mute(radio, AMRADIO_STOP);
598 if (retval < 0)
599 dev_warn(&intf->dev, "amradio_stop failed\n");
600
601 dev_info(&intf->dev, "going into suspend..\n");
602
603 return 0;
604}
605
606
607static int usb_amradio_resume(struct usb_interface *intf)
608{
609 struct amradio_device *radio = usb_get_intfdata(intf);
610 int retval;
611
612 retval = amradio_set_mute(radio, AMRADIO_START);
613 if (retval < 0)
614 dev_warn(&intf->dev, "amradio_start failed\n");
615
616 dev_info(&intf->dev, "coming out of suspend..\n");
617
618 return 0;
619}
620
621
622static const struct v4l2_file_operations usb_amradio_fops = {
623 .owner = THIS_MODULE,
624 .open = usb_amradio_open,
625 .release = usb_amradio_close,
626 .ioctl = video_ioctl2,
627};
628
629static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
630 .vidioc_querycap = vidioc_querycap,
631 .vidioc_g_tuner = vidioc_g_tuner,
632 .vidioc_s_tuner = vidioc_s_tuner,
633 .vidioc_g_frequency = vidioc_g_frequency,
634 .vidioc_s_frequency = vidioc_s_frequency,
635 .vidioc_queryctrl = vidioc_queryctrl,
636 .vidioc_g_ctrl = vidioc_g_ctrl,
637 .vidioc_s_ctrl = vidioc_s_ctrl,
638 .vidioc_g_audio = vidioc_g_audio,
639 .vidioc_s_audio = vidioc_s_audio,
640 .vidioc_g_input = vidioc_g_input,
641 .vidioc_s_input = vidioc_s_input,
642};
643
644static void usb_amradio_video_device_release(struct video_device *videodev)
645{
646 struct amradio_device *radio = video_get_drvdata(videodev);
647
648
649 video_device_release(videodev);
650
651 v4l2_device_unregister(&radio->v4l2_dev);
652
653
654 kfree(radio->buffer);
655 kfree(radio);
656}
657
658
659static int usb_amradio_probe(struct usb_interface *intf,
660 const struct usb_device_id *id)
661{
662 struct amradio_device *radio;
663 struct v4l2_device *v4l2_dev;
664 int retval;
665
666 radio = kzalloc(sizeof(struct amradio_device), GFP_KERNEL);
667
668 if (!radio) {
669 dev_err(&intf->dev, "kmalloc for amradio_device failed\n");
670 return -ENOMEM;
671 }
672
673 radio->buffer = kmalloc(BUFFER_LENGTH, GFP_KERNEL);
674
675 if (!radio->buffer) {
676 dev_err(&intf->dev, "kmalloc for radio->buffer failed\n");
677 kfree(radio);
678 return -ENOMEM;
679 }
680
681 v4l2_dev = &radio->v4l2_dev;
682 retval = v4l2_device_register(&intf->dev, v4l2_dev);
683 if (retval < 0) {
684 dev_err(&intf->dev, "couldn't register v4l2_device\n");
685 kfree(radio->buffer);
686 kfree(radio);
687 return retval;
688 }
689
690 radio->videodev = video_device_alloc();
691
692 if (!radio->videodev) {
693 dev_err(&intf->dev, "video_device_alloc failed\n");
694 kfree(radio->buffer);
695 kfree(radio);
696 return -ENOMEM;
697 }
698
699 strlcpy(radio->videodev->name, v4l2_dev->name, sizeof(radio->videodev->name));
700 radio->videodev->v4l2_dev = v4l2_dev;
701 radio->videodev->fops = &usb_amradio_fops;
702 radio->videodev->ioctl_ops = &usb_amradio_ioctl_ops;
703 radio->videodev->release = usb_amradio_video_device_release;
704
705 radio->removed = 0;
706 radio->users = 0;
707 radio->usbdev = interface_to_usbdev(intf);
708 radio->curfreq = 95.16 * FREQ_MUL;
709 radio->stereo = -1;
710
711 mutex_init(&radio->lock);
712
713 video_set_drvdata(radio->videodev, radio);
714
715 retval = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr);
716 if (retval < 0) {
717 dev_err(&intf->dev, "could not register video device\n");
718 video_device_release(radio->videodev);
719 v4l2_device_unregister(v4l2_dev);
720 kfree(radio->buffer);
721 kfree(radio);
722 return -EIO;
723 }
724
725 usb_set_intfdata(intf, radio);
726 return 0;
727}
728
729static int __init amradio_init(void)
730{
731 int retval = usb_register(&usb_amradio_driver);
732
733 pr_info(KBUILD_MODNAME
734 ": version " DRIVER_VERSION " " DRIVER_DESC "\n");
735
736 if (retval)
737 pr_err(KBUILD_MODNAME
738 ": usb_register failed. Error number %d\n", retval);
739
740 return retval;
741}
742
743static void __exit amradio_exit(void)
744{
745 usb_deregister(&usb_amradio_driver);
746}
747
748module_init(amradio_init);
749module_exit(amradio_exit);
750
751