drivers/media/radio/radio-si470x.c

   1 /*
   2  *  drivers/media/radio/radio-si470x.c
   3  *
   4  *  Driver for USB radios for the Silicon Labs Si470x FM Radio Receivers:
   5  *   - Silicon Labs USB FM Radio Reference Design
   6  *   - ADS/Tech FM Radio Receiver (formerly Instant FM Music) (RDX-155-EF)
   7  *
   8  *  Copyright (c) 2008 Tobias Lorenz <tobias.lorenz@gmx.net>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  */
  24
  25
  26 /*
  27  * History:
  28  * 2008-01-12   Tobias Lorenz <tobias.lorenz@gmx.net>
  29  *              Version 1.0.0
  30  *              - First working version
  31  * 2008-01-13   Tobias Lorenz <tobias.lorenz@gmx.net>
  32  *              Version 1.0.1
  33  *              - Improved error handling, every function now returns errno
  34  *              - Improved multi user access (start/mute/stop)
  35  *              - Channel doesn't get lost anymore after start/mute/stop
  36  *              - RDS support added (polling mode via interrupt EP 1)
  37  *              - marked default module parameters with *value*
  38  *              - switched from bit structs to bit masks
  39  *              - header file cleaned and integrated
  40  * 2008-01-14   Tobias Lorenz <tobias.lorenz@gmx.net>
  41  *              Version 1.0.2
  42  *              - hex values are now lower case
  43  *              - commented USB ID for ADS/Tech moved on todo list
  44  *              - blacklisted si470x in hid-quirks.c
  45  *              - rds buffer handling functions integrated into *_work, *_read
  46  *              - rds_command in si470x_poll exchanged against simple retval
  47  *              - check for firmware version 15
  48  *              - code order and prototypes still remain the same
  49  *              - spacing and bottom of band codes remain the same
  50  * 2008-01-16   Tobias Lorenz <tobias.lorenz@gmx.net>
  51  *              Version 1.0.3
  52  *              - code reordered to avoid function prototypes
  53  *              - switch/case defaults are now more user-friendly
  54  *              - unified comment style
  55  *              - applied all checkpatch.pl v1.12 suggestions
  56  *                except the warning about the too long lines with bit comments
  57  *              - renamed FMRADIO to RADIO to cut line length (checkpatch.pl)
  58  * 2008-01-22   Tobias Lorenz <tobias.lorenz@gmx.net>
  59  *              Version 1.0.4
  60  *              - avoid poss. locking when doing copy_to_user which may sleep
  61  *              - RDS is automatically activated on read now
  62  *              - code cleaned of unnecessary rds_commands
  63  *              - USB Vendor/Product ID for ADS/Tech FM Radio Receiver verified
  64  *                (thanks to Guillaume RAMOUSSE)
  65  *
  66  * ToDo:
  67  * - add seeking support
  68  * - add firmware download/update support
  69  * - RDS support: interrupt mode, instead of polling
  70  * - add LED status output (check if that's not already done in firmware)
  71  */
  72
  73
  74 /* driver definitions */
  75 #define DRIVER_AUTHOR "Tobias Lorenz <tobias.lorenz@gmx.net>"
  76 #define DRIVER_NAME "radio-si470x"
  77 #define DRIVER_VERSION KERNEL_VERSION(1, 0, 4)
  78 #define DRIVER_CARD "Silicon Labs Si470x FM Radio Receiver"
  79 #define DRIVER_DESC "USB radio driver for Si470x FM Radio Receivers"
  80
  81
  82 /* kernel includes */
  83 #include <linux/kernel.h>
  84 #include <linux/module.h>
  85 #include <linux/init.h>
  86 #include <linux/slab.h>
  87 #include <linux/input.h>
  88 #include <linux/usb.h>
  89 #include <linux/hid.h>
  90 #include <linux/version.h>
  91 #include <linux/videodev2.h>
  92 #include <media/v4l2-common.h>
  93 #include <media/rds.h>
  94
  95
  96 /* USB Device ID List */
  97 static struct usb_device_id si470x_usb_driver_id_table[] = {
  98         /* Silicon Labs USB FM Radio Reference Design */
  99         { USB_DEVICE_AND_INTERFACE_INFO(0x10c4, 0x818a, USB_CLASS_HID, 0, 0) },
 100         /* ADS/Tech FM Radio Receiver (formerly Instant FM Music) */
 101         { USB_DEVICE_AND_INTERFACE_INFO(0x06e1, 0xa155, USB_CLASS_HID, 0, 0) },
 102         /* Terminating entry */
 103         { }
 104 };
 105 MODULE_DEVICE_TABLE(usb, si470x_usb_driver_id_table);
 106
 107
 108
 109 /**************************************************************************
 110  * Module Parameters
 111  **************************************************************************/
 112
 113 /* Radio Nr */
 114 static int radio_nr = -1;
 115 module_param(radio_nr, int, 0);
 116 MODULE_PARM_DESC(radio_nr, "Radio Nr");
 117
 118 /* Spacing (kHz) */
 119 /* 0: 200 kHz (USA, Australia) */
 120 /* 1: 100 kHz (Europe, Japan) */
 121 /* 2:  50 kHz */
 122 static int space = 2;
 123 module_param(space, int, 0);
 124 MODULE_PARM_DESC(radio_nr, "Spacing: 0=200kHz 1=100kHz *2=50kHz*");
 125
 126 /* Bottom of Band (MHz) */
 127 /* 0: 87.5 - 108 MHz (USA, Europe)*/
 128 /* 1: 76   - 108 MHz (Japan wide band) */
 129 /* 2: 76   -  90 MHz (Japan) */
 130 static int band = 1;
 131 module_param(band, int, 0);
 132 MODULE_PARM_DESC(radio_nr, "Band: 0=87.5..108MHz *1=76..108MHz* 2=76..90MHz");
 133
 134 /* De-emphasis */
 135 /* 0: 75 us (USA) */
 136 /* 1: 50 us (Europe, Australia, Japan) */
 137 static int de = 1;
 138 module_param(de, int, 0);
 139 MODULE_PARM_DESC(radio_nr, "De-emphasis: 0=75us *1=50us*");
 140
 141 /* USB timeout */
 142 static int usb_timeout = 500;
 143 module_param(usb_timeout, int, 0);
 144 MODULE_PARM_DESC(usb_timeout, "USB timeout (ms): *500*");
 145
 146 /* Seek retries */
 147 static int seek_retries = 100;
 148 module_param(seek_retries, int, 0);
 149 MODULE_PARM_DESC(seek_retries, "Seek retries: *100*");
 150
 151 /* RDS buffer blocks */
 152 static int rds_buf = 100;
 153 module_param(rds_buf, int, 0);
 154 MODULE_PARM_DESC(rds_buf, "RDS buffer entries: *100*");
 155
 156 /* RDS maximum block errors */
 157 static int max_rds_errors = 1;
 158 /* 0 means   0  errors requiring correction */
 159 /* 1 means 1-2  errors requiring correction (used by original USBRadio.exe) */
 160 /* 2 means 3-5  errors requiring correction */
 161 /* 3 means   6+ errors or errors in checkword, correction not possible */
 162 module_param(max_rds_errors, int, 0);
 163 MODULE_PARM_DESC(max_rds_errors, "RDS maximum block errors: *1*");
 164
 165 /* RDS poll frequency */
 166 static int rds_poll_time = 40;
 167 /* 40 is used by the original USBRadio.exe */
 168 /* 50 is used by radio-cadet */
 169 /* 75 should be okay */
 170 /* 80 is the usual RDS receive interval */
 171 module_param(rds_poll_time, int, 0);
 172 MODULE_PARM_DESC(rds_poll_time, "RDS poll time (ms): *40*");
 173
 174
 175
 176 /**************************************************************************
 177  * Register Definitions
 178  **************************************************************************/
 179 #define RADIO_REGISTER_SIZE     2       /* 16 register bit width */
 180 #define RADIO_REGISTER_NUM      16      /* DEVICEID   ... RDSD */
 181 #define RDS_REGISTER_NUM        6       /* STATUSRSSI ... RDSD */
 182
 183 #define DEVICEID                0       /* Device ID */
 184 #define DEVICEID_PN             0xf000  /* bits 15..12: Part Number */
 185 #define DEVICEID_MFGID          0x0fff  /* bits 11..00: Manufacturer ID */
 186
 187 #define CHIPID                  1       /* Chip ID */
 188 #define CHIPID_REV              0xfc00  /* bits 15..10: Chip Version */
 189 #define CHIPID_DEV              0x0200  /* bits 09..09: Device */
 190 #define CHIPID_FIRMWARE         0x01ff  /* bits 08..00: Firmware Version */
 191
 192 #define POWERCFG                2       /* Power Configuration */
 193 #define POWERCFG_DSMUTE         0x8000  /* bits 15..15: Softmute Disable */
 194 #define POWERCFG_DMUTE          0x4000  /* bits 14..14: Mute Disable */
 195 #define POWERCFG_MONO           0x2000  /* bits 13..13: Mono Select */
 196 #define POWERCFG_RDSM           0x0800  /* bits 11..11: RDS Mode (Si4701 only) */
 197 #define POWERCFG_SKMODE         0x0400  /* bits 10..10: Seek Mode */
 198 #define POWERCFG_SEEKUP         0x0200  /* bits 09..09: Seek Direction */
 199 #define POWERCFG_SEEK           0x0100  /* bits 08..08: Seek */
 200 #define POWERCFG_DISABLE        0x0040  /* bits 06..06: Powerup Disable */
 201 #define POWERCFG_ENABLE         0x0001  /* bits 00..00: Powerup Enable */
 202
 203 #define CHANNEL                 3       /* Channel */
 204 #define CHANNEL_TUNE            0x8000  /* bits 15..15: Tune */
 205 #define CHANNEL_CHAN            0x03ff  /* bits 09..00: Channel Select */
 206
 207 #define SYSCONFIG1              4       /* System Configuration 1 */
 208 #define SYSCONFIG1_RDSIEN       0x8000  /* bits 15..15: RDS Interrupt Enable (Si4701 only) */
 209 #define SYSCONFIG1_STCIEN       0x4000  /* bits 14..14: Seek/Tune Complete Interrupt Enable */
 210 #define SYSCONFIG1_RDS          0x1000  /* bits 12..12: RDS Enable (Si4701 only) */
 211 #define SYSCONFIG1_DE           0x0800  /* bits 11..11: De-emphasis (0=75us 1=50us) */
 212 #define SYSCONFIG1_AGCD         0x0400  /* bits 10..10: AGC Disable */
 213 #define SYSCONFIG1_BLNDADJ      0x00c0  /* bits 07..06: Stereo/Mono Blend Level Adjustment */
 214 #define SYSCONFIG1_GPIO3        0x0030  /* bits 05..04: General Purpose I/O 3 */
 215 #define SYSCONFIG1_GPIO2        0x000c  /* bits 03..02: General Purpose I/O 2 */
 216 #define SYSCONFIG1_GPIO1        0x0003  /* bits 01..00: General Purpose I/O 1 */
 217
 218 #define SYSCONFIG2              5       /* System Configuration 2 */
 219 #define SYSCONFIG2_SEEKTH       0xff00  /* bits 15..08: RSSI Seek Threshold */
 220 #define SYSCONFIG2_BAND         0x0080  /* bits 07..06: Band Select */
 221 #define SYSCONFIG2_SPACE        0x0030  /* bits 05..04: Channel Spacing */
 222 #define SYSCONFIG2_VOLUME       0x000f  /* bits 03..00: Volume */
 223
 224 #define SYSCONFIG3              6       /* System Configuration 3 */
 225 #define SYSCONFIG3_SMUTER       0xc000  /* bits 15..14: Softmute Attack/Recover Rate */
 226 #define SYSCONFIG3_SMUTEA       0x3000  /* bits 13..12: Softmute Attenuation */
 227 #define SYSCONFIG3_SKSNR        0x00f0  /* bits 07..04: Seek SNR Threshold */
 228 #define SYSCONFIG3_SKCNT        0x000f  /* bits 03..00: Seek FM Impulse Detection Threshold */
 229
 230 #define TEST1                   7       /* Test 1 */
 231 #define TEST1_AHIZEN            0x4000  /* bits 14..14: Audio High-Z Enable */
 232
 233 #define TEST2                   8       /* Test 2 */
 234 /* TEST2 only contains reserved bits */
 235
 236 #define BOOTCONFIG              9       /* Boot Configuration */
 237 /* BOOTCONFIG only contains reserved bits */
 238
 239 #define STATUSRSSI              10      /* Status RSSI */
 240 #define STATUSRSSI_RDSR         0x8000  /* bits 15..15: RDS Ready (Si4701 only) */
 241 #define STATUSRSSI_STC          0x4000  /* bits 14..14: Seek/Tune Complete */
 242 #define STATUSRSSI_SF           0x2000  /* bits 13..13: Seek Fail/Band Limit */
 243 #define STATUSRSSI_AFCRL        0x1000  /* bits 12..12: AFC Rail */
 244 #define STATUSRSSI_RDSS         0x0800  /* bits 11..11: RDS Synchronized (Si4701 only) */
 245 #define STATUSRSSI_BLERA        0x0600  /* bits 10..09: RDS Block A Errors (Si4701 only) */
 246 #define STATUSRSSI_ST           0x0100  /* bits 08..08: Stereo Indicator */
 247 #define STATUSRSSI_RSSI         0x00ff  /* bits 07..00: RSSI (Received Signal Strength Indicator) */
 248
 249 #define READCHAN                11      /* Read Channel */
 250 #define READCHAN_BLERB          0xc000  /* bits 15..14: RDS Block D Errors (Si4701 only) */
 251 #define READCHAN_BLERC          0x3000  /* bits 13..12: RDS Block C Errors (Si4701 only) */
 252 #define READCHAN_BLERD          0x0c00  /* bits 11..10: RDS Block B Errors (Si4701 only) */
 253 #define READCHAN_READCHAN       0x03ff  /* bits 09..00: Read Channel */
 254
 255 #define RDSA                    12      /* RDSA */
 256 #define RDSA_RDSA               0xffff  /* bits 15..00: RDS Block A Data (Si4701 only) */
 257
 258 #define RDSB                    13      /* RDSB */
 259 #define RDSB_RDSB               0xffff  /* bits 15..00: RDS Block B Data (Si4701 only) */
 260
 261 #define RDSC                    14      /* RDSC */
 262 #define RDSC_RDSC               0xffff  /* bits 15..00: RDS Block C Data (Si4701 only) */
 263
 264 #define RDSD                    15      /* RDSD */
 265 #define RDSD_RDSD               0xffff  /* bits 15..00: RDS Block D Data (Si4701 only) */
 266
 267
 268
 269 /**************************************************************************
 270  * USB HID Reports
 271  **************************************************************************/
 272
 273 /* Reports 1-16 give direct read/write access to the 16 Si470x registers */
 274 /* with the (REPORT_ID - 1) corresponding to the register address across USB */
 275 /* endpoint 0 using GET_REPORT and SET_REPORT */
 276 #define REGISTER_REPORT_SIZE    (RADIO_REGISTER_SIZE + 1)
 277 #define REGISTER_REPORT(reg)    ((reg) + 1)
 278
 279 /* Report 17 gives direct read/write access to the entire Si470x register */
 280 /* map across endpoint 0 using GET_REPORT and SET_REPORT */
 281 #define ENTIRE_REPORT_SIZE      (RADIO_REGISTER_NUM * RADIO_REGISTER_SIZE + 1)
 282 #define ENTIRE_REPORT           17
 283
 284 /* Report 18 is used to send the lowest 6 Si470x registers up the HID */
 285 /* interrupt endpoint 1 to Windows every 20 milliseconds for status */
 286 #define RDS_REPORT_SIZE         (RDS_REGISTER_NUM * RADIO_REGISTER_SIZE + 1)
 287 #define RDS_REPORT              18
 288
 289 /* Report 19: LED state */
 290 #define LED_REPORT_SIZE         3
 291 #define LED_REPORT              19
 292
 293 /* Report 19: stream */
 294 #define STREAM_REPORT_SIZE      3
 295 #define STREAM_REPORT           19
 296
 297 /* Report 20: scratch */
 298 #define SCRATCH_PAGE_SIZE       63
 299 #define SCRATCH_REPORT_SIZE     (SCRATCH_PAGE_SIZE + 1)
 300 #define SCRATCH_REPORT          20
 301
 302 /* Reports 19-22: flash upgrade of the C8051F321 */
 303 #define WRITE_REPORT            19
 304 #define FLASH_REPORT            20
 305 #define CRC_REPORT              21
 306 #define RESPONSE_REPORT         22
 307
 308 /* Report 23: currently unused, but can accept 60 byte reports on the HID */
 309 /* interrupt out endpoint 2 every 1 millisecond */
 310 #define UNUSED_REPORT           23
 311
 312
 313
 314 /**************************************************************************
 315  * Software/Hardware Versions
 316  **************************************************************************/
 317 #define RADIO_SW_VERSION_NOT_BOOTLOADABLE       6
 318 #define RADIO_SW_VERSION                        7
 319 #define RADIO_SW_VERSION_CURRENT                15
 320 #define RADIO_HW_VERSION                        1
 321
 322 #define SCRATCH_PAGE_SW_VERSION 1
 323 #define SCRATCH_PAGE_HW_VERSION 2
 324
 325
 326
 327 /**************************************************************************
 328  * LED State Definitions
 329  **************************************************************************/
 330 #define LED_COMMAND             0x35
 331
 332 #define NO_CHANGE_LED           0x00
 333 #define ALL_COLOR_LED           0x01    /* streaming state */
 334 #define BLINK_GREEN_LED         0x02    /* connect state */
 335 #define BLINK_RED_LED           0x04
 336 #define BLINK_ORANGE_LED        0x10    /* disconnect state */
 337 #define SOLID_GREEN_LED         0x20    /* tuning/seeking state */
 338 #define SOLID_RED_LED           0x40    /* bootload state */
 339 #define SOLID_ORANGE_LED        0x80
 340
 341
 342
 343 /**************************************************************************
 344  * Stream State Definitions
 345  **************************************************************************/
 346 #define STREAM_COMMAND  0x36
 347 #define STREAM_VIDPID   0x00
 348 #define STREAM_AUDIO    0xff
 349
 350
 351
 352 /**************************************************************************
 353  * Bootloader / Flash Commands
 354  **************************************************************************/
 355
 356 /* unique id sent to bootloader and required to put into a bootload state */
 357 #define UNIQUE_BL_ID            0x34
 358
 359 /* mask for the flash data */
 360 #define FLASH_DATA_MASK         0x55
 361
 362 /* bootloader commands */
 363 #define GET_SW_VERSION_COMMAND  0x00
 364 #define SET_PAGE_COMMAND        0x01
 365 #define ERASE_PAGE_COMMAND      0x02
 366 #define WRITE_PAGE_COMMAND      0x03
 367 #define CRC_ON_PAGE_COMMAND     0x04
 368 #define READ_FLASH_BYTE_COMMAND 0x05
 369 #define RESET_DEVICE_COMMAND    0x06
 370 #define GET_HW_VERSION_COMMAND  0x07
 371 #define BLANK                   0xff
 372
 373 /* bootloader command responses */
 374 #define COMMAND_OK              0x01
 375 #define COMMAND_FAILED          0x02
 376 #define COMMAND_PENDING         0x03
 377
 378 /* buffer sizes */
 379 #define COMMAND_BUFFER_SIZE     4
 380 #define RESPONSE_BUFFER_SIZE    2
 381 #define FLASH_BUFFER_SIZE       64
 382 #define CRC_BUFFER_SIZE         3
 383
 384
 385
 386 /**************************************************************************
 387  * General Driver Definitions
 388  **************************************************************************/
 389
 390 /*
 391  * si470x_device - private data
 392  */
 393 struct si470x_device {
 394         /* reference to USB and video device */
 395         struct usb_device *usbdev;
 396         struct video_device *videodev;
 397
 398         /* are these really necessary ? */
 399         int users;
 400
 401         /* report buffer (maximum 64 bytes) */
 402         unsigned char buf[64];
 403
 404         /* Silabs internal registers (0..15) */
 405         unsigned short registers[RADIO_REGISTER_NUM];
 406
 407         /* RDS receive buffer */
 408         struct work_struct work;
 409         wait_queue_head_t read_queue;
 410         struct timer_list timer;
 411         spinlock_t lock;                /* buffer locking */
 412         unsigned char *buffer;          /* size is always multiple of three */
 413         unsigned int buf_size;
 414         unsigned int rd_index;
 415         unsigned int wr_index;
 416 };
 417
 418
 419 /*
 420  * The frequency is set in units of 62.5 Hz when using V4L2_TUNER_CAP_LOW,
 421  * 62.5 kHz otherwise.
 422  * The tuner is able to have a channel spacing of 50, 100 or 200 kHz.
 423  * tuner->capability is therefore set to V4L2_TUNER_CAP_LOW
 424  * The FREQ_MUL is then: 1 MHz / 62.5 Hz = 16000
 425  */
 426 #define FREQ_MUL (1000000 / 62.5)
 427
 428
 429
 430 /**************************************************************************
 431  * General Driver Functions
 432  **************************************************************************/
 433
 434 /*
 435  * si470x_get_report - receive a HID report
 436  */
 437 static int si470x_get_report(struct si470x_device *radio, int size)
 438 {
 439         return usb_control_msg(radio->usbdev,
 440                 usb_rcvctrlpipe(radio->usbdev, 0),
 441                 HID_REQ_GET_REPORT,
 442                 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
 443                 radio->buf[0], 2,
 444                 radio->buf, size, usb_timeout);
 445 }
 446
 447
 448 /*
 449  * si470x_set_report - send a HID report
 450  */
 451 static int si470x_set_report(struct si470x_device *radio, int size)
 452 {
 453         return usb_control_msg(radio->usbdev,
 454                 usb_sndctrlpipe(radio->usbdev, 0),
 455                 HID_REQ_SET_REPORT,
 456                 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
 457                 radio->buf[0], 2,
 458                 radio->buf, size, usb_timeout);
 459 }
 460
 461
 462 /*
 463  * si470x_get_register - read register
 464  */
 465 static int si470x_get_register(struct si470x_device *radio, int regnr)
 466 {
 467         int retval;
 468
 469         radio->buf[0] = REGISTER_REPORT(regnr);
 470
 471         retval = si470x_get_report(radio, REGISTER_REPORT_SIZE);
 472         if (retval >= 0)
 473                 radio->registers[regnr] = (radio->buf[1] << 8) | radio->buf[2];
 474
 475         return (retval < 0) ? -EINVAL : 0;
 476 }
 477
 478
 479 /*
 480  * si470x_set_register - write register
 481  */
 482 static int si470x_set_register(struct si470x_device *radio, int regnr)
 483 {
 484         int retval;
 485
 486         radio->buf[0] = REGISTER_REPORT(regnr);
 487         radio->buf[1] = (radio->registers[regnr] & 0xff00) >> 8;
 488         radio->buf[2] = (radio->registers[regnr] & 0x00ff);
 489
 490         retval = si470x_set_report(radio, REGISTER_REPORT_SIZE);
 491
 492         return (retval < 0) ? -EINVAL : 0;
 493 }
 494
 495
 496 /*
 497  * si470x_get_all_registers - read entire registers
 498  */
 499 static int si470x_get_all_registers(struct si470x_device *radio)
 500 {
 501         int retval;
 502         int regnr;
 503
 504         radio->buf[0] = ENTIRE_REPORT;
 505
 506         retval = si470x_get_report(radio, ENTIRE_REPORT_SIZE);
 507
 508         if (retval >= 0)
 509                 for (regnr = 0; regnr < RADIO_REGISTER_NUM; regnr++)
 510                         radio->registers[regnr] =
 511                         (radio->buf[regnr * RADIO_REGISTER_SIZE + 1] << 8) |
 512                          radio->buf[regnr * RADIO_REGISTER_SIZE + 2];
 513
 514         return (retval < 0) ? -EINVAL : 0;
 515 }
 516
 517
 518 /*
 519  * si470x_get_rds_registers - read rds registers
 520  */
 521 static int si470x_get_rds_registers(struct si470x_device *radio)
 522 {
 523         int retval;
 524         int regnr;
 525         int size;
 526
 527         radio->buf[0] = RDS_REPORT;
 528
 529         retval = usb_interrupt_msg(radio->usbdev,
 530                 usb_rcvctrlpipe(radio->usbdev, 1),
 531                 radio->buf, RDS_REPORT_SIZE, &size, usb_timeout);
 532
 533         if (retval >= 0)
 534                 for (regnr = 0; regnr < RDS_REGISTER_NUM; regnr++)
 535                         radio->registers[STATUSRSSI + regnr] =
 536                         (radio->buf[regnr * RADIO_REGISTER_SIZE + 1] << 8) |
 537                          radio->buf[regnr * RADIO_REGISTER_SIZE + 2];
 538
 539         return (retval < 0) ? -EINVAL : 0;
 540 }
 541
 542
 543 /*
 544  * si470x_set_chan - set the channel
 545  */
 546 static int si470x_set_chan(struct si470x_device *radio, int chan)
 547 {
 548         int retval, i;
 549
 550         /* start tuning */
 551         radio->registers[CHANNEL] &= ~CHANNEL_CHAN;
 552         radio->registers[CHANNEL] |= CHANNEL_TUNE | chan;
 553         retval = si470x_set_register(radio, CHANNEL);
 554         if (retval < 0)
 555                 return retval;
 556
 557         /* wait till seek operation has completed */
 558         i = 0;
 559         do {
 560                 retval = si470x_get_register(radio, STATUSRSSI);
 561                 if (retval < 0)
 562                         return retval;
 563         } while ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) &&
 564                 (++i < seek_retries));
 565         if (i >= seek_retries)
 566                 printk(KERN_WARNING DRIVER_NAME
 567                         ": seek does not finish after %d tries\n", i);
 568
 569         /* stop tuning */
 570         radio->registers[CHANNEL] &= ~CHANNEL_TUNE;
 571         return si470x_set_register(radio, CHANNEL);
 572 }
 573
 574
 575 /*
 576  * si470x_get_freq - get the frequency
 577  */
 578 static int si470x_get_freq(struct si470x_device *radio)
 579 {
 580         int spacing, band_bottom, chan, freq;
 581         int retval;
 582
 583         /* Spacing (kHz) */
 584         switch (space) {
 585         /* 0: 200 kHz (USA, Australia) */
 586         case 0 : spacing = 0.200 * FREQ_MUL; break;
 587         /* 1: 100 kHz (Europe, Japan) */
 588         case 1 : spacing = 0.100 * FREQ_MUL; break;
 589         /* 2:  50 kHz */
 590         default: spacing = 0.050 * FREQ_MUL; break;
 591         };
 592
 593         /* Bottom of Band (MHz) */
 594         switch (band) {
 595         /* 0: 87.5 - 108 MHz (USA, Europe) */
 596         case 0 : band_bottom = 87.5 * FREQ_MUL; break;
 597         /* 1: 76   - 108 MHz (Japan wide band) */
 598         default: band_bottom = 76   * FREQ_MUL; break;
 599         /* 2: 76   -  90 MHz (Japan) */
 600         case 2 : band_bottom = 76   * FREQ_MUL; break;
 601         };
 602
 603         /* read channel */
 604         retval = si470x_get_register(radio, READCHAN);
 605         if (retval < 0)
 606                 return retval;
 607         chan = radio->registers[READCHAN] & READCHAN_READCHAN;
 608
 609         /* Frequency (MHz) = Spacing (kHz) x Channel + Bottom of Band (MHz) */
 610         freq = chan * spacing + band_bottom;
 611
 612         return freq;
 613 }
 614
 615
 616 /*
 617  * si470x_set_freq - set the frequency
 618  */
 619 static int si470x_set_freq(struct si470x_device *radio, int freq)
 620 {
 621         int spacing, band_bottom, chan;
 622
 623         /* Spacing (kHz) */
 624         switch (space) {
 625         /* 0: 200 kHz (USA, Australia) */
 626         case 0 : spacing = 0.200 * FREQ_MUL; break;
 627         /* 1: 100 kHz (Europe, Japan) */
 628         case 1 : spacing = 0.100 * FREQ_MUL; break;
 629         /* 2:  50 kHz */
 630         default: spacing = 0.050 * FREQ_MUL; break;
 631         };
 632
 633         /* Bottom of Band (MHz) */
 634         switch (band) {
 635         /* 0: 87.5 - 108 MHz (USA, Europe) */
 636         case 0 : band_bottom = 87.5 * FREQ_MUL; break;
 637         /* 1: 76   - 108 MHz (Japan wide band) */
 638         default: band_bottom = 76   * FREQ_MUL; break;
 639         /* 2: 76   -  90 MHz (Japan) */
 640         case 2 : band_bottom = 76   * FREQ_MUL; break;
 641         };
 642
 643         /* Chan = [ Freq (Mhz) - Bottom of Band (MHz) ] / Spacing (kHz) */
 644         chan = (freq - band_bottom) / spacing;
 645
 646         return si470x_set_chan(radio, chan);
 647 }
 648
 649
 650 /*
 651  * si470x_start - switch on radio
 652  */
 653 static int si470x_start(struct si470x_device *radio)
 654 {
 655         int retval;
 656
 657         /* powercfg */
 658         radio->registers[POWERCFG] =
 659                 POWERCFG_DMUTE | POWERCFG_ENABLE | POWERCFG_RDSM;
 660         retval = si470x_set_register(radio, POWERCFG);
 661         if (retval < 0)
 662                 return retval;
 663
 664         /* sysconfig 1 */
 665         radio->registers[SYSCONFIG1] = SYSCONFIG1_DE;
 666         retval = si470x_set_register(radio, SYSCONFIG1);
 667         if (retval < 0)
 668                 return retval;
 669
 670         /* sysconfig 2 */
 671         radio->registers[SYSCONFIG2] =
 672                 (0x3f  << 8) |  /* SEEKTH */
 673                 (band  << 6) |  /* BAND */
 674                 (space << 4) |  /* SPACE */
 675                 15;             /* VOLUME (max) */
 676         retval = si470x_set_register(radio, SYSCONFIG2);
 677         if (retval < 0)
 678                 return retval;
 679
 680         /* reset last channel */
 681         return si470x_set_chan(radio,
 682                 radio->registers[CHANNEL] & CHANNEL_CHAN);
 683 }
 684
 685
 686 /*
 687  * si470x_stop - switch off radio
 688  */
 689 static int si470x_stop(struct si470x_device *radio)
 690 {
 691         int retval;
 692
 693         /* sysconfig 1 */
 694         radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS;
 695         retval = si470x_set_register(radio, SYSCONFIG1);
 696         if (retval < 0)
 697                 return retval;
 698
 699         /* powercfg */
 700         radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
 701         /* POWERCFG_ENABLE has to automatically go low */
 702         radio->registers[POWERCFG] |= POWERCFG_ENABLE | POWERCFG_DISABLE;
 703         return si470x_set_register(radio, POWERCFG);
 704 }
 705
 706
 707 /*
 708  * si470x_rds_on - switch on rds reception
 709  */
 710 static int si470x_rds_on(struct si470x_device *radio)
 711 {
 712         /* sysconfig 1 */
 713         radio->registers[SYSCONFIG1] |= SYSCONFIG1_RDS;
 714         return si470x_set_register(radio, SYSCONFIG1);
 715 }
 716
 717
 718
 719 /**************************************************************************
 720  * RDS Driver Functions
 721  **************************************************************************/
 722
 723 /*
 724  * si470x_rds - rds processing function
 725  */
 726 static void si470x_rds(struct si470x_device *radio)
 727 {
 728         unsigned char tmpbuf[3];
 729         unsigned char blocknum;
 730         unsigned char bler; /* rds block errors */
 731         unsigned short rds;
 732         unsigned int i;
 733
 734         /* get rds blocks */
 735         if (si470x_get_rds_registers(radio) < 0)
 736                 return;
 737         if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSR) == 0) {
 738                 /* No RDS group ready */
 739                 return;
 740         }
 741         if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSS) == 0) {
 742                 /* RDS decoder not synchronized */
 743                 return;
 744         }
 745
 746         /* copy four RDS blocks to internal buffer */
 747         if (spin_trylock(&radio->lock)) {
 748                 /* process each rds block */
 749                 for (blocknum = 0; blocknum < 4; blocknum++) {
 750                         switch (blocknum) {
 751                         default:
 752                                 bler = (radio->registers[STATUSRSSI] &
 753                                                 STATUSRSSI_BLERA) >> 9;
 754                                 rds = radio->registers[RDSA];
 755                                 break;
 756                         case 1:
 757                                 bler = (radio->registers[READCHAN] &
 758                                                 READCHAN_BLERB) >> 14;
 759                                 rds = radio->registers[RDSB];
 760                                 break;
 761                         case 2:
 762                                 bler = (radio->registers[READCHAN] &
 763                                                 READCHAN_BLERC) >> 12;
 764                                 rds = radio->registers[RDSC];
 765                                 break;
 766                         case 3:
 767                                 bler = (radio->registers[READCHAN] &
 768                                                 READCHAN_BLERD) >> 10;
 769                                 rds = radio->registers[RDSD];
 770                                 break;
 771                         };
 772
 773                         /* Fill the V4L2 RDS buffer */
 774                         tmpbuf[0] = rds & 0x00ff;       /* LSB */
 775                         tmpbuf[1] = (rds & 0xff00) >> 8;/* MSB */
 776                         tmpbuf[2] = blocknum;           /* offset name */
 777                         tmpbuf[2] |= blocknum << 3;     /* received offset */
 778                         if (bler > max_rds_errors)
 779                                 tmpbuf[2] |= 0x80; /* uncorrectable errors */
 780                         else if (bler > 0)
 781                                 tmpbuf[2] |= 0x40; /* corrected error(s) */
 782
 783                         /* copy RDS block to internal buffer */
 784                         for (i = 0; i < 3; i++) {
 785                                 radio->buffer[radio->wr_index] = tmpbuf[i];
 786                                 radio->wr_index++;
 787                         }
 788
 789                         /* wrap write pointer */
 790                         if (radio->wr_index >= radio->buf_size)
 791                                 radio->wr_index = 0;
 792
 793                         /* check for overflow */
 794                         if (radio->wr_index == radio->rd_index) {
 795                                 /* increment and wrap read pointer */
 796                                 radio->rd_index += 3;
 797                                 if (radio->rd_index >= radio->buf_size)
 798                                         radio->rd_index = 0;
 799                         }
 800                 }
 801                 spin_unlock(&radio->lock);
 802         }
 803
 804         /* wake up read queue */
 805         if (radio->wr_index != radio->rd_index)
 806                 wake_up_interruptible(&radio->read_queue);
 807 }
 808
 809
 810 /*
 811  * si470x_timer - rds timer function
 812  */
 813 static void si470x_timer(unsigned long data)
 814 {
 815         struct si470x_device *radio = (struct si470x_device *) data;
 816
 817         schedule_work(&radio->work);
 818 }
 819
 820
 821 /*
 822  * si470x_work - rds work function
 823  */
 824 static void si470x_work(struct work_struct *work)
 825 {
 826         struct si470x_device *radio = container_of(work, struct si470x_device,
 827                 work);
 828
 829         if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
 830                 return;
 831
 832         si470x_rds(radio);
 833         mod_timer(&radio->timer, jiffies + msecs_to_jiffies(rds_poll_time));
 834 }
 835
 836
 837
 838 /**************************************************************************
 839  * File Operations Interface
 840  **************************************************************************/
 841
 842 /*
 843  * si470x_fops_read - read RDS data
 844  */
 845 static ssize_t si470x_fops_read(struct file *file, char __user *buf,
 846                 size_t count, loff_t *ppos)
 847 {
 848         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
 849         int retval = 0;
 850         unsigned int block_count = 0;
 851
 852         /* switch on rds reception */
 853         if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0) {
 854                 si470x_rds_on(radio);
 855                 schedule_work(&radio->work);
 856         }
 857
 858         /* block if no new data available */
 859         while (radio->wr_index == radio->rd_index) {
 860                 if (file->f_flags & O_NONBLOCK)
 861                         return -EWOULDBLOCK;
 862                 interruptible_sleep_on(&radio->read_queue);
 863         }
 864
 865         /* calculate block count from byte count */
 866         count /= 3;
 867
 868         /* copy RDS block out of internal buffer and to user buffer */
 869         if (spin_trylock(&radio->lock)) {
 870                 while (block_count < count) {
 871                         if (radio->rd_index == radio->wr_index)
 872                                 break;
 873
 874                         /* always transfer rds complete blocks */
 875                         if (copy_to_user(buf,
 876                                         &radio->buffer[radio->rd_index], 3))
 877                                 /* retval = -EFAULT; */
 878                                 break;
 879
 880                         /* increment and wrap read pointer */
 881                         radio->rd_index += 3;
 882                         if (radio->rd_index >= radio->buf_size)
 883                                 radio->rd_index = 0;
 884
 885                         /* increment counters */
 886                         block_count++;
 887                         buf += 3;
 888                         retval += 3;
 889                 }
 890
 891                 spin_unlock(&radio->lock);
 892         }
 893
 894         return retval;
 895 }
 896
 897
 898 /*
 899  * si470x_fops_poll - poll RDS data
 900  */
 901 static unsigned int si470x_fops_poll(struct file *file,
 902                 struct poll_table_struct *pts)
 903 {
 904         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
 905
 906         /* switch on rds reception */
 907         if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0) {
 908                 si470x_rds_on(radio);
 909                 schedule_work(&radio->work);
 910         }
 911
 912         poll_wait(file, &radio->read_queue, pts);
 913
 914         if (radio->rd_index != radio->wr_index)
 915                 return POLLIN | POLLRDNORM;
 916
 917         return 0;
 918 }
 919
 920
 921 /*
 922  * si470x_fops_open - file open
 923  */
 924 static int si470x_fops_open(struct inode *inode, struct file *file)
 925 {
 926         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
 927
 928         radio->users++;
 929         if (radio->users == 1)
 930                 return si470x_start(radio);
 931
 932         return 0;
 933 }
 934
 935
 936 /*
 937  * si470x_fops_release - file release
 938  */
 939 static int si470x_fops_release(struct inode *inode, struct file *file)
 940 {
 941         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
 942
 943         if (!radio)
 944                 return -ENODEV;
 945
 946         radio->users--;
 947         if (radio->users == 0) {
 948                 /* stop rds reception */
 949                 del_timer_sync(&radio->timer);
 950                 flush_scheduled_work();
 951
 952                 /* cancel read processes */
 953                 wake_up_interruptible(&radio->read_queue);
 954
 955                 return si470x_stop(radio);
 956         }
 957
 958         return 0;
 959 }
 960
 961
 962 /*
 963  * si470x_fops - file operations interface
 964  */
 965 static const struct file_operations si470x_fops = {
 966         .owner          = THIS_MODULE,
 967         .llseek         = no_llseek,
 968         .read           = si470x_fops_read,
 969         .poll           = si470x_fops_poll,
 970         .ioctl          = video_ioctl2,
 971         .compat_ioctl   = v4l_compat_ioctl32,
 972         .open           = si470x_fops_open,
 973         .release        = si470x_fops_release,
 974 };
 975
 976
 977
 978 /**************************************************************************
 979  * Video4Linux Interface
 980  **************************************************************************/
 981
 982 /*
 983  * si470x_v4l2_queryctrl - query control
 984  */
 985 static struct v4l2_queryctrl si470x_v4l2_queryctrl[] = {
 986 /* HINT: the disabled controls are only here to satify kradio and such apps */
 987         {
 988                 .id             = V4L2_CID_AUDIO_VOLUME,
 989                 .type           = V4L2_CTRL_TYPE_INTEGER,
 990                 .name           = "Volume",
 991                 .minimum        = 0,
 992                 .maximum        = 15,
 993                 .step           = 1,
 994                 .default_value  = 15,
 995         },
 996         {
 997                 .id             = V4L2_CID_AUDIO_BALANCE,
 998                 .flags          = V4L2_CTRL_FLAG_DISABLED,
 999         },
1000         {
1001                 .id             = V4L2_CID_AUDIO_BASS,
1002                 .flags          = V4L2_CTRL_FLAG_DISABLED,
1003         },
1004         {
1005                 .id             = V4L2_CID_AUDIO_TREBLE,
1006                 .flags          = V4L2_CTRL_FLAG_DISABLED,
1007         },
1008         {
1009                 .id             = V4L2_CID_AUDIO_MUTE,
1010                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
1011                 .name           = "Mute",
1012                 .minimum        = 0,
1013                 .maximum        = 1,
1014                 .step           = 1,
1015                 .default_value  = 1,
1016         },
1017         {
1018                 .id             = V4L2_CID_AUDIO_LOUDNESS,
1019                 .flags          = V4L2_CTRL_FLAG_DISABLED,
1020         },
1021 };
1022
1023
1024 /*
1025  * si470x_vidioc_querycap - query device capabilities
1026  */
1027 static int si470x_vidioc_querycap(struct file *file, void *priv,
1028                 struct v4l2_capability *capability)
1029 {
1030         strlcpy(capability->driver, DRIVER_NAME, sizeof(capability->driver));
1031         strlcpy(capability->card, DRIVER_CARD, sizeof(capability->card));
1032         sprintf(capability->bus_info, "USB");
1033         capability->version = DRIVER_VERSION;
1034         capability->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
1035
1036         return 0;
1037 }
1038
1039
1040 /*
1041  * si470x_vidioc_g_input - get input
1042  */
1043 static int si470x_vidioc_g_input(struct file *filp, void *priv,
1044                 unsigned int *i)
1045 {
1046         *i = 0;
1047
1048         return 0;
1049 }
1050
1051
1052 /*
1053  * si470x_vidioc_s_input - set input
1054  */
1055 static int si470x_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1056 {
1057         if (i != 0)
1058                 return -EINVAL;
1059
1060         return 0;
1061 }
1062
1063
1064 /*
1065  * si470x_vidioc_queryctrl - enumerate control items
1066  */
1067 static int si470x_vidioc_queryctrl(struct file *file, void *priv,
1068                 struct v4l2_queryctrl *qc)
1069 {
1070         int i;
1071
1072         for (i = 0; i < ARRAY_SIZE(si470x_v4l2_queryctrl); i++) {
1073                 if (qc->id && qc->id == si470x_v4l2_queryctrl[i].id) {
1074                         memcpy(qc, &(si470x_v4l2_queryctrl[i]), sizeof(*qc));
1075                         return 0;
1076                 }
1077         }
1078
1079         return -EINVAL;
1080 }
1081
1082
1083 /*
1084  * si470x_vidioc_g_ctrl - get the value of a control
1085  */
1086 static int si470x_vidioc_g_ctrl(struct file *file, void *priv,
1087                 struct v4l2_control *ctrl)
1088 {
1089         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1090
1091         switch (ctrl->id) {
1092         case V4L2_CID_AUDIO_VOLUME:
1093                 ctrl->value = radio->registers[SYSCONFIG2] &
1094                                 SYSCONFIG2_VOLUME;
1095                 break;
1096         case V4L2_CID_AUDIO_MUTE:
1097                 ctrl->value = ((radio->registers[POWERCFG] &
1098                                 POWERCFG_DMUTE) == 0) ? 1 : 0;
1099                 break;
1100         }
1101
1102         return 0;
1103 }
1104
1105
1106 /*
1107  * si470x_vidioc_s_ctrl - set the value of a control
1108  */
1109 static int si470x_vidioc_s_ctrl(struct file *file, void *priv,
1110                 struct v4l2_control *ctrl)
1111 {
1112         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1113
1114         switch (ctrl->id) {
1115         case V4L2_CID_AUDIO_VOLUME:
1116                 radio->registers[SYSCONFIG2] &= ~SYSCONFIG2_VOLUME;
1117                 radio->registers[SYSCONFIG2] |= ctrl->value;
1118                 return si470x_set_register(radio, SYSCONFIG2);
1119         case V4L2_CID_AUDIO_MUTE:
1120                 if (ctrl->value == 1)
1121                         radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
1122                 else
1123                         radio->registers[POWERCFG] |= POWERCFG_DMUTE;
1124                 return si470x_set_register(radio, POWERCFG);
1125         }
1126
1127         return -EINVAL;
1128 }
1129
1130
1131 /*
1132  * si470x_vidioc_g_audio - get audio attributes
1133  */
1134 static int si470x_vidioc_g_audio(struct file *file, void *priv,
1135                 struct v4l2_audio *audio)
1136 {
1137         if (audio->index > 1)
1138                 return -EINVAL;
1139
1140         strcpy(audio->name, "Radio");
1141         audio->capability = V4L2_AUDCAP_STEREO;
1142
1143         return 0;
1144 }
1145
1146
1147 /*
1148  * si470x_vidioc_s_audio - set audio attributes
1149  */
1150 static int si470x_vidioc_s_audio(struct file *file, void *priv,
1151                 struct v4l2_audio *audio)
1152 {
1153         if (audio->index != 0)
1154                 return -EINVAL;
1155
1156         return 0;
1157 }
1158
1159
1160 /*
1161  * si470x_vidioc_g_tuner - get tuner attributes
1162  */
1163 static int si470x_vidioc_g_tuner(struct file *file, void *priv,
1164                 struct v4l2_tuner *tuner)
1165 {
1166         int retval;
1167         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1168
1169         if (tuner->index > 0)
1170                 return -EINVAL;
1171
1172         /* read status rssi */
1173         retval = si470x_get_register(radio, STATUSRSSI);
1174         if (retval < 0)
1175                 return retval;
1176
1177         strcpy(tuner->name, "FM");
1178         tuner->type = V4L2_TUNER_RADIO;
1179         switch (band) {
1180         /* 0: 87.5 - 108 MHz (USA, Europe, default) */
1181         default:
1182                 tuner->rangelow  =  87.5 * FREQ_MUL;
1183                 tuner->rangehigh = 108   * FREQ_MUL;
1184                 break;
1185         /* 1: 76   - 108 MHz (Japan wide band) */
1186         case 1 :
1187                 tuner->rangelow  =  76   * FREQ_MUL;
1188                 tuner->rangehigh = 108   * FREQ_MUL;
1189                 break;
1190         /* 2: 76   -  90 MHz (Japan) */
1191         case 2 :
1192                 tuner->rangelow  =  76   * FREQ_MUL;
1193                 tuner->rangehigh =  90   * FREQ_MUL;
1194                 break;
1195         };
1196         tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1197         tuner->capability = V4L2_TUNER_CAP_LOW;
1198
1199         /* Stereo indicator == Stereo (instead of Mono) */
1200         if ((radio->registers[STATUSRSSI] & STATUSRSSI_ST) == 1)
1201                 tuner->audmode = V4L2_TUNER_MODE_STEREO;
1202         else
1203                 tuner->audmode = V4L2_TUNER_MODE_MONO;
1204
1205         /* min is worst, max is best; signal:0..0xffff; rssi: 0..0xff */
1206         tuner->signal = (radio->registers[STATUSRSSI] & STATUSRSSI_RSSI)
1207                                 * 0x0101;
1208
1209         /* automatic frequency control: -1: freq to low, 1 freq to high */
1210         tuner->afc = 0;
1211
1212         return 0;
1213 }
1214
1215
1216 /*
1217  * si470x_vidioc_s_tuner - set tuner attributes
1218  */
1219 static int si470x_vidioc_s_tuner(struct file *file, void *priv,
1220                 struct v4l2_tuner *tuner)
1221 {
1222         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1223
1224         if (tuner->index > 0)
1225                 return -EINVAL;
1226
1227         if (tuner->audmode == V4L2_TUNER_MODE_MONO)
1228                 radio->registers[POWERCFG] |= POWERCFG_MONO;  /* force mono */
1229         else
1230                 radio->registers[POWERCFG] &= ~POWERCFG_MONO; /* try stereo */
1231
1232         return si470x_set_register(radio, POWERCFG);
1233 }
1234
1235
1236 /*
1237  * si470x_vidioc_g_frequency - get tuner or modulator radio frequency
1238  */
1239 static int si470x_vidioc_g_frequency(struct file *file, void *priv,
1240                 struct v4l2_frequency *freq)
1241 {
1242         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1243
1244         freq->type = V4L2_TUNER_RADIO;
1245         freq->frequency = si470x_get_freq(radio);
1246
1247         return 0;
1248 }
1249
1250
1251 /*
1252  * si470x_vidioc_s_frequency - set tuner or modulator radio frequency
1253  */
1254 static int si470x_vidioc_s_frequency(struct file *file, void *priv,
1255                 struct v4l2_frequency *freq)
1256 {
1257         struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1258
1259         if (freq->type != V4L2_TUNER_RADIO)
1260                 return -EINVAL;
1261
1262         return si470x_set_freq(radio, freq->frequency);
1263 }
1264
1265
1266 /*
1267  * si470x_viddev_tamples - video device interface
1268  */
1269 static struct video_device si470x_viddev_template = {
1270         .fops                   = &si470x_fops,
1271         .name                   = DRIVER_NAME,
1272         .type                   = VID_TYPE_TUNER,
1273         .release                = video_device_release,
1274         .vidioc_querycap        = si470x_vidioc_querycap,
1275         .vidioc_g_input         = si470x_vidioc_g_input,
1276         .vidioc_s_input         = si470x_vidioc_s_input,
1277         .vidioc_queryctrl       = si470x_vidioc_queryctrl,
1278         .vidioc_g_ctrl          = si470x_vidioc_g_ctrl,
1279         .vidioc_s_ctrl          = si470x_vidioc_s_ctrl,
1280         .vidioc_g_audio         = si470x_vidioc_g_audio,
1281         .vidioc_s_audio         = si470x_vidioc_s_audio,
1282         .vidioc_g_tuner         = si470x_vidioc_g_tuner,
1283         .vidioc_s_tuner         = si470x_vidioc_s_tuner,
1284         .vidioc_g_frequency     = si470x_vidioc_g_frequency,
1285         .vidioc_s_frequency     = si470x_vidioc_s_frequency,
1286         .owner                  = THIS_MODULE,
1287 };
1288
1289
1290
1291 /**************************************************************************
1292  * USB Interface
1293  **************************************************************************/
1294
1295 /*
1296  * si470x_usb_driver_probe - probe for the device
1297  */
1298 static int si470x_usb_driver_probe(struct usb_interface *intf,
1299                 const struct usb_device_id *id)
1300 {
1301         struct si470x_device *radio;
1302
1303         /* memory and interface allocations */
1304         radio = kmalloc(sizeof(struct si470x_device), GFP_KERNEL);
1305         if (!radio)
1306                 return -ENOMEM;
1307         radio->videodev = video_device_alloc();
1308         if (!radio->videodev) {
1309                 kfree(radio);
1310                 return -ENOMEM;
1311         }
1312         memcpy(radio->videodev, &si470x_viddev_template,
1313                         sizeof(si470x_viddev_template));
1314         radio->users = 0;
1315         radio->usbdev = interface_to_usbdev(intf);
1316         video_set_drvdata(radio->videodev, radio);
1317         if (video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr)) {
1318                 printk(KERN_WARNING DRIVER_NAME
1319                                 ": Could not register video device\n");
1320                 video_device_release(radio->videodev);
1321                 kfree(radio);
1322                 return -EIO;
1323         }
1324         usb_set_intfdata(intf, radio);
1325
1326         /* show some infos about the specific device */
1327         if (si470x_get_all_registers(radio) < 0) {
1328                 video_device_release(radio->videodev);
1329                 kfree(radio);
1330                 return -EIO;
1331         }
1332         printk(KERN_INFO DRIVER_NAME ": DeviceID=0x%4.4x ChipID=0x%4.4x\n",
1333                         radio->registers[DEVICEID], radio->registers[CHIPID]);
1334
1335         /* check if firmware is current */
1336         if ((radio->registers[CHIPID] & CHIPID_FIRMWARE)
1337                         < RADIO_SW_VERSION_CURRENT)
1338                 printk(KERN_WARNING DRIVER_NAME
1339                         ": This driver is known to work with chip version %d, "
1340                         "but the device has firmware %d.\n"
1341                         DRIVER_NAME
1342                         "If you have some trouble using this driver, please "
1343                         "report to V4L ML at video4linux-list@redhat.com\n",
1344                         radio->registers[CHIPID] & CHIPID_FIRMWARE,
1345                         RADIO_SW_VERSION_CURRENT);
1346
1347         /* set initial frequency */
1348         si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */
1349
1350         /* rds initialization */
1351         radio->buf_size = rds_buf * 3;
1352         radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
1353         if (!radio->buffer) {
1354                 video_device_release(radio->videodev);
1355                 kfree(radio);
1356                 return -ENOMEM;
1357         }
1358         radio->wr_index = 0;
1359         radio->rd_index = 0;
1360         init_waitqueue_head(&radio->read_queue);
1361
1362         /* prepare polling via eventd */
1363         INIT_WORK(&radio->work, si470x_work);
1364         init_timer(&radio->timer);
1365         radio->timer.function = si470x_timer;
1366         radio->timer.data = (unsigned long) radio;
1367
1368         return 0;
1369 }
1370
1371
1372 /*
1373  * si470x_usb_driver_disconnect - disconnect the device
1374  */
1375 static void si470x_usb_driver_disconnect(struct usb_interface *intf)
1376 {
1377         struct si470x_device *radio = usb_get_intfdata(intf);
1378
1379         del_timer_sync(&radio->timer);
1380         flush_scheduled_work();
1381
1382         usb_set_intfdata(intf, NULL);
1383         if (radio) {
1384                 video_unregister_device(radio->videodev);
1385                 kfree(radio->buffer);
1386                 kfree(radio);
1387         }
1388 }
1389
1390
1391 /*
1392  * si470x_usb_driver - usb driver interface
1393  */
1394 static struct usb_driver si470x_usb_driver = {
1395         .name           = DRIVER_NAME,
1396         .probe          = si470x_usb_driver_probe,
1397         .disconnect     = si470x_usb_driver_disconnect,
1398         .id_table       = si470x_usb_driver_id_table,
1399 };
1400
1401
1402
1403 /**************************************************************************
1404  * Module Interface
1405  **************************************************************************/
1406
1407 /*
1408  * si470x_module_init - module init
1409  */
1410 static int __init si470x_module_init(void)
1411 {
1412         printk(KERN_INFO DRIVER_DESC "\n");
1413         return usb_register(&si470x_usb_driver);
1414 }
1415
1416
1417 /*
1418  * si470x_module_exit - module exit
1419  */
1420 static void __exit si470x_module_exit(void)
1421 {
1422         usb_deregister(&si470x_usb_driver);
1423 }
1424
1425
1426 module_init(si470x_module_init);
1427 module_exit(si470x_module_exit);
1428
1429 MODULE_LICENSE("GPL");
1430 MODULE_AUTHOR(DRIVER_AUTHOR);
1431 MODULE_DESCRIPTION(DRIVER_DESC);
1432 MODULE_VERSION("1.0.4");