1/* A driver for the D-Link DSB-R100 USB radio and Gemtek USB Radio 21. 2 The device plugs into both the USB and an analog audio input, so this thing 3 only deals with initialisation and frequency setting, the 4 audio data has to be handled by a sound driver. 5 6 Major issue: I can't find out where the device reports the signal 7 strength, and indeed the windows software appearantly just looks 8 at the stereo indicator as well. So, scanning will only find 9 stereo stations. Sad, but I can't help it. 10 11 Also, the windows program sends oodles of messages over to the 12 device, and I couldn't figure out their meaning. My suspicion 13 is that they don't have any:-) 14 15 You might find some interesting stuff about this module at 16 http://unimut.fsk.uni-heidelberg.de/unimut/demi/dsbr 17 18 Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de> 19 20 This program is free software; you can redistribute it and/or modify 21 it under the terms of the GNU General Public License as published by 22 the Free Software Foundation; either version 2 of the License, or 23 (at your option) any later version. 24 25 This program is distributed in the hope that it will be useful, 26 but WITHOUT ANY WARRANTY; without even the implied warranty of 27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 28 GNU General Public License for more details. 29 30 You should have received a copy of the GNU General Public License 31 along with this program; if not, write to the Free Software 32 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 33 34 History: 35 36 Version 0.46: 37 Removed usb_dsbr100_open/close calls and radio->users counter. Also, 38 radio->muted changed to radio->status and suspend/resume calls updated. 39 40 Version 0.45: 41 Converted to v4l2_device. 42 43 Version 0.44: 44 Add suspend/resume functions, fix unplug of device, 45 a lot of cleanups and fixes by Alexey Klimov <klimov.linux@gmail.com> 46 47 Version 0.43: 48 Oliver Neukum: avoided DMA coherency issue 49 50 Version 0.42: 51 Converted dsbr100 to use video_ioctl2 52 by Douglas Landgraf <dougsland@gmail.com> 53 54 Version 0.41-ac1: 55 Alan Cox: Some cleanups and fixes 56 57 Version 0.41: 58 Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org> 59 60 Version 0.40: 61 Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing 62 63 Version 0.30: 64 Markus: Updates for 2.5.x kernel and more ISO compliant source 65 66 Version 0.25: 67 PSL and Markus: Cleanup, radio now doesn't stop on device close 68 69 Version 0.24: 70 Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally 71 right. Some minor cleanup, improved standalone compilation 72 73 Version 0.23: 74 Markus: Sign extension bug fixed by declaring transfer_buffer unsigned 75 76 Version 0.22: 77 Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns, 78 thanks to Mike Cox for pointing the problem out. 79 80 Version 0.21: 81 Markus: Minor cleanup, warnings if something goes wrong, lame attempt 82 to adhere to Documentation/CodingStyle 83 84 Version 0.2: 85 Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module 86 Markus: Copyright clarification 87 88 Version 0.01: Markus: initial release 89 90*/ 91 92#include <linux/kernel.h> 93#include <linux/module.h> 94#include <linux/init.h> 95#include <linux/slab.h> 96#include <linux/input.h> 97#include <linux/videodev2.h> 98#include <media/v4l2-device.h> 99#include <media/v4l2-ioctl.h> 100#include <linux/usb.h> 101 102/* 103 * Version Information 104 */ 105#include <linux/version.h> /* for KERNEL_VERSION MACRO */ 106 107#define DRIVER_VERSION "v0.46" 108#define RADIO_VERSION KERNEL_VERSION(0, 4, 6) 109 110#define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>" 111#define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver" 112 113#define DSB100_VENDOR 0x04b4 114#define DSB100_PRODUCT 0x1002 115 116/* Commands the device appears to understand */ 117#define DSB100_TUNE 1 118#define DSB100_ONOFF 2 119 120#define TB_LEN 16 121 122/* Frequency limits in MHz -- these are European values. For Japanese 123devices, that would be 76 and 91. */ 124#define FREQ_MIN 87.5 125#define FREQ_MAX 108.0 126#define FREQ_MUL 16000 127 128/* defines for radio->status */ 129#define STARTED 0 130#define STOPPED 1 131 132#define videodev_to_radio(d) container_of(d, struct dsbr100_device, videodev) 133 134static int usb_dsbr100_probe(struct usb_interface *intf, 135 const struct usb_device_id *id); 136static void usb_dsbr100_disconnect(struct usb_interface *intf); 137static int usb_dsbr100_suspend(struct usb_interface *intf, 138 pm_message_t message); 139static int usb_dsbr100_resume(struct usb_interface *intf); 140 141static int radio_nr = -1; 142module_param(radio_nr, int, 0); 143 144/* Data for one (physical) device */ 145struct dsbr100_device { 146 struct usb_device *usbdev; 147 struct video_device videodev; 148 struct v4l2_device v4l2_dev; 149 150 u8 *transfer_buffer; 151 struct mutex lock; /* buffer locking */ 152 int curfreq; 153 int stereo; 154 int removed; 155 int status; 156}; 157 158static struct usb_device_id usb_dsbr100_device_table [] = { 159 { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) }, 160 { } /* Terminating entry */ 161}; 162 163MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table); 164 165/* USB subsystem interface */ 166static struct usb_driver usb_dsbr100_driver = { 167 .name = "dsbr100", 168 .probe = usb_dsbr100_probe, 169 .disconnect = usb_dsbr100_disconnect, 170 .id_table = usb_dsbr100_device_table, 171 .suspend = usb_dsbr100_suspend, 172 .resume = usb_dsbr100_resume, 173 .reset_resume = usb_dsbr100_resume, 174 .supports_autosuspend = 0, 175}; 176 177/* Low-level device interface begins here */ 178 179/* switch on radio */ 180static int dsbr100_start(struct dsbr100_device *radio) 181{ 182 int retval; 183 int request; 184 185 mutex_lock(&radio->lock); 186 187 retval = usb_control_msg(radio->usbdev, 188 usb_rcvctrlpipe(radio->usbdev, 0), 189 USB_REQ_GET_STATUS, 190 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 191 0x00, 0xC7, radio->transfer_buffer, 8, 300); 192 193 if (retval < 0) { 194 request = USB_REQ_GET_STATUS; 195 goto usb_control_msg_failed; 196 } 197 198 retval = usb_control_msg(radio->usbdev, 199 usb_rcvctrlpipe(radio->usbdev, 0), 200 DSB100_ONOFF, 201 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 202 0x01, 0x00, radio->transfer_buffer, 8, 300); 203 204 if (retval < 0) { 205 request = DSB100_ONOFF; 206 goto usb_control_msg_failed; 207 } 208 209 radio->status = STARTED; 210 mutex_unlock(&radio->lock); 211 return (radio->transfer_buffer)[0]; 212 213usb_control_msg_failed: 214 mutex_unlock(&radio->lock); 215 dev_err(&radio->usbdev->dev, 216 "%s - usb_control_msg returned %i, request %i\n", 217 __func__, retval, request); 218 return retval; 219 220} 221 222/* switch off radio */ 223static int dsbr100_stop(struct dsbr100_device *radio) 224{ 225 int retval; 226 int request; 227 228 mutex_lock(&radio->lock); 229 230 retval = usb_control_msg(radio->usbdev, 231 usb_rcvctrlpipe(radio->usbdev, 0), 232 USB_REQ_GET_STATUS, 233 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 234 0x16, 0x1C, radio->transfer_buffer, 8, 300); 235 236 if (retval < 0) { 237 request = USB_REQ_GET_STATUS; 238 goto usb_control_msg_failed; 239 } 240 241 retval = usb_control_msg(radio->usbdev, 242 usb_rcvctrlpipe(radio->usbdev, 0), 243 DSB100_ONOFF, 244 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 245 0x00, 0x00, radio->transfer_buffer, 8, 300); 246 247 if (retval < 0) { 248 request = DSB100_ONOFF; 249 goto usb_control_msg_failed; 250 } 251 252 radio->status = STOPPED; 253 mutex_unlock(&radio->lock); 254 return (radio->transfer_buffer)[0]; 255 256usb_control_msg_failed: 257 mutex_unlock(&radio->lock); 258 dev_err(&radio->usbdev->dev, 259 "%s - usb_control_msg returned %i, request %i\n", 260 __func__, retval, request); 261 return retval; 262 263} 264 265/* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */ 266static int dsbr100_setfreq(struct dsbr100_device *radio) 267{ 268 int retval; 269 int request; 270 int freq = (radio->curfreq / 16 * 80) / 1000 + 856; 271 272 mutex_lock(&radio->lock); 273 274 retval = usb_control_msg(radio->usbdev, 275 usb_rcvctrlpipe(radio->usbdev, 0), 276 DSB100_TUNE, 277 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 278 (freq >> 8) & 0x00ff, freq & 0xff, 279 radio->transfer_buffer, 8, 300); 280 281 if (retval < 0) { 282 request = DSB100_TUNE; 283 goto usb_control_msg_failed; 284 } 285 286 retval = usb_control_msg(radio->usbdev, 287 usb_rcvctrlpipe(radio->usbdev, 0), 288 USB_REQ_GET_STATUS, 289 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 290 0x96, 0xB7, radio->transfer_buffer, 8, 300); 291 292 if (retval < 0) { 293 request = USB_REQ_GET_STATUS; 294 goto usb_control_msg_failed; 295 } 296 297 retval = usb_control_msg(radio->usbdev, 298 usb_rcvctrlpipe(radio->usbdev, 0), 299 USB_REQ_GET_STATUS, 300 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 301 0x00, 0x24, radio->transfer_buffer, 8, 300); 302 303 if (retval < 0) { 304 request = USB_REQ_GET_STATUS; 305 goto usb_control_msg_failed; 306 } 307 308 radio->stereo = !((radio->transfer_buffer)[0] & 0x01); 309 mutex_unlock(&radio->lock); 310 return (radio->transfer_buffer)[0]; 311 312usb_control_msg_failed: 313 radio->stereo = -1; 314 mutex_unlock(&radio->lock); 315 dev_err(&radio->usbdev->dev, 316 "%s - usb_control_msg returned %i, request %i\n", 317 __func__, retval, request); 318 return retval; 319} 320 321/* return the device status. This is, in effect, just whether it 322sees a stereo signal or not. Pity. */ 323static void dsbr100_getstat(struct dsbr100_device *radio) 324{ 325 int retval; 326 327 mutex_lock(&radio->lock); 328 329 retval = usb_control_msg(radio->usbdev, 330 usb_rcvctrlpipe(radio->usbdev, 0), 331 USB_REQ_GET_STATUS, 332 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 333 0x00 , 0x24, radio->transfer_buffer, 8, 300); 334 335 if (retval < 0) { 336 radio->stereo = -1; 337 dev_err(&radio->usbdev->dev, 338 "%s - usb_control_msg returned %i, request %i\n", 339 __func__, retval, USB_REQ_GET_STATUS); 340 } else { 341 radio->stereo = !(radio->transfer_buffer[0] & 0x01); 342 } 343 344 mutex_unlock(&radio->lock); 345} 346 347/* USB subsystem interface begins here */ 348 349/* 350 * Handle unplugging of the device. 351 * We call video_unregister_device in any case. 352 * The last function called in this procedure is 353 * usb_dsbr100_video_device_release 354 */ 355static void usb_dsbr100_disconnect(struct usb_interface *intf) 356{ 357 struct dsbr100_device *radio = usb_get_intfdata(intf); 358 359 usb_set_intfdata (intf, NULL); 360 361 mutex_lock(&radio->lock); 362 radio->removed = 1; 363 mutex_unlock(&radio->lock); 364 365 video_unregister_device(&radio->videodev); 366 v4l2_device_disconnect(&radio->v4l2_dev); 367} 368 369 370static int vidioc_querycap(struct file *file, void *priv, 371 struct v4l2_capability *v) 372{ 373 struct dsbr100_device *radio = video_drvdata(file); 374 375 strlcpy(v->driver, "dsbr100", sizeof(v->driver)); 376 strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card)); 377 usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info)); 378 v->version = RADIO_VERSION; 379 v->capabilities = V4L2_CAP_TUNER; 380 return 0; 381} 382 383static int vidioc_g_tuner(struct file *file, void *priv, 384 struct v4l2_tuner *v) 385{ 386 struct dsbr100_device *radio = video_drvdata(file); 387 388 /* safety check */ 389 if (radio->removed) 390 return -EIO; 391 392 if (v->index > 0) 393 return -EINVAL; 394 395 dsbr100_getstat(radio); 396 strcpy(v->name, "FM"); 397 v->type = V4L2_TUNER_RADIO; 398 v->rangelow = FREQ_MIN * FREQ_MUL; 399 v->rangehigh = FREQ_MAX * FREQ_MUL; 400 v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO; 401 v->capability = V4L2_TUNER_CAP_LOW; 402 if(radio->stereo) 403 v->audmode = V4L2_TUNER_MODE_STEREO; 404 else 405 v->audmode = V4L2_TUNER_MODE_MONO; 406 v->signal = 0xffff; /* We can't get the signal strength */ 407 return 0; 408} 409 410static int vidioc_s_tuner(struct file *file, void *priv, 411 struct v4l2_tuner *v) 412{ 413 struct dsbr100_device *radio = video_drvdata(file); 414 415 /* safety check */ 416 if (radio->removed) 417 return -EIO; 418 419 if (v->index > 0) 420 return -EINVAL; 421 422 return 0; 423} 424 425static int vidioc_s_frequency(struct file *file, void *priv, 426 struct v4l2_frequency *f) 427{ 428 struct dsbr100_device *radio = video_drvdata(file); 429 int retval; 430 431 /* safety check */ 432 if (radio->removed) 433 return -EIO; 434 435 mutex_lock(&radio->lock); 436 radio->curfreq = f->frequency; 437 mutex_unlock(&radio->lock); 438 439 retval = dsbr100_setfreq(radio); 440 if (retval < 0) 441 dev_warn(&radio->usbdev->dev, "Set frequency failed\n"); 442 return 0; 443} 444 445static int vidioc_g_frequency(struct file *file, void *priv, 446 struct v4l2_frequency *f) 447{ 448 struct dsbr100_device *radio = video_drvdata(file); 449 450 /* safety check */ 451 if (radio->removed) 452 return -EIO; 453 454 f->type = V4L2_TUNER_RADIO; 455 f->frequency = radio->curfreq; 456 return 0; 457} 458 459static int vidioc_queryctrl(struct file *file, void *priv, 460 struct v4l2_queryctrl *qc) 461{ 462 switch (qc->id) { 463 case V4L2_CID_AUDIO_MUTE: 464 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1); 465 } 466 467 return -EINVAL; 468} 469 470static int vidioc_g_ctrl(struct file *file, void *priv, 471 struct v4l2_control *ctrl) 472{ 473 struct dsbr100_device *radio = video_drvdata(file); 474 475 /* safety check */ 476 if (radio->removed) 477 return -EIO; 478 479 switch (ctrl->id) { 480 case V4L2_CID_AUDIO_MUTE: 481 ctrl->value = radio->status; 482 return 0; 483 } 484 return -EINVAL; 485} 486 487static int vidioc_s_ctrl(struct file *file, void *priv, 488 struct v4l2_control *ctrl) 489{ 490 struct dsbr100_device *radio = video_drvdata(file); 491 int retval; 492 493 /* safety check */ 494 if (radio->removed) 495 return -EIO; 496 497 switch (ctrl->id) { 498 case V4L2_CID_AUDIO_MUTE: 499 if (ctrl->value) { 500 retval = dsbr100_stop(radio); 501 if (retval < 0) { 502 dev_warn(&radio->usbdev->dev, 503 "Radio did not respond properly\n"); 504 return -EBUSY; 505 } 506 } else { 507 retval = dsbr100_start(radio); 508 if (retval < 0) { 509 dev_warn(&radio->usbdev->dev, 510 "Radio did not respond properly\n"); 511 return -EBUSY; 512 } 513 } 514 return 0; 515 } 516 return -EINVAL; 517} 518 519static int vidioc_g_audio(struct file *file, void *priv, 520 struct v4l2_audio *a) 521{ 522 if (a->index > 1) 523 return -EINVAL; 524 525 strcpy(a->name, "Radio"); 526 a->capability = V4L2_AUDCAP_STEREO; 527 return 0; 528} 529 530static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i) 531{ 532 *i = 0; 533 return 0; 534} 535 536static int vidioc_s_input(struct file *filp, void *priv, unsigned int i) 537{ 538 if (i != 0) 539 return -EINVAL; 540 return 0; 541} 542 543static int vidioc_s_audio(struct file *file, void *priv, 544 struct v4l2_audio *a) 545{ 546 if (a->index != 0) 547 return -EINVAL; 548 return 0; 549} 550 551/* Suspend device - stop device. */ 552static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message) 553{ 554 struct dsbr100_device *radio = usb_get_intfdata(intf); 555 int retval; 556 557 if (radio->status == STARTED) { 558 retval = dsbr100_stop(radio); 559 if (retval < 0) 560 dev_warn(&intf->dev, "dsbr100_stop failed\n"); 561 562 /* After dsbr100_stop() status set to STOPPED. 563 * If we want driver to start radio on resume 564 * we set status equal to STARTED. 565 * On resume we will check status and run radio if needed. 566 */ 567 568 mutex_lock(&radio->lock); 569 radio->status = STARTED; 570 mutex_unlock(&radio->lock); 571 } 572 573 dev_info(&intf->dev, "going into suspend..\n"); 574 575 return 0; 576} 577 578/* Resume device - start device. */ 579static int usb_dsbr100_resume(struct usb_interface *intf) 580{ 581 struct dsbr100_device *radio = usb_get_intfdata(intf); 582 int retval; 583 584 if (radio->status == STARTED) { 585 retval = dsbr100_start(radio); 586 if (retval < 0) 587 dev_warn(&intf->dev, "dsbr100_start failed\n"); 588 } 589 590 dev_info(&intf->dev, "coming out of suspend..\n"); 591 592 return 0; 593} 594 595/* free data structures */ 596static void usb_dsbr100_video_device_release(struct video_device *videodev) 597{ 598 struct dsbr100_device *radio = videodev_to_radio(videodev); 599 600 v4l2_device_unregister(&radio->v4l2_dev); 601 kfree(radio->transfer_buffer); 602 kfree(radio); 603} 604 605/* File system interface */ 606static const struct v4l2_file_operations usb_dsbr100_fops = { 607 .owner = THIS_MODULE, 608 .ioctl = video_ioctl2, 609}; 610 611static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = { 612 .vidioc_querycap = vidioc_querycap, 613 .vidioc_g_tuner = vidioc_g_tuner, 614 .vidioc_s_tuner = vidioc_s_tuner, 615 .vidioc_g_frequency = vidioc_g_frequency, 616 .vidioc_s_frequency = vidioc_s_frequency, 617 .vidioc_queryctrl = vidioc_queryctrl, 618 .vidioc_g_ctrl = vidioc_g_ctrl, 619 .vidioc_s_ctrl = vidioc_s_ctrl, 620 .vidioc_g_audio = vidioc_g_audio, 621 .vidioc_s_audio = vidioc_s_audio, 622 .vidioc_g_input = vidioc_g_input, 623 .vidioc_s_input = vidioc_s_input, 624}; 625 626/* check if the device is present and register with v4l and usb if it is */ 627static int usb_dsbr100_probe(struct usb_interface *intf, 628 const struct usb_device_id *id) 629{ 630 struct dsbr100_device *radio; 631 struct v4l2_device *v4l2_dev; 632 int retval; 633 634 radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL); 635 636 if (!radio) 637 return -ENOMEM; 638 639 radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL); 640 641 if (!(radio->transfer_buffer)) { 642 kfree(radio); 643 return -ENOMEM; 644 } 645 646 v4l2_dev = &radio->v4l2_dev; 647 648 retval = v4l2_device_register(&intf->dev, v4l2_dev); 649 if (retval < 0) { 650 v4l2_err(v4l2_dev, "couldn't register v4l2_device\n"); 651 kfree(radio->transfer_buffer); 652 kfree(radio); 653 return retval; 654 } 655 656 strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name)); 657 radio->videodev.v4l2_dev = v4l2_dev; 658 radio->videodev.fops = &usb_dsbr100_fops; 659 radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops; 660 radio->videodev.release = usb_dsbr100_video_device_release; 661 662 mutex_init(&radio->lock); 663 664 radio->removed = 0; 665 radio->usbdev = interface_to_usbdev(intf); 666 radio->curfreq = FREQ_MIN * FREQ_MUL; 667 radio->status = STOPPED; 668 669 video_set_drvdata(&radio->videodev, radio); 670 671 retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr); 672 if (retval < 0) { 673 v4l2_err(v4l2_dev, "couldn't register video device\n"); 674 v4l2_device_unregister(v4l2_dev); 675 kfree(radio->transfer_buffer); 676 kfree(radio); 677 return -EIO; 678 } 679 usb_set_intfdata(intf, radio); 680 return 0; 681} 682 683static int __init dsbr100_init(void) 684{ 685 int retval = usb_register(&usb_dsbr100_driver); 686 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 687 DRIVER_DESC "\n"); 688 return retval; 689} 690 691static void __exit dsbr100_exit(void) 692{ 693 usb_deregister(&usb_dsbr100_driver); 694} 695 696module_init (dsbr100_init); 697module_exit (dsbr100_exit); 698 699MODULE_AUTHOR( DRIVER_AUTHOR ); 700MODULE_DESCRIPTION( DRIVER_DESC ); 701MODULE_LICENSE("GPL"); 702