1 /*
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.
6 *
7 * Copyright (c) 2008 Alexey Klimov <klimov.linux@gmail.com>
8 *
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.
13 *
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.
18 *
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
22 */
23
24 /*
25 * Big thanks to authors and contributors of dsbr100.c and radio-si470x.c
26 *
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
36 *
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.
47 *
48 * Many things to do:
49 * - Correct power managment of device (suspend & resume)
50 * - Add code for scanning and smooth tuning
51 * - Add code for sensitivity value
52 * - Correct mistakes
53 * - In Japan another FREQ_MIN and FREQ_MAX
54 */
55
56 /* kernel includes */
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>
69
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)
75
76 MODULE_AUTHOR(DRIVER_AUTHOR);
77 MODULE_DESCRIPTION(DRIVER_DESC);
78 MODULE_LICENSE("GPL");
79
80 #define USB_AMRADIO_VENDOR 0x07ca
81 #define USB_AMRADIO_PRODUCT 0xb800
82
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)
87
88 /* Probably USB_TIMEOUT should be modified in module parameter */
89 #define BUFFER_LENGTH 8
90 #define USB_TIMEOUT 500
91
92 /* Frequency limits in MHz -- these are European values. For Japanese
93 devices, that would be 76 and 91. */
94 #define FREQ_MIN 87.5
95 #define FREQ_MAX 108.0
96 #define FREQ_MUL 16000
97
98 /*
99 * Commands that device should understand
100 * List isnt full and will be updated with implementation of new functions
101 */
102 #define AMRADIO_SET_FREQ 0xa4
103 #define AMRADIO_SET_MUTE 0xab
104 #define AMRADIO_SET_MONO 0xae
105
106 /* Comfortable defines for amradio_set_mute */
107 #define AMRADIO_START 0x00
108 #define AMRADIO_STOP 0x01
109
110 /* Comfortable defines for amradio_set_stereo */
111 #define WANT_STEREO 0x00
112 #define WANT_MONO 0x01
113
114 /* module parameter */
115 static int radio_nr = -1;
116 module_param(radio_nr, int, 0);
117 MODULE_PARM_DESC(radio_nr, "Radio Nr");
118
119 static int usb_amradio_probe(struct usb_interface *intf,
120 const struct usb_device_id *id);
121 static void usb_amradio_disconnect(struct usb_interface *intf);
122 static int usb_amradio_open(struct file *file);
123 static int usb_amradio_close(struct file *file);
124 static int usb_amradio_suspend(struct usb_interface *intf,
125 pm_message_t message);
126 static int usb_amradio_resume(struct usb_interface *intf);
127
128 /* Data for one (physical) device */
129 struct amradio_device {
130 /* reference to USB and video device */
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; /* buffer locking */
137 int curfreq;
138 int stereo;
139 int users;
140 int removed;
141 int muted;
142 };
143
144 /* USB Device ID List */
145 static 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 { } /* Terminating entry */
149 };
150
151 MODULE_DEVICE_TABLE(usb, usb_amradio_device_table);
152
153 /* USB subsystem interface */
154 static 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 /* switch on/off the radio. Send 8 bytes to device */
166 static int amradio_set_mute(struct amradio_device *radio, char argument)
167 {
168 int retval;
169 int size;
170
171 /* safety check */
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 /* 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)
203 {
204 int retval;
205 int size;
206 unsigned short freq_send = 0x10 + (freq >> 3) / 25;
207
208 /* safety check */
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 /* frequency is calculated from freq_send and placed in first 2 bytes */
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 /* 5 and 6 bytes of buffer already = 0x00 */
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
253 static int amradio_set_stereo(struct amradio_device *radio, char argument)
254 {
255 int retval;
256 int size;
257
258 /* safety check */
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 /* Handle unplugging the device.
290 * We call video_unregister_device in any case.
291 * The last function called in this procedure is
292 * usb_amradio_device_release.
293 */
294 static 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 /* vidioc_querycap - query device capabilities */
308 static 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 /* vidioc_g_tuner - get tuner attributes */
322 static 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 /* safety check */
329 if (radio->removed)
330 return -EIO;
331
332 if (v->index > 0)
333 return -EINVAL;
334
335 /* TODO: Add function which look is signal stereo or not
336 * amradio_getstat(radio);
337 */
338
339 /* we call amradio_set_stereo to set radio->stereo
340 * Honestly, amradio_getstat should cover this in future and
341 * amradio_set_stereo shouldn't be here
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; /* Can't get the signal strength, sad.. */
359 v->afc = 0; /* Don't know what is this */
360 return 0;
361 }
362
363 /* vidioc_s_tuner - set tuner attributes */
364 static 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 /* safety check */
371 if (radio->removed)
372 return -EIO;
373
374 if (v->index > 0)
375 return -EINVAL;
376
377 /* mono/stereo selector */
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 /* vidioc_s_frequency - set tuner radio frequency */
399 static 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 /* safety check */
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 /* vidioc_g_frequency - get tuner radio frequency */
421 static 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 /* safety check */
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 /* vidioc_queryctrl - enumerate control items */
436 static 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 /* vidioc_g_ctrl - get the value of a control */
448 static 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 /* safety check */
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 /* vidioc_s_ctrl - set the value of a control */
466 static 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 /* safety check */
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 /* vidioc_g_audio - get audio attributes */
499 static 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 /* vidioc_s_audio - set audio attributes */
511 static 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 /* vidioc_g_input - get input */
520 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
521 {
522 *i = 0;
523 return 0;
524 }
525
526 /* vidioc_s_input - set input */
527 static 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 /* open device - amradio_start() and amradio_setfreq() */
535 static 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 /*close device */
569 static 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 /* Suspend device - stop device. Need to be checked and fixed */
592 static 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 /* Resume device - start device. Need to be checked and fixed */
607 static 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 /* File system interface */
622 static 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
629 static 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
644 static void usb_amradio_video_device_release(struct video_device *videodev)
645 {
646 struct amradio_device *radio = video_get_drvdata(videodev);
647
648 /* we call v4l to free radio->videodev */
649 video_device_release(videodev);
650
651 v4l2_device_unregister(&radio->v4l2_dev);
652
653 /* free rest memory */
654 kfree(radio->buffer);
655 kfree(radio);
656 }
657
658 /* check if the device is present and register with v4l and usb if it is */
659 static 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
729 static 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
743 static void __exit amradio_exit(void)
744 {
745 usb_deregister(&usb_amradio_driver);
746 }
747
748 module_init(amradio_init);
749 module_exit(amradio_exit);
750
751
|
This page was automatically generated by the
LXR engine.
|