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 * 47 * Many things to do: 48 * - Correct power managment of device (suspend & resume) 49 * - Add code for scanning and smooth tuning 50 * - Add code for sensitivity value 51 * - Correct mistakes 52 * - In Japan another FREQ_MIN and FREQ_MAX 53 */ 54 55 /* kernel includes */ 56 #include <linux/kernel.h> 57 #include <linux/module.h> 58 #include <linux/init.h> 59 #include <linux/slab.h> 60 #include <linux/input.h> 61 #include <linux/videodev2.h> 62 #include <media/v4l2-common.h> 63 #include <media/v4l2-ioctl.h> 64 #include <linux/usb.h> 65 #include <linux/version.h> /* for KERNEL_VERSION MACRO */ 66 67 /* driver and module definitions */ 68 #define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@gmail.com>" 69 #define DRIVER_DESC "AverMedia MR 800 USB FM radio driver" 70 #define DRIVER_VERSION "0.10" 71 #define RADIO_VERSION KERNEL_VERSION(0, 1, 0) 72 73 MODULE_AUTHOR(DRIVER_AUTHOR); 74 MODULE_DESCRIPTION(DRIVER_DESC); 75 MODULE_LICENSE("GPL"); 76 77 #define USB_AMRADIO_VENDOR 0x07ca 78 #define USB_AMRADIO_PRODUCT 0xb800 79 80 /* dev_warn macro with driver name */ 81 #define MR800_DRIVER_NAME "radio-mr800" 82 #define amradio_dev_warn(dev, fmt, arg...) \ 83 dev_warn(dev, MR800_DRIVER_NAME " - " fmt, ##arg) 84 85 /* Probably USB_TIMEOUT should be modified in module parameter */ 86 #define BUFFER_LENGTH 8 87 #define USB_TIMEOUT 500 88 89 /* Frequency limits in MHz -- these are European values. For Japanese 90 devices, that would be 76 and 91. */ 91 #define FREQ_MIN 87.5 92 #define FREQ_MAX 108.0 93 #define FREQ_MUL 16000 94 95 /* 96 * Commands that device should understand 97 * List isnt full and will be updated with implementation of new functions 98 */ 99 #define AMRADIO_SET_FREQ 0xa4 100 #define AMRADIO_SET_MUTE 0xab 101 #define AMRADIO_SET_MONO 0xae 102 103 /* Comfortable defines for amradio_set_mute */ 104 #define AMRADIO_START 0x00 105 #define AMRADIO_STOP 0x01 106 107 /* Comfortable defines for amradio_set_stereo */ 108 #define WANT_STEREO 0x00 109 #define WANT_MONO 0x01 110 111 /* module parameter */ 112 static int radio_nr = -1; 113 module_param(radio_nr, int, 0); 114 MODULE_PARM_DESC(radio_nr, "Radio Nr"); 115 116 static struct v4l2_queryctrl radio_qctrl[] = { 117 { 118 .id = V4L2_CID_AUDIO_MUTE, 119 .name = "Mute", 120 .minimum = 0, 121 .maximum = 1, 122 .step = 1, 123 .default_value = 1, 124 .type = V4L2_CTRL_TYPE_BOOLEAN, 125 }, 126 /* HINT: the disabled controls are only here to satify kradio and such apps */ 127 { .id = V4L2_CID_AUDIO_VOLUME, 128 .flags = V4L2_CTRL_FLAG_DISABLED, 129 }, 130 { 131 .id = V4L2_CID_AUDIO_BALANCE, 132 .flags = V4L2_CTRL_FLAG_DISABLED, 133 }, 134 { 135 .id = V4L2_CID_AUDIO_BASS, 136 .flags = V4L2_CTRL_FLAG_DISABLED, 137 }, 138 { 139 .id = V4L2_CID_AUDIO_TREBLE, 140 .flags = V4L2_CTRL_FLAG_DISABLED, 141 }, 142 { 143 .id = V4L2_CID_AUDIO_LOUDNESS, 144 .flags = V4L2_CTRL_FLAG_DISABLED, 145 }, 146 }; 147 148 static int usb_amradio_probe(struct usb_interface *intf, 149 const struct usb_device_id *id); 150 static void usb_amradio_disconnect(struct usb_interface *intf); 151 static int usb_amradio_open(struct file *file); 152 static int usb_amradio_close(struct file *file); 153 static int usb_amradio_suspend(struct usb_interface *intf, 154 pm_message_t message); 155 static int usb_amradio_resume(struct usb_interface *intf); 156 157 /* Data for one (physical) device */ 158 struct amradio_device { 159 /* reference to USB and video device */ 160 struct usb_device *usbdev; 161 struct video_device *videodev; 162 163 unsigned char *buffer; 164 struct mutex lock; /* buffer locking */ 165 int curfreq; 166 int stereo; 167 int users; 168 int removed; 169 int muted; 170 }; 171 172 /* USB Device ID List */ 173 static struct usb_device_id usb_amradio_device_table[] = { 174 {USB_DEVICE_AND_INTERFACE_INFO(USB_AMRADIO_VENDOR, USB_AMRADIO_PRODUCT, 175 USB_CLASS_HID, 0, 0) }, 176 { } /* Terminating entry */ 177 }; 178 179 MODULE_DEVICE_TABLE(usb, usb_amradio_device_table); 180 181 /* USB subsystem interface */ 182 static struct usb_driver usb_amradio_driver = { 183 .name = MR800_DRIVER_NAME, 184 .probe = usb_amradio_probe, 185 .disconnect = usb_amradio_disconnect, 186 .suspend = usb_amradio_suspend, 187 .resume = usb_amradio_resume, 188 .reset_resume = usb_amradio_resume, 189 .id_table = usb_amradio_device_table, 190 .supports_autosuspend = 0, 191 }; 192 193 /* switch on/off the radio. Send 8 bytes to device */ 194 static int amradio_set_mute(struct amradio_device *radio, char argument) 195 { 196 int retval; 197 int size; 198 199 /* safety check */ 200 if (radio->removed) 201 return -EIO; 202 203 mutex_lock(&radio->lock); 204 205 radio->buffer[0] = 0x00; 206 radio->buffer[1] = 0x55; 207 radio->buffer[2] = 0xaa; 208 radio->buffer[3] = 0x00; 209 radio->buffer[4] = AMRADIO_SET_MUTE; 210 radio->buffer[5] = argument; 211 radio->buffer[6] = 0x00; 212 radio->buffer[7] = 0x00; 213 214 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2), 215 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT); 216 217 if (retval < 0 || size != BUFFER_LENGTH) { 218 mutex_unlock(&radio->lock); 219 return retval; 220 } 221 222 radio->muted = argument; 223 224 mutex_unlock(&radio->lock); 225 226 return retval; 227 } 228 229 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */ 230 static int amradio_setfreq(struct amradio_device *radio, int freq) 231 { 232 int retval; 233 int size; 234 unsigned short freq_send = 0x10 + (freq >> 3) / 25; 235 236 /* safety check */ 237 if (radio->removed) 238 return -EIO; 239 240 mutex_lock(&radio->lock); 241 242 radio->buffer[0] = 0x00; 243 radio->buffer[1] = 0x55; 244 radio->buffer[2] = 0xaa; 245 radio->buffer[3] = 0x03; 246 radio->buffer[4] = AMRADIO_SET_FREQ; 247 radio->buffer[5] = 0x00; 248 radio->buffer[6] = 0x00; 249 radio->buffer[7] = 0x08; 250 251 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2), 252 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT); 253 254 if (retval < 0 || size != BUFFER_LENGTH) { 255 mutex_unlock(&radio->lock); 256 return retval; 257 } 258 259 /* frequency is calculated from freq_send and placed in first 2 bytes */ 260 radio->buffer[0] = (freq_send >> 8) & 0xff; 261 radio->buffer[1] = freq_send & 0xff; 262 radio->buffer[2] = 0x01; 263 radio->buffer[3] = 0x00; 264 radio->buffer[4] = 0x00; 265 /* 5 and 6 bytes of buffer already = 0x00 */ 266 radio->buffer[7] = 0x00; 267 268 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2), 269 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT); 270 271 if (retval < 0 || size != BUFFER_LENGTH) { 272 mutex_unlock(&radio->lock); 273 return retval; 274 } 275 276 mutex_unlock(&radio->lock); 277 278 return retval; 279 } 280 281 static int amradio_set_stereo(struct amradio_device *radio, char argument) 282 { 283 int retval; 284 int size; 285 286 /* safety check */ 287 if (radio->removed) 288 return -EIO; 289 290 mutex_lock(&radio->lock); 291 292 radio->buffer[0] = 0x00; 293 radio->buffer[1] = 0x55; 294 radio->buffer[2] = 0xaa; 295 radio->buffer[3] = 0x00; 296 radio->buffer[4] = AMRADIO_SET_MONO; 297 radio->buffer[5] = argument; 298 radio->buffer[6] = 0x00; 299 radio->buffer[7] = 0x00; 300 301 retval = usb_bulk_msg(radio->usbdev, usb_sndintpipe(radio->usbdev, 2), 302 (void *) (radio->buffer), BUFFER_LENGTH, &size, USB_TIMEOUT); 303 304 if (retval < 0 || size != BUFFER_LENGTH) { 305 radio->stereo = -1; 306 mutex_unlock(&radio->lock); 307 return retval; 308 } 309 310 radio->stereo = 1; 311 312 mutex_unlock(&radio->lock); 313 314 return retval; 315 } 316 317 /* Handle unplugging the device. 318 * We call video_unregister_device in any case. 319 * The last function called in this procedure is 320 * usb_amradio_device_release. 321 */ 322 static void usb_amradio_disconnect(struct usb_interface *intf) 323 { 324 struct amradio_device *radio = usb_get_intfdata(intf); 325 326 mutex_lock(&radio->lock); 327 radio->removed = 1; 328 mutex_unlock(&radio->lock); 329 330 usb_set_intfdata(intf, NULL); 331 video_unregister_device(radio->videodev); 332 } 333 334 /* vidioc_querycap - query device capabilities */ 335 static int vidioc_querycap(struct file *file, void *priv, 336 struct v4l2_capability *v) 337 { 338 struct amradio_device *radio = video_drvdata(file); 339 340 strlcpy(v->driver, "radio-mr800", sizeof(v->driver)); 341 strlcpy(v->card, "AverMedia MR 800 USB FM Radio", sizeof(v->card)); 342 usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info)); 343 v->version = RADIO_VERSION; 344 v->capabilities = V4L2_CAP_TUNER; 345 return 0; 346 } 347 348 /* vidioc_g_tuner - get tuner attributes */ 349 static int vidioc_g_tuner(struct file *file, void *priv, 350 struct v4l2_tuner *v) 351 { 352 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 353 int retval; 354 355 /* safety check */ 356 if (radio->removed) 357 return -EIO; 358 359 if (v->index > 0) 360 return -EINVAL; 361 362 /* TODO: Add function which look is signal stereo or not 363 * amradio_getstat(radio); 364 */ 365 366 /* we call amradio_set_stereo to set radio->stereo 367 * Honestly, amradio_getstat should cover this in future and 368 * amradio_set_stereo shouldn't be here 369 */ 370 retval = amradio_set_stereo(radio, WANT_STEREO); 371 if (retval < 0) 372 amradio_dev_warn(&radio->videodev->dev, 373 "set stereo failed\n"); 374 375 strcpy(v->name, "FM"); 376 v->type = V4L2_TUNER_RADIO; 377 v->rangelow = FREQ_MIN * FREQ_MUL; 378 v->rangehigh = FREQ_MAX * FREQ_MUL; 379 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 380 v->capability = V4L2_TUNER_CAP_LOW; 381 if (radio->stereo) 382 v->audmode = V4L2_TUNER_MODE_STEREO; 383 else 384 v->audmode = V4L2_TUNER_MODE_MONO; 385 v->signal = 0xffff; /* Can't get the signal strength, sad.. */ 386 v->afc = 0; /* Don't know what is this */ 387 return 0; 388 } 389 390 /* vidioc_s_tuner - set tuner attributes */ 391 static int vidioc_s_tuner(struct file *file, void *priv, 392 struct v4l2_tuner *v) 393 { 394 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 395 int retval; 396 397 /* safety check */ 398 if (radio->removed) 399 return -EIO; 400 401 if (v->index > 0) 402 return -EINVAL; 403 404 /* mono/stereo selector */ 405 switch (v->audmode) { 406 case V4L2_TUNER_MODE_MONO: 407 retval = amradio_set_stereo(radio, WANT_MONO); 408 if (retval < 0) 409 amradio_dev_warn(&radio->videodev->dev, 410 "set mono failed\n"); 411 break; 412 case V4L2_TUNER_MODE_STEREO: 413 retval = amradio_set_stereo(radio, WANT_STEREO); 414 if (retval < 0) 415 amradio_dev_warn(&radio->videodev->dev, 416 "set stereo failed\n"); 417 break; 418 default: 419 return -EINVAL; 420 } 421 422 return 0; 423 } 424 425 /* vidioc_s_frequency - set tuner radio frequency */ 426 static int vidioc_s_frequency(struct file *file, void *priv, 427 struct v4l2_frequency *f) 428 { 429 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 430 int retval; 431 432 /* safety check */ 433 if (radio->removed) 434 return -EIO; 435 436 mutex_lock(&radio->lock); 437 radio->curfreq = f->frequency; 438 mutex_unlock(&radio->lock); 439 440 retval = amradio_setfreq(radio, radio->curfreq); 441 if (retval < 0) 442 amradio_dev_warn(&radio->videodev->dev, 443 "set frequency failed\n"); 444 return 0; 445 } 446 447 /* vidioc_g_frequency - get tuner radio frequency */ 448 static int vidioc_g_frequency(struct file *file, void *priv, 449 struct v4l2_frequency *f) 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 f->type = V4L2_TUNER_RADIO; 458 f->frequency = radio->curfreq; 459 return 0; 460 } 461 462 /* vidioc_queryctrl - enumerate control items */ 463 static int vidioc_queryctrl(struct file *file, void *priv, 464 struct v4l2_queryctrl *qc) 465 { 466 int i; 467 468 for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) { 469 if (qc->id && qc->id == radio_qctrl[i].id) { 470 memcpy(qc, &(radio_qctrl[i]), sizeof(*qc)); 471 return 0; 472 } 473 } 474 return -EINVAL; 475 } 476 477 /* vidioc_g_ctrl - get the value of a control */ 478 static int vidioc_g_ctrl(struct file *file, void *priv, 479 struct v4l2_control *ctrl) 480 { 481 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 482 483 /* safety check */ 484 if (radio->removed) 485 return -EIO; 486 487 switch (ctrl->id) { 488 case V4L2_CID_AUDIO_MUTE: 489 ctrl->value = radio->muted; 490 return 0; 491 } 492 return -EINVAL; 493 } 494 495 /* vidioc_s_ctrl - set the value of a control */ 496 static int vidioc_s_ctrl(struct file *file, void *priv, 497 struct v4l2_control *ctrl) 498 { 499 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 500 int retval; 501 502 /* safety check */ 503 if (radio->removed) 504 return -EIO; 505 506 switch (ctrl->id) { 507 case V4L2_CID_AUDIO_MUTE: 508 if (ctrl->value) { 509 retval = amradio_set_mute(radio, AMRADIO_STOP); 510 if (retval < 0) { 511 amradio_dev_warn(&radio->videodev->dev, 512 "amradio_stop failed\n"); 513 return -1; 514 } 515 } else { 516 retval = amradio_set_mute(radio, AMRADIO_START); 517 if (retval < 0) { 518 amradio_dev_warn(&radio->videodev->dev, 519 "amradio_start failed\n"); 520 return -1; 521 } 522 } 523 return 0; 524 } 525 return -EINVAL; 526 } 527 528 /* vidioc_g_audio - get audio attributes */ 529 static int vidioc_g_audio(struct file *file, void *priv, 530 struct v4l2_audio *a) 531 { 532 if (a->index > 1) 533 return -EINVAL; 534 535 strcpy(a->name, "Radio"); 536 a->capability = V4L2_AUDCAP_STEREO; 537 return 0; 538 } 539 540 /* vidioc_s_audio - set audio attributes */ 541 static int vidioc_s_audio(struct file *file, void *priv, 542 struct v4l2_audio *a) 543 { 544 if (a->index != 0) 545 return -EINVAL; 546 return 0; 547 } 548 549 /* vidioc_g_input - get input */ 550 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i) 551 { 552 *i = 0; 553 return 0; 554 } 555 556 /* vidioc_s_input - set input */ 557 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i) 558 { 559 if (i != 0) 560 return -EINVAL; 561 return 0; 562 } 563 564 /* open device - amradio_start() and amradio_setfreq() */ 565 static int usb_amradio_open(struct file *file) 566 { 567 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 568 int retval; 569 570 lock_kernel(); 571 572 radio->users = 1; 573 radio->muted = 1; 574 575 retval = amradio_set_mute(radio, AMRADIO_START); 576 if (retval < 0) { 577 amradio_dev_warn(&radio->videodev->dev, 578 "radio did not start up properly\n"); 579 radio->users = 0; 580 unlock_kernel(); 581 return -EIO; 582 } 583 584 retval = amradio_set_stereo(radio, WANT_STEREO); 585 if (retval < 0) 586 amradio_dev_warn(&radio->videodev->dev, 587 "set stereo failed\n"); 588 589 retval = amradio_setfreq(radio, radio->curfreq); 590 if (retval < 0) 591 amradio_dev_warn(&radio->videodev->dev, 592 "set frequency failed\n"); 593 594 unlock_kernel(); 595 return 0; 596 } 597 598 /*close device */ 599 static int usb_amradio_close(struct file *file) 600 { 601 struct amradio_device *radio = video_get_drvdata(video_devdata(file)); 602 int retval; 603 604 if (!radio) 605 return -ENODEV; 606 607 mutex_lock(&radio->lock); 608 radio->users = 0; 609 mutex_unlock(&radio->lock); 610 611 if (!radio->removed) { 612 retval = amradio_set_mute(radio, AMRADIO_STOP); 613 if (retval < 0) 614 amradio_dev_warn(&radio->videodev->dev, 615 "amradio_stop failed\n"); 616 } 617 618 return 0; 619 } 620 621 /* Suspend device - stop device. Need to be checked and fixed */ 622 static int usb_amradio_suspend(struct usb_interface *intf, pm_message_t message) 623 { 624 struct amradio_device *radio = usb_get_intfdata(intf); 625 int retval; 626 627 retval = amradio_set_mute(radio, AMRADIO_STOP); 628 if (retval < 0) 629 dev_warn(&intf->dev, "amradio_stop failed\n"); 630 631 dev_info(&intf->dev, "going into suspend..\n"); 632 633 return 0; 634 } 635 636 /* Resume device - start device. Need to be checked and fixed */ 637 static int usb_amradio_resume(struct usb_interface *intf) 638 { 639 struct amradio_device *radio = usb_get_intfdata(intf); 640 int retval; 641 642 retval = amradio_set_mute(radio, AMRADIO_START); 643 if (retval < 0) 644 dev_warn(&intf->dev, "amradio_start failed\n"); 645 646 dev_info(&intf->dev, "coming out of suspend..\n"); 647 648 return 0; 649 } 650 651 /* File system interface */ 652 static const struct v4l2_file_operations usb_amradio_fops = { 653 .owner = THIS_MODULE, 654 .open = usb_amradio_open, 655 .release = usb_amradio_close, 656 .ioctl = video_ioctl2, 657 }; 658 659 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = { 660 .vidioc_querycap = vidioc_querycap, 661 .vidioc_g_tuner = vidioc_g_tuner, 662 .vidioc_s_tuner = vidioc_s_tuner, 663 .vidioc_g_frequency = vidioc_g_frequency, 664 .vidioc_s_frequency = vidioc_s_frequency, 665 .vidioc_queryctrl = vidioc_queryctrl, 666 .vidioc_g_ctrl = vidioc_g_ctrl, 667 .vidioc_s_ctrl = vidioc_s_ctrl, 668 .vidioc_g_audio = vidioc_g_audio, 669 .vidioc_s_audio = vidioc_s_audio, 670 .vidioc_g_input = vidioc_g_input, 671 .vidioc_s_input = vidioc_s_input, 672 }; 673 674 static void usb_amradio_device_release(struct video_device *videodev) 675 { 676 struct amradio_device *radio = video_get_drvdata(videodev); 677 678 /* we call v4l to free radio->videodev */ 679 video_device_release(videodev); 680 681 /* free rest memory */ 682 kfree(radio->buffer); 683 kfree(radio); 684 } 685 686 /* V4L2 interface */ 687 static struct video_device amradio_videodev_template = { 688 .name = "AverMedia MR 800 USB FM Radio", 689 .fops = &usb_amradio_fops, 690 .ioctl_ops = &usb_amradio_ioctl_ops, 691 .release = usb_amradio_device_release, 692 }; 693 694 /* check if the device is present and register with v4l and usb if it is */ 695 static int usb_amradio_probe(struct usb_interface *intf, 696 const struct usb_device_id *id) 697 { 698 struct amradio_device *radio; 699 int retval; 700 701 radio = kmalloc(sizeof(struct amradio_device), GFP_KERNEL); 702 703 if (!radio) { 704 dev_err(&intf->dev, "kmalloc for amradio_device failed\n"); 705 return -ENOMEM; 706 } 707 708 radio->buffer = kmalloc(BUFFER_LENGTH, GFP_KERNEL); 709 710 if (!radio->buffer) { 711 dev_err(&intf->dev, "kmalloc for radio->buffer failed\n"); 712 kfree(radio); 713 return -ENOMEM; 714 } 715 716 radio->videodev = video_device_alloc(); 717 718 if (!radio->videodev) { 719 dev_err(&intf->dev, "video_device_alloc failed\n"); 720 kfree(radio->buffer); 721 kfree(radio); 722 return -ENOMEM; 723 } 724 725 memcpy(radio->videodev, &amradio_videodev_template, 726 sizeof(amradio_videodev_template)); 727 728 radio->removed = 0; 729 radio->users = 0; 730 radio->usbdev = interface_to_usbdev(intf); 731 radio->curfreq = 95.16 * FREQ_MUL; 732 radio->stereo = -1; 733 734 mutex_init(&radio->lock); 735 736 video_set_drvdata(radio->videodev, radio); 737 retval = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr); 738 if (retval < 0) { 739 dev_err(&intf->dev, "could not register video device\n"); 740 video_device_release(radio->videodev); 741 kfree(radio->buffer); 742 kfree(radio); 743 return -EIO; 744 } 745 746 usb_set_intfdata(intf, radio); 747 return 0; 748 } 749 750 static int __init amradio_init(void) 751 { 752 int retval = usb_register(&usb_amradio_driver); 753 754 pr_info(KBUILD_MODNAME 755 ": version " DRIVER_VERSION " " DRIVER_DESC "\n"); 756 757 if (retval) 758 pr_err(KBUILD_MODNAME 759 ": usb_register failed. Error number %d\n", retval); 760 761 return retval; 762 } 763 764 static void __exit amradio_exit(void) 765 { 766 usb_deregister(&usb_amradio_driver); 767 } 768 769 module_init(amradio_init); 770 module_exit(amradio_exit); 771 772