kernel/drivers/media/radio/si470x/radio-si470x-common.c

   1 /*
   2  *  drivers/media/radio/si470x/radio-si470x-common.c
   3  *
   4  *  Driver for radios with Silicon Labs Si470x FM Radio Receivers
   5  *
   6  *  Copyright (c) 2009 Tobias Lorenz <tobias.lorenz@gmx.net>
   7  *  Copyright (c) 2012 Hans de Goede <hdegoede@redhat.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 /*
  26  * History:
  27  * 2008-01-12   Tobias Lorenz <tobias.lorenz@gmx.net>
  28  *              Version 1.0.0
  29  *              - First working version
  30  * 2008-01-13   Tobias Lorenz <tobias.lorenz@gmx.net>
  31  *              Version 1.0.1
  32  *              - Improved error handling, every function now returns errno
  33  *              - Improved multi user access (start/mute/stop)
  34  *              - Channel doesn't get lost anymore after start/mute/stop
  35  *              - RDS support added (polling mode via interrupt EP 1)
  36  *              - marked default module parameters with *value*
  37  *              - switched from bit structs to bit masks
  38  *              - header file cleaned and integrated
  39  * 2008-01-14   Tobias Lorenz <tobias.lorenz@gmx.net>
  40  *              Version 1.0.2
  41  *              - hex values are now lower case
  42  *              - commented USB ID for ADS/Tech moved on todo list
  43  *              - blacklisted si470x in hid-quirks.c
  44  *              - rds buffer handling functions integrated into *_work, *_read
  45  *              - rds_command in si470x_poll exchanged against simple retval
  46  *              - check for firmware version 15
  47  *              - code order and prototypes still remain the same
  48  *              - spacing and bottom of band codes remain the same
  49  * 2008-01-16   Tobias Lorenz <tobias.lorenz@gmx.net>
  50  *              Version 1.0.3
  51  *              - code reordered to avoid function prototypes
  52  *              - switch/case defaults are now more user-friendly
  53  *              - unified comment style
  54  *              - applied all checkpatch.pl v1.12 suggestions
  55  *                except the warning about the too long lines with bit comments
  56  *              - renamed FMRADIO to RADIO to cut line length (checkpatch.pl)
  57  * 2008-01-22   Tobias Lorenz <tobias.lorenz@gmx.net>
  58  *              Version 1.0.4
  59  *              - avoid poss. locking when doing copy_to_user which may sleep
  60  *              - RDS is automatically activated on read now
  61  *              - code cleaned of unnecessary rds_commands
  62  *              - USB Vendor/Product ID for ADS/Tech FM Radio Receiver verified
  63  *                (thanks to Guillaume RAMOUSSE)
  64  * 2008-01-27   Tobias Lorenz <tobias.lorenz@gmx.net>
  65  *              Version 1.0.5
  66  *              - number of seek_retries changed to tune_timeout
  67  *              - fixed problem with incomplete tune operations by own buffers
  68  *              - optimization of variables and printf types
  69  *              - improved error logging
  70  * 2008-01-31   Tobias Lorenz <tobias.lorenz@gmx.net>
  71  *              Oliver Neukum <oliver@neukum.org>
  72  *              Version 1.0.6
  73  *              - fixed coverity checker warnings in *_usb_driver_disconnect
  74  *              - probe()/open() race by correct ordering in probe()
  75  *              - DMA coherency rules by separate allocation of all buffers
  76  *              - use of endianness macros
  77  *              - abuse of spinlock, replaced by mutex
  78  *              - racy handling of timer in disconnect,
  79  *                replaced by delayed_work
  80  *              - racy interruptible_sleep_on(),
  81  *                replaced with wait_event_interruptible()
  82  *              - handle signals in read()
  83  * 2008-02-08   Tobias Lorenz <tobias.lorenz@gmx.net>
  84  *              Oliver Neukum <oliver@neukum.org>
  85  *              Version 1.0.7
  86  *              - usb autosuspend support
  87  *              - unplugging fixed
  88  * 2008-05-07   Tobias Lorenz <tobias.lorenz@gmx.net>
  89  *              Version 1.0.8
  90  *              - hardware frequency seek support
  91  *              - afc indication
  92  *              - more safety checks, let si470x_get_freq return errno
  93  *              - vidioc behavior corrected according to v4l2 spec
  94  * 2008-10-20   Alexey Klimov <klimov.linux@gmail.com>
  95  *              - add support for KWorld USB FM Radio FM700
  96  *              - blacklisted KWorld radio in hid-core.c and hid-ids.h
  97  * 2008-12-03   Mark Lord <mlord@pobox.com>
  98  *              - add support for DealExtreme USB Radio
  99  * 2009-01-31   Bob Ross <pigiron@gmx.com>
 100  *              - correction of stereo detection/setting
 101  *              - correction of signal strength indicator scaling
 102  * 2009-01-31   Rick Bronson <rick@efn.org>
 103  *              Tobias Lorenz <tobias.lorenz@gmx.net>
 104  *              - add LED status output
 105  *              - get HW/SW version from scratchpad
 106  * 2009-06-16   Edouard Lafargue <edouard@lafargue.name>
 107  *              Version 1.0.10
 108  *              - add support for interrupt mode for RDS endpoint,
 109  *                instead of polling.
 110  *                Improves RDS reception significantly
 111  */
 112
 113
 114 /* kernel includes */
 115 #include "radio-si470x.h"
 116
 117
 118
 119 /**************************************************************************
 120  * Module Parameters
 121  **************************************************************************/
 122
 123 /* Spacing (kHz) */
 124 /* 0: 200 kHz (USA, Australia) */
 125 /* 1: 100 kHz (Europe, Japan) */
 126 /* 2:  50 kHz */
 127 static unsigned short space = 2;
 128 module_param(space, ushort, 0444);
 129 MODULE_PARM_DESC(space, "Spacing: 0=200kHz 1=100kHz *2=50kHz*");
 130
 131 /* De-emphasis */
 132 /* 0: 75 us (USA) */
 133 /* 1: 50 us (Europe, Australia, Japan) */
 134 static unsigned short de = 1;
 135 module_param(de, ushort, 0444);
 136 MODULE_PARM_DESC(de, "De-emphasis: 0=75us *1=50us*");
 137
 138 /* Tune timeout */
 139 static unsigned int tune_timeout = 3000;
 140 module_param(tune_timeout, uint, 0644);
 141 MODULE_PARM_DESC(tune_timeout, "Tune timeout: *3000*");
 142
 143 /* Seek timeout */
 144 static unsigned int seek_timeout = 5000;
 145 module_param(seek_timeout, uint, 0644);
 146 MODULE_PARM_DESC(seek_timeout, "Seek timeout: *5000*");
 147
 148 static const struct v4l2_frequency_band bands[] = {
 149         {
 150                 .type = V4L2_TUNER_RADIO,
 151                 .index = 0,
 152                 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
 153                             V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
 154                             V4L2_TUNER_CAP_FREQ_BANDS |
 155                             V4L2_TUNER_CAP_HWSEEK_BOUNDED |
 156                             V4L2_TUNER_CAP_HWSEEK_WRAP,
 157                 .rangelow   =  87500 * 16,
 158                 .rangehigh  = 108000 * 16,
 159                 .modulation = V4L2_BAND_MODULATION_FM,
 160         },
 161         {
 162                 .type = V4L2_TUNER_RADIO,
 163                 .index = 1,
 164                 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
 165                             V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
 166                             V4L2_TUNER_CAP_FREQ_BANDS |
 167                             V4L2_TUNER_CAP_HWSEEK_BOUNDED |
 168                             V4L2_TUNER_CAP_HWSEEK_WRAP,
 169                 .rangelow   =  76000 * 16,
 170                 .rangehigh  = 108000 * 16,
 171                 .modulation = V4L2_BAND_MODULATION_FM,
 172         },
 173         {
 174                 .type = V4L2_TUNER_RADIO,
 175                 .index = 2,
 176                 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
 177                             V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
 178                             V4L2_TUNER_CAP_FREQ_BANDS |
 179                             V4L2_TUNER_CAP_HWSEEK_BOUNDED |
 180                             V4L2_TUNER_CAP_HWSEEK_WRAP,
 181                 .rangelow   =  76000 * 16,
 182                 .rangehigh  =  90000 * 16,
 183                 .modulation = V4L2_BAND_MODULATION_FM,
 184         },
 185 };
 186
 187 /**************************************************************************
 188  * Generic Functions
 189  **************************************************************************/
 190
 191 /*
 192  * si470x_set_band - set the band
 193  */
 194 static int si470x_set_band(struct si470x_device *radio, int band)
 195 {
 196         if (radio->band == band)
 197                 return 0;
 198
 199         radio->band = band;
 200         radio->registers[SYSCONFIG2] &= ~SYSCONFIG2_BAND;
 201         radio->registers[SYSCONFIG2] |= radio->band << 6;
 202         return si470x_set_register(radio, SYSCONFIG2);
 203 }
 204
 205 /*
 206  * si470x_set_chan - set the channel
 207  */
 208 static int si470x_set_chan(struct si470x_device *radio, unsigned short chan)
 209 {
 210         int retval;
 211         unsigned long time_left;
 212         bool timed_out = false;
 213
 214         /* start tuning */
 215         radio->registers[CHANNEL] &= ~CHANNEL_CHAN;
 216         radio->registers[CHANNEL] |= CHANNEL_TUNE | chan;
 217         retval = si470x_set_register(radio, CHANNEL);
 218         if (retval < 0)
 219                 goto done;
 220
 221         /* wait till tune operation has completed */
 222         reinit_completion(&radio->completion);
 223         time_left = wait_for_completion_timeout(&radio->completion,
 224                                                 msecs_to_jiffies(tune_timeout));
 225         if (time_left == 0)
 226                 timed_out = true;
 227
 228         if ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0)
 229                 dev_warn(&radio->videodev.dev, "tune does not complete\n");
 230         if (timed_out)
 231                 dev_warn(&radio->videodev.dev,
 232                         "tune timed out after %u ms\n", tune_timeout);
 233
 234         /* stop tuning */
 235         radio->registers[CHANNEL] &= ~CHANNEL_TUNE;
 236         retval = si470x_set_register(radio, CHANNEL);
 237
 238 done:
 239         return retval;
 240 }
 241
 242 /*
 243  * si470x_get_step - get channel spacing
 244  */
 245 static unsigned int si470x_get_step(struct si470x_device *radio)
 246 {
 247         /* Spacing (kHz) */
 248         switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_SPACE) >> 4) {
 249         /* 0: 200 kHz (USA, Australia) */
 250         case 0:
 251                 return 200 * 16;
 252         /* 1: 100 kHz (Europe, Japan) */
 253         case 1:
 254                 return 100 * 16;
 255         /* 2:  50 kHz */
 256         default:
 257                 return 50 * 16;
 258         }
 259 }
 260
 261
 262 /*
 263  * si470x_get_freq - get the frequency
 264  */
 265 static int si470x_get_freq(struct si470x_device *radio, unsigned int *freq)
 266 {
 267         int chan, retval;
 268
 269         /* read channel */
 270         retval = si470x_get_register(radio, READCHAN);
 271         chan = radio->registers[READCHAN] & READCHAN_READCHAN;
 272
 273         /* Frequency (MHz) = Spacing (kHz) x Channel + Bottom of Band (MHz) */
 274         *freq = chan * si470x_get_step(radio) + bands[radio->band].rangelow;
 275
 276         return retval;
 277 }
 278
 279
 280 /*
 281  * si470x_set_freq - set the frequency
 282  */
 283 int si470x_set_freq(struct si470x_device *radio, unsigned int freq)
 284 {
 285         unsigned short chan;
 286
 287         freq = clamp(freq, bands[radio->band].rangelow,
 288                            bands[radio->band].rangehigh);
 289         /* Chan = [ Freq (Mhz) - Bottom of Band (MHz) ] / Spacing (kHz) */
 290         chan = (freq - bands[radio->band].rangelow) / si470x_get_step(radio);
 291
 292         return si470x_set_chan(radio, chan);
 293 }
 294
 295
 296 /*
 297  * si470x_set_seek - set seek
 298  */
 299 static int si470x_set_seek(struct si470x_device *radio,
 300                            const struct v4l2_hw_freq_seek *seek)
 301 {
 302         int band, retval;
 303         unsigned int freq;
 304         bool timed_out = false;
 305         unsigned long time_left;
 306
 307         /* set band */
 308         if (seek->rangelow || seek->rangehigh) {
 309                 for (band = 0; band < ARRAY_SIZE(bands); band++) {
 310                         if (bands[band].rangelow  == seek->rangelow &&
 311                             bands[band].rangehigh == seek->rangehigh)
 312                                 break;
 313                 }
 314                 if (band == ARRAY_SIZE(bands))
 315                         return -EINVAL; /* No matching band found */
 316         } else
 317                 band = 1; /* If nothing is specified seek 76 - 108 Mhz */
 318
 319         if (radio->band != band) {
 320                 retval = si470x_get_freq(radio, &freq);
 321                 if (retval)
 322                         return retval;
 323                 retval = si470x_set_band(radio, band);
 324                 if (retval)
 325                         return retval;
 326                 retval = si470x_set_freq(radio, freq);
 327                 if (retval)
 328                         return retval;
 329         }
 330
 331         /* start seeking */
 332         radio->registers[POWERCFG] |= POWERCFG_SEEK;
 333         if (seek->wrap_around)
 334                 radio->registers[POWERCFG] &= ~POWERCFG_SKMODE;
 335         else
 336                 radio->registers[POWERCFG] |= POWERCFG_SKMODE;
 337         if (seek->seek_upward)
 338                 radio->registers[POWERCFG] |= POWERCFG_SEEKUP;
 339         else
 340                 radio->registers[POWERCFG] &= ~POWERCFG_SEEKUP;
 341         retval = si470x_set_register(radio, POWERCFG);
 342         if (retval < 0)
 343                 return retval;
 344
 345         /* wait till tune operation has completed */
 346         reinit_completion(&radio->completion);
 347         time_left = wait_for_completion_timeout(&radio->completion,
 348                                                 msecs_to_jiffies(seek_timeout));
 349         if (time_left == 0)
 350                 timed_out = true;
 351
 352         if ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0)
 353                 dev_warn(&radio->videodev.dev, "seek does not complete\n");
 354         if (radio->registers[STATUSRSSI] & STATUSRSSI_SF)
 355                 dev_warn(&radio->videodev.dev,
 356                         "seek failed / band limit reached\n");
 357
 358         /* stop seeking */
 359         radio->registers[POWERCFG] &= ~POWERCFG_SEEK;
 360         retval = si470x_set_register(radio, POWERCFG);
 361
 362         /* try again, if timed out */
 363         if (retval == 0 && timed_out)
 364                 return -ENODATA;
 365         return retval;
 366 }
 367
 368
 369 /*
 370  * si470x_start - switch on radio
 371  */
 372 int si470x_start(struct si470x_device *radio)
 373 {
 374         int retval;
 375
 376         /* powercfg */
 377         radio->registers[POWERCFG] =
 378                 POWERCFG_DMUTE | POWERCFG_ENABLE | POWERCFG_RDSM;
 379         retval = si470x_set_register(radio, POWERCFG);
 380         if (retval < 0)
 381                 goto done;
 382
 383         /* sysconfig 1 */
 384         radio->registers[SYSCONFIG1] =
 385                 (de << 11) & SYSCONFIG1_DE;             /* DE*/
 386         retval = si470x_set_register(radio, SYSCONFIG1);
 387         if (retval < 0)
 388                 goto done;
 389
 390         /* sysconfig 2 */
 391         radio->registers[SYSCONFIG2] =
 392                 (0x1f  << 8) |                          /* SEEKTH */
 393                 ((radio->band << 6) & SYSCONFIG2_BAND) |/* BAND */
 394                 ((space << 4) & SYSCONFIG2_SPACE) |     /* SPACE */
 395                 15;                                     /* VOLUME (max) */
 396         retval = si470x_set_register(radio, SYSCONFIG2);
 397         if (retval < 0)
 398                 goto done;
 399
 400         /* reset last channel */
 401         retval = si470x_set_chan(radio,
 402                 radio->registers[CHANNEL] & CHANNEL_CHAN);
 403
 404 done:
 405         return retval;
 406 }
 407
 408
 409 /*
 410  * si470x_stop - switch off radio
 411  */
 412 int si470x_stop(struct si470x_device *radio)
 413 {
 414         int retval;
 415
 416         /* sysconfig 1 */
 417         radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS;
 418         retval = si470x_set_register(radio, SYSCONFIG1);
 419         if (retval < 0)
 420                 goto done;
 421
 422         /* powercfg */
 423         radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
 424         /* POWERCFG_ENABLE has to automatically go low */
 425         radio->registers[POWERCFG] |= POWERCFG_ENABLE | POWERCFG_DISABLE;
 426         retval = si470x_set_register(radio, POWERCFG);
 427
 428 done:
 429         return retval;
 430 }
 431
 432
 433 /*
 434  * si470x_rds_on - switch on rds reception
 435  */
 436 static int si470x_rds_on(struct si470x_device *radio)
 437 {
 438         int retval;
 439
 440         /* sysconfig 1 */
 441         radio->registers[SYSCONFIG1] |= SYSCONFIG1_RDS;
 442         retval = si470x_set_register(radio, SYSCONFIG1);
 443         if (retval < 0)
 444                 radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS;
 445
 446         return retval;
 447 }
 448
 449
 450
 451 /**************************************************************************
 452  * File Operations Interface
 453  **************************************************************************/
 454
 455 /*
 456  * si470x_fops_read - read RDS data
 457  */
 458 static ssize_t si470x_fops_read(struct file *file, char __user *buf,
 459                 size_t count, loff_t *ppos)
 460 {
 461         struct si470x_device *radio = video_drvdata(file);
 462         int retval = 0;
 463         unsigned int block_count = 0;
 464
 465         /* switch on rds reception */
 466         if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
 467                 si470x_rds_on(radio);
 468
 469         /* block if no new data available */
 470         while (radio->wr_index == radio->rd_index) {
 471                 if (file->f_flags & O_NONBLOCK) {
 472                         retval = -EWOULDBLOCK;
 473                         goto done;
 474                 }
 475                 if (wait_event_interruptible(radio->read_queue,
 476                         radio->wr_index != radio->rd_index) < 0) {
 477                         retval = -EINTR;
 478                         goto done;
 479                 }
 480         }
 481
 482         /* calculate block count from byte count */
 483         count /= 3;
 484
 485         /* copy RDS block out of internal buffer and to user buffer */
 486         while (block_count < count) {
 487                 if (radio->rd_index == radio->wr_index)
 488                         break;
 489
 490                 /* always transfer rds complete blocks */
 491                 if (copy_to_user(buf, &radio->buffer[radio->rd_index], 3))
 492                         /* retval = -EFAULT; */
 493                         break;
 494
 495                 /* increment and wrap read pointer */
 496                 radio->rd_index += 3;
 497                 if (radio->rd_index >= radio->buf_size)
 498                         radio->rd_index = 0;
 499
 500                 /* increment counters */
 501                 block_count++;
 502                 buf += 3;
 503                 retval += 3;
 504         }
 505
 506 done:
 507         return retval;
 508 }
 509
 510
 511 /*
 512  * si470x_fops_poll - poll RDS data
 513  */
 514 static unsigned int si470x_fops_poll(struct file *file,
 515                 struct poll_table_struct *pts)
 516 {
 517         struct si470x_device *radio = video_drvdata(file);
 518         unsigned long req_events = poll_requested_events(pts);
 519         int retval = v4l2_ctrl_poll(file, pts);
 520
 521         if (req_events & (POLLIN | POLLRDNORM)) {
 522                 /* switch on rds reception */
 523                 if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
 524                         si470x_rds_on(radio);
 525
 526                 poll_wait(file, &radio->read_queue, pts);
 527
 528                 if (radio->rd_index != radio->wr_index)
 529                         retval |= POLLIN | POLLRDNORM;
 530         }
 531
 532         return retval;
 533 }
 534
 535
 536 /*
 537  * si470x_fops - file operations interface
 538  */
 539 static const struct v4l2_file_operations si470x_fops = {
 540         .owner                  = THIS_MODULE,
 541         .read                   = si470x_fops_read,
 542         .poll                   = si470x_fops_poll,
 543         .unlocked_ioctl         = video_ioctl2,
 544         .open                   = si470x_fops_open,
 545         .release                = si470x_fops_release,
 546 };
 547
 548
 549
 550 /**************************************************************************
 551  * Video4Linux Interface
 552  **************************************************************************/
 553
 554
 555 static int si470x_s_ctrl(struct v4l2_ctrl *ctrl)
 556 {
 557         struct si470x_device *radio =
 558                 container_of(ctrl->handler, struct si470x_device, hdl);
 559
 560         switch (ctrl->id) {
 561         case V4L2_CID_AUDIO_VOLUME:
 562                 radio->registers[SYSCONFIG2] &= ~SYSCONFIG2_VOLUME;
 563                 radio->registers[SYSCONFIG2] |= ctrl->val;
 564                 return si470x_set_register(radio, SYSCONFIG2);
 565         case V4L2_CID_AUDIO_MUTE:
 566                 if (ctrl->val)
 567                         radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
 568                 else
 569                         radio->registers[POWERCFG] |= POWERCFG_DMUTE;
 570                 return si470x_set_register(radio, POWERCFG);
 571         default:
 572                 return -EINVAL;
 573         }
 574 }
 575
 576
 577 /*
 578  * si470x_vidioc_g_tuner - get tuner attributes
 579  */
 580 static int si470x_vidioc_g_tuner(struct file *file, void *priv,
 581                 struct v4l2_tuner *tuner)
 582 {
 583         struct si470x_device *radio = video_drvdata(file);
 584         int retval = 0;
 585
 586         if (tuner->index != 0)
 587                 return -EINVAL;
 588
 589         if (!radio->status_rssi_auto_update) {
 590                 retval = si470x_get_register(radio, STATUSRSSI);
 591                 if (retval < 0)
 592                         return retval;
 593         }
 594
 595         /* driver constants */
 596         strcpy(tuner->name, "FM");
 597         tuner->type = V4L2_TUNER_RADIO;
 598         tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
 599                             V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO |
 600                             V4L2_TUNER_CAP_HWSEEK_BOUNDED |
 601                             V4L2_TUNER_CAP_HWSEEK_WRAP;
 602         tuner->rangelow  =  76 * FREQ_MUL;
 603         tuner->rangehigh = 108 * FREQ_MUL;
 604
 605         /* stereo indicator == stereo (instead of mono) */
 606         if ((radio->registers[STATUSRSSI] & STATUSRSSI_ST) == 0)
 607                 tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
 608         else
 609                 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
 610         /* If there is a reliable method of detecting an RDS channel,
 611            then this code should check for that before setting this
 612            RDS subchannel. */
 613         tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
 614
 615         /* mono/stereo selector */
 616         if ((radio->registers[POWERCFG] & POWERCFG_MONO) == 0)
 617                 tuner->audmode = V4L2_TUNER_MODE_STEREO;
 618         else
 619                 tuner->audmode = V4L2_TUNER_MODE_MONO;
 620
 621         /* min is worst, max is best; signal:0..0xffff; rssi: 0..0xff */
 622         /* measured in units of dbµV in 1 db increments (max at ~75 dbµV) */
 623         tuner->signal = (radio->registers[STATUSRSSI] & STATUSRSSI_RSSI);
 624         /* the ideal factor is 0xffff/75 = 873,8 */
 625         tuner->signal = (tuner->signal * 873) + (8 * tuner->signal / 10);
 626         if (tuner->signal > 0xffff)
 627                 tuner->signal = 0xffff;
 628
 629         /* automatic frequency control: -1: freq to low, 1 freq to high */
 630         /* AFCRL does only indicate that freq. differs, not if too low/high */
 631         tuner->afc = (radio->registers[STATUSRSSI] & STATUSRSSI_AFCRL) ? 1 : 0;
 632
 633         return retval;
 634 }
 635
 636
 637 /*
 638  * si470x_vidioc_s_tuner - set tuner attributes
 639  */
 640 static int si470x_vidioc_s_tuner(struct file *file, void *priv,
 641                 const struct v4l2_tuner *tuner)
 642 {
 643         struct si470x_device *radio = video_drvdata(file);
 644
 645         if (tuner->index != 0)
 646                 return -EINVAL;
 647
 648         /* mono/stereo selector */
 649         switch (tuner->audmode) {
 650         case V4L2_TUNER_MODE_MONO:
 651                 radio->registers[POWERCFG] |= POWERCFG_MONO;  /* force mono */
 652                 break;
 653         case V4L2_TUNER_MODE_STEREO:
 654         default:
 655                 radio->registers[POWERCFG] &= ~POWERCFG_MONO; /* try stereo */
 656                 break;
 657         }
 658
 659         return si470x_set_register(radio, POWERCFG);
 660 }
 661
 662
 663 /*
 664  * si470x_vidioc_g_frequency - get tuner or modulator radio frequency
 665  */
 666 static int si470x_vidioc_g_frequency(struct file *file, void *priv,
 667                 struct v4l2_frequency *freq)
 668 {
 669         struct si470x_device *radio = video_drvdata(file);
 670
 671         if (freq->tuner != 0)
 672                 return -EINVAL;
 673
 674         freq->type = V4L2_TUNER_RADIO;
 675         return si470x_get_freq(radio, &freq->frequency);
 676 }
 677
 678
 679 /*
 680  * si470x_vidioc_s_frequency - set tuner or modulator radio frequency
 681  */
 682 static int si470x_vidioc_s_frequency(struct file *file, void *priv,
 683                 const struct v4l2_frequency *freq)
 684 {
 685         struct si470x_device *radio = video_drvdata(file);
 686         int retval;
 687
 688         if (freq->tuner != 0)
 689                 return -EINVAL;
 690
 691         if (freq->frequency < bands[radio->band].rangelow ||
 692             freq->frequency > bands[radio->band].rangehigh) {
 693                 /* Switch to band 1 which covers everything we support */
 694                 retval = si470x_set_band(radio, 1);
 695                 if (retval)
 696                         return retval;
 697         }
 698         return si470x_set_freq(radio, freq->frequency);
 699 }
 700
 701
 702 /*
 703  * si470x_vidioc_s_hw_freq_seek - set hardware frequency seek
 704  */
 705 static int si470x_vidioc_s_hw_freq_seek(struct file *file, void *priv,
 706                 const struct v4l2_hw_freq_seek *seek)
 707 {
 708         struct si470x_device *radio = video_drvdata(file);
 709
 710         if (seek->tuner != 0)
 711                 return -EINVAL;
 712
 713         if (file->f_flags & O_NONBLOCK)
 714                 return -EWOULDBLOCK;
 715
 716         return si470x_set_seek(radio, seek);
 717 }
 718
 719 /*
 720  * si470x_vidioc_enum_freq_bands - enumerate supported bands
 721  */
 722 static int si470x_vidioc_enum_freq_bands(struct file *file, void *priv,
 723                                          struct v4l2_frequency_band *band)
 724 {
 725         if (band->tuner != 0)
 726                 return -EINVAL;
 727         if (band->index >= ARRAY_SIZE(bands))
 728                 return -EINVAL;
 729         *band = bands[band->index];
 730         return 0;
 731 }
 732
 733 const struct v4l2_ctrl_ops si470x_ctrl_ops = {
 734         .s_ctrl = si470x_s_ctrl,
 735 };
 736
 737 /*
 738  * si470x_ioctl_ops - video device ioctl operations
 739  */
 740 static const struct v4l2_ioctl_ops si470x_ioctl_ops = {
 741         .vidioc_querycap        = si470x_vidioc_querycap,
 742         .vidioc_g_tuner         = si470x_vidioc_g_tuner,
 743         .vidioc_s_tuner         = si470x_vidioc_s_tuner,
 744         .vidioc_g_frequency     = si470x_vidioc_g_frequency,
 745         .vidioc_s_frequency     = si470x_vidioc_s_frequency,
 746         .vidioc_s_hw_freq_seek  = si470x_vidioc_s_hw_freq_seek,
 747         .vidioc_enum_freq_bands = si470x_vidioc_enum_freq_bands,
 748         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
 749         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 750 };
 751
 752
 753 /*
 754  * si470x_viddev_template - video device interface
 755  */
 756 struct video_device si470x_viddev_template = {
 757         .fops                   = &si470x_fops,
 758         .name                   = DRIVER_NAME,
 759         .release                = video_device_release_empty,
 760         .ioctl_ops              = &si470x_ioctl_ops,
 761 };