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 bool timed_out = 0; 212 213 /* start tuning */ 214 radio->registers[CHANNEL] &= ~CHANNEL_CHAN; 215 radio->registers[CHANNEL] |= CHANNEL_TUNE | chan; 216 retval = si470x_set_register(radio, CHANNEL); 217 if (retval < 0) 218 goto done; 219 220 /* wait till tune operation has completed */ 221 INIT_COMPLETION(radio->completion); 222 retval = wait_for_completion_timeout(&radio->completion, 223 msecs_to_jiffies(tune_timeout)); 224 if (!retval) 225 timed_out = true; 226 227 if ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0) 228 dev_warn(&radio->videodev.dev, "tune does not complete\n"); 229 if (timed_out) 230 dev_warn(&radio->videodev.dev, 231 "tune timed out after %u ms\n", tune_timeout); 232 233 /* stop tuning */ 234 radio->registers[CHANNEL] &= ~CHANNEL_TUNE; 235 retval = si470x_set_register(radio, CHANNEL); 236 237 done: 238 return retval; 239 } 240 241 /* 242 * si470x_get_step - get channel spacing 243 */ 244 static unsigned int si470x_get_step(struct si470x_device *radio) 245 { 246 /* Spacing (kHz) */ 247 switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_SPACE) >> 4) { 248 /* 0: 200 kHz (USA, Australia) */ 249 case 0: 250 return 200 * 16; 251 /* 1: 100 kHz (Europe, Japan) */ 252 case 1: 253 return 100 * 16; 254 /* 2: 50 kHz */ 255 default: 256 return 50 * 16; 257 }; 258 } 259 260 261 /* 262 * si470x_get_freq - get the frequency 263 */ 264 static int si470x_get_freq(struct si470x_device *radio, unsigned int *freq) 265 { 266 int chan, retval; 267 268 /* read channel */ 269 retval = si470x_get_register(radio, READCHAN); 270 chan = radio->registers[READCHAN] & READCHAN_READCHAN; 271 272 /* Frequency (MHz) = Spacing (kHz) x Channel + Bottom of Band (MHz) */ 273 *freq = chan * si470x_get_step(radio) + bands[radio->band].rangelow; 274 275 return retval; 276 } 277 278 279 /* 280 * si470x_set_freq - set the frequency 281 */ 282 int si470x_set_freq(struct si470x_device *radio, unsigned int freq) 283 { 284 unsigned short chan; 285 286 freq = clamp(freq, bands[radio->band].rangelow, 287 bands[radio->band].rangehigh); 288 /* Chan = [ Freq (Mhz) - Bottom of Band (MHz) ] / Spacing (kHz) */ 289 chan = (freq - bands[radio->band].rangelow) / si470x_get_step(radio); 290 291 return si470x_set_chan(radio, chan); 292 } 293 294 295 /* 296 * si470x_set_seek - set seek 297 */ 298 static int si470x_set_seek(struct si470x_device *radio, 299 struct v4l2_hw_freq_seek *seek) 300 { 301 int band, retval; 302 unsigned int freq; 303 bool timed_out = 0; 304 305 /* set band */ 306 if (seek->rangelow || seek->rangehigh) { 307 for (band = 0; band < ARRAY_SIZE(bands); band++) { 308 if (bands[band].rangelow == seek->rangelow && 309 bands[band].rangehigh == seek->rangehigh) 310 break; 311 } 312 if (band == ARRAY_SIZE(bands)) 313 return -EINVAL; /* No matching band found */ 314 } else 315 band = 1; /* If nothing is specified seek 76 - 108 Mhz */ 316 317 if (radio->band != band) { 318 retval = si470x_get_freq(radio, &freq); 319 if (retval) 320 return retval; 321 retval = si470x_set_band(radio, band); 322 if (retval) 323 return retval; 324 retval = si470x_set_freq(radio, freq); 325 if (retval) 326 return retval; 327 } 328 329 /* start seeking */ 330 radio->registers[POWERCFG] |= POWERCFG_SEEK; 331 if (seek->wrap_around) 332 radio->registers[POWERCFG] &= ~POWERCFG_SKMODE; 333 else 334 radio->registers[POWERCFG] |= POWERCFG_SKMODE; 335 if (seek->seek_upward) 336 radio->registers[POWERCFG] |= POWERCFG_SEEKUP; 337 else 338 radio->registers[POWERCFG] &= ~POWERCFG_SEEKUP; 339 retval = si470x_set_register(radio, POWERCFG); 340 if (retval < 0) 341 return retval; 342 343 /* wait till tune operation has completed */ 344 INIT_COMPLETION(radio->completion); 345 retval = wait_for_completion_timeout(&radio->completion, 346 msecs_to_jiffies(seek_timeout)); 347 if (!retval) 348 timed_out = true; 349 350 if ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0) 351 dev_warn(&radio->videodev.dev, "seek does not complete\n"); 352 if (radio->registers[STATUSRSSI] & STATUSRSSI_SF) 353 dev_warn(&radio->videodev.dev, 354 "seek failed / band limit reached\n"); 355 356 /* stop seeking */ 357 radio->registers[POWERCFG] &= ~POWERCFG_SEEK; 358 retval = si470x_set_register(radio, POWERCFG); 359 360 /* try again, if timed out */ 361 if (retval == 0 && timed_out) 362 return -ENODATA; 363 return retval; 364 } 365 366 367 /* 368 * si470x_start - switch on radio 369 */ 370 int si470x_start(struct si470x_device *radio) 371 { 372 int retval; 373 374 /* powercfg */ 375 radio->registers[POWERCFG] = 376 POWERCFG_DMUTE | POWERCFG_ENABLE | POWERCFG_RDSM; 377 retval = si470x_set_register(radio, POWERCFG); 378 if (retval < 0) 379 goto done; 380 381 /* sysconfig 1 */ 382 radio->registers[SYSCONFIG1] = 383 (de << 11) & SYSCONFIG1_DE; /* DE*/ 384 retval = si470x_set_register(radio, SYSCONFIG1); 385 if (retval < 0) 386 goto done; 387 388 /* sysconfig 2 */ 389 radio->registers[SYSCONFIG2] = 390 (0x1f << 8) | /* SEEKTH */ 391 ((radio->band << 6) & SYSCONFIG2_BAND) |/* BAND */ 392 ((space << 4) & SYSCONFIG2_SPACE) | /* SPACE */ 393 15; /* VOLUME (max) */ 394 retval = si470x_set_register(radio, SYSCONFIG2); 395 if (retval < 0) 396 goto done; 397 398 /* reset last channel */ 399 retval = si470x_set_chan(radio, 400 radio->registers[CHANNEL] & CHANNEL_CHAN); 401 402 done: 403 return retval; 404 } 405 406 407 /* 408 * si470x_stop - switch off radio 409 */ 410 int si470x_stop(struct si470x_device *radio) 411 { 412 int retval; 413 414 /* sysconfig 1 */ 415 radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS; 416 retval = si470x_set_register(radio, SYSCONFIG1); 417 if (retval < 0) 418 goto done; 419 420 /* powercfg */ 421 radio->registers[POWERCFG] &= ~POWERCFG_DMUTE; 422 /* POWERCFG_ENABLE has to automatically go low */ 423 radio->registers[POWERCFG] |= POWERCFG_ENABLE | POWERCFG_DISABLE; 424 retval = si470x_set_register(radio, POWERCFG); 425 426 done: 427 return retval; 428 } 429 430 431 /* 432 * si470x_rds_on - switch on rds reception 433 */ 434 static int si470x_rds_on(struct si470x_device *radio) 435 { 436 int retval; 437 438 /* sysconfig 1 */ 439 radio->registers[SYSCONFIG1] |= SYSCONFIG1_RDS; 440 retval = si470x_set_register(radio, SYSCONFIG1); 441 if (retval < 0) 442 radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS; 443 444 return retval; 445 } 446 447 448 449 /************************************************************************** 450 * File Operations Interface 451 **************************************************************************/ 452 453 /* 454 * si470x_fops_read - read RDS data 455 */ 456 static ssize_t si470x_fops_read(struct file *file, char __user *buf, 457 size_t count, loff_t *ppos) 458 { 459 struct si470x_device *radio = video_drvdata(file); 460 int retval = 0; 461 unsigned int block_count = 0; 462 463 /* switch on rds reception */ 464 if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0) 465 si470x_rds_on(radio); 466 467 /* block if no new data available */ 468 while (radio->wr_index == radio->rd_index) { 469 if (file->f_flags & O_NONBLOCK) { 470 retval = -EWOULDBLOCK; 471 goto done; 472 } 473 if (wait_event_interruptible(radio->read_queue, 474 radio->wr_index != radio->rd_index) < 0) { 475 retval = -EINTR; 476 goto done; 477 } 478 } 479 480 /* calculate block count from byte count */ 481 count /= 3; 482 483 /* copy RDS block out of internal buffer and to user buffer */ 484 while (block_count < count) { 485 if (radio->rd_index == radio->wr_index) 486 break; 487 488 /* always transfer rds complete blocks */ 489 if (copy_to_user(buf, &radio->buffer[radio->rd_index], 3)) 490 /* retval = -EFAULT; */ 491 break; 492 493 /* increment and wrap read pointer */ 494 radio->rd_index += 3; 495 if (radio->rd_index >= radio->buf_size) 496 radio->rd_index = 0; 497 498 /* increment counters */ 499 block_count++; 500 buf += 3; 501 retval += 3; 502 } 503 504 done: 505 return retval; 506 } 507 508 509 /* 510 * si470x_fops_poll - poll RDS data 511 */ 512 static unsigned int si470x_fops_poll(struct file *file, 513 struct poll_table_struct *pts) 514 { 515 struct si470x_device *radio = video_drvdata(file); 516 unsigned long req_events = poll_requested_events(pts); 517 int retval = v4l2_ctrl_poll(file, pts); 518 519 if (req_events & (POLLIN | POLLRDNORM)) { 520 /* switch on rds reception */ 521 if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0) 522 si470x_rds_on(radio); 523 524 poll_wait(file, &radio->read_queue, pts); 525 526 if (radio->rd_index != radio->wr_index) 527 retval |= POLLIN | POLLRDNORM; 528 } 529 530 return retval; 531 } 532 533 534 /* 535 * si470x_fops - file operations interface 536 */ 537 static const struct v4l2_file_operations si470x_fops = { 538 .owner = THIS_MODULE, 539 .read = si470x_fops_read, 540 .poll = si470x_fops_poll, 541 .unlocked_ioctl = video_ioctl2, 542 .open = si470x_fops_open, 543 .release = si470x_fops_release, 544 }; 545 546 547 548 /************************************************************************** 549 * Video4Linux Interface 550 **************************************************************************/ 551 552 553 static int si470x_s_ctrl(struct v4l2_ctrl *ctrl) 554 { 555 struct si470x_device *radio = 556 container_of(ctrl->handler, struct si470x_device, hdl); 557 558 switch (ctrl->id) { 559 case V4L2_CID_AUDIO_VOLUME: 560 radio->registers[SYSCONFIG2] &= ~SYSCONFIG2_VOLUME; 561 radio->registers[SYSCONFIG2] |= ctrl->val; 562 return si470x_set_register(radio, SYSCONFIG2); 563 case V4L2_CID_AUDIO_MUTE: 564 if (ctrl->val) 565 radio->registers[POWERCFG] &= ~POWERCFG_DMUTE; 566 else 567 radio->registers[POWERCFG] |= POWERCFG_DMUTE; 568 return si470x_set_register(radio, POWERCFG); 569 default: 570 return -EINVAL; 571 } 572 } 573 574 575 /* 576 * si470x_vidioc_g_tuner - get tuner attributes 577 */ 578 static int si470x_vidioc_g_tuner(struct file *file, void *priv, 579 struct v4l2_tuner *tuner) 580 { 581 struct si470x_device *radio = video_drvdata(file); 582 int retval = 0; 583 584 if (tuner->index != 0) 585 return -EINVAL; 586 587 if (!radio->status_rssi_auto_update) { 588 retval = si470x_get_register(radio, STATUSRSSI); 589 if (retval < 0) 590 return retval; 591 } 592 593 /* driver constants */ 594 strcpy(tuner->name, "FM"); 595 tuner->type = V4L2_TUNER_RADIO; 596 tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO | 597 V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_BLOCK_IO | 598 V4L2_TUNER_CAP_HWSEEK_BOUNDED | 599 V4L2_TUNER_CAP_HWSEEK_WRAP; 600 tuner->rangelow = 76 * FREQ_MUL; 601 tuner->rangehigh = 108 * FREQ_MUL; 602 603 /* stereo indicator == stereo (instead of mono) */ 604 if ((radio->registers[STATUSRSSI] & STATUSRSSI_ST) == 0) 605 tuner->rxsubchans = V4L2_TUNER_SUB_MONO; 606 else 607 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO; 608 /* If there is a reliable method of detecting an RDS channel, 609 then this code should check for that before setting this 610 RDS subchannel. */ 611 tuner->rxsubchans |= V4L2_TUNER_SUB_RDS; 612 613 /* mono/stereo selector */ 614 if ((radio->registers[POWERCFG] & POWERCFG_MONO) == 0) 615 tuner->audmode = V4L2_TUNER_MODE_STEREO; 616 else 617 tuner->audmode = V4L2_TUNER_MODE_MONO; 618 619 /* min is worst, max is best; signal:0..0xffff; rssi: 0..0xff */ 620 /* measured in units of dbµV in 1 db increments (max at ~75 dbµV) */ 621 tuner->signal = (radio->registers[STATUSRSSI] & STATUSRSSI_RSSI); 622 /* the ideal factor is 0xffff/75 = 873,8 */ 623 tuner->signal = (tuner->signal * 873) + (8 * tuner->signal / 10); 624 if (tuner->signal > 0xffff) 625 tuner->signal = 0xffff; 626 627 /* automatic frequency control: -1: freq to low, 1 freq to high */ 628 /* AFCRL does only indicate that freq. differs, not if too low/high */ 629 tuner->afc = (radio->registers[STATUSRSSI] & STATUSRSSI_AFCRL) ? 1 : 0; 630 631 return retval; 632 } 633 634 635 /* 636 * si470x_vidioc_s_tuner - set tuner attributes 637 */ 638 static int si470x_vidioc_s_tuner(struct file *file, void *priv, 639 struct v4l2_tuner *tuner) 640 { 641 struct si470x_device *radio = video_drvdata(file); 642 643 if (tuner->index != 0) 644 return -EINVAL; 645 646 /* mono/stereo selector */ 647 switch (tuner->audmode) { 648 case V4L2_TUNER_MODE_MONO: 649 radio->registers[POWERCFG] |= POWERCFG_MONO; /* force mono */ 650 break; 651 case V4L2_TUNER_MODE_STEREO: 652 default: 653 radio->registers[POWERCFG] &= ~POWERCFG_MONO; /* try stereo */ 654 break; 655 } 656 657 return si470x_set_register(radio, POWERCFG); 658 } 659 660 661 /* 662 * si470x_vidioc_g_frequency - get tuner or modulator radio frequency 663 */ 664 static int si470x_vidioc_g_frequency(struct file *file, void *priv, 665 struct v4l2_frequency *freq) 666 { 667 struct si470x_device *radio = video_drvdata(file); 668 669 if (freq->tuner != 0) 670 return -EINVAL; 671 672 freq->type = V4L2_TUNER_RADIO; 673 return si470x_get_freq(radio, &freq->frequency); 674 } 675 676 677 /* 678 * si470x_vidioc_s_frequency - set tuner or modulator radio frequency 679 */ 680 static int si470x_vidioc_s_frequency(struct file *file, void *priv, 681 struct v4l2_frequency *freq) 682 { 683 struct si470x_device *radio = video_drvdata(file); 684 int retval; 685 686 if (freq->tuner != 0) 687 return -EINVAL; 688 689 if (freq->frequency < bands[radio->band].rangelow || 690 freq->frequency > bands[radio->band].rangehigh) { 691 /* Switch to band 1 which covers everything we support */ 692 retval = si470x_set_band(radio, 1); 693 if (retval) 694 return retval; 695 } 696 return si470x_set_freq(radio, freq->frequency); 697 } 698 699 700 /* 701 * si470x_vidioc_s_hw_freq_seek - set hardware frequency seek 702 */ 703 static int si470x_vidioc_s_hw_freq_seek(struct file *file, void *priv, 704 struct v4l2_hw_freq_seek *seek) 705 { 706 struct si470x_device *radio = video_drvdata(file); 707 708 if (seek->tuner != 0) 709 return -EINVAL; 710 711 return si470x_set_seek(radio, seek); 712 } 713 714 /* 715 * si470x_vidioc_enum_freq_bands - enumerate supported bands 716 */ 717 static int si470x_vidioc_enum_freq_bands(struct file *file, void *priv, 718 struct v4l2_frequency_band *band) 719 { 720 if (band->tuner != 0) 721 return -EINVAL; 722 if (band->index >= ARRAY_SIZE(bands)) 723 return -EINVAL; 724 *band = bands[band->index]; 725 return 0; 726 } 727 728 const struct v4l2_ctrl_ops si470x_ctrl_ops = { 729 .s_ctrl = si470x_s_ctrl, 730 }; 731 732 /* 733 * si470x_ioctl_ops - video device ioctl operations 734 */ 735 static const struct v4l2_ioctl_ops si470x_ioctl_ops = { 736 .vidioc_querycap = si470x_vidioc_querycap, 737 .vidioc_g_tuner = si470x_vidioc_g_tuner, 738 .vidioc_s_tuner = si470x_vidioc_s_tuner, 739 .vidioc_g_frequency = si470x_vidioc_g_frequency, 740 .vidioc_s_frequency = si470x_vidioc_s_frequency, 741 .vidioc_s_hw_freq_seek = si470x_vidioc_s_hw_freq_seek, 742 .vidioc_enum_freq_bands = si470x_vidioc_enum_freq_bands, 743 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 744 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 745 }; 746 747 748 /* 749 * si470x_viddev_template - video device interface 750 */ 751 struct video_device si470x_viddev_template = { 752 .fops = &si470x_fops, 753 .name = DRIVER_NAME, 754 .release = video_device_release_empty, 755 .ioctl_ops = &si470x_ioctl_ops, 756 }; 757