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