a1239083472dcb468a8eff54079de25b65f9f918
[linux-2.6.git] / drivers / media / radio / radio-mr800.c
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 management 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