dvb_frontend.c revision 7e0722215a510921cbb73ab4c37477d4dcb91bf8
1/* 2 * dvb_frontend.c: DVB frontend tuning interface/thread 3 * 4 * 5 * Copyright (C) 1999-2001 Ralph Metzler 6 * Marcus Metzler 7 * Holger Waechtler 8 * for convergence integrated media GmbH 9 * 10 * Copyright (C) 2004 Andrew de Quincey (tuning thread cleanup) 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 2 15 * of the License, or (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 25 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html 26 */ 27 28#include <linux/string.h> 29#include <linux/kernel.h> 30#include <linux/sched.h> 31#include <linux/wait.h> 32#include <linux/slab.h> 33#include <linux/poll.h> 34#include <linux/semaphore.h> 35#include <linux/module.h> 36#include <linux/list.h> 37#include <linux/freezer.h> 38#include <linux/jiffies.h> 39#include <linux/kthread.h> 40#include <asm/processor.h> 41 42#include "dvb_frontend.h" 43#include "dvbdev.h" 44#include <linux/dvb/version.h> 45 46static int dvb_frontend_debug; 47static int dvb_shutdown_timeout; 48static int dvb_force_auto_inversion; 49static int dvb_override_tune_delay; 50static int dvb_powerdown_on_sleep = 1; 51static int dvb_mfe_wait_time = 5; 52 53module_param_named(frontend_debug, dvb_frontend_debug, int, 0644); 54MODULE_PARM_DESC(frontend_debug, "Turn on/off frontend core debugging (default:off)."); 55module_param(dvb_shutdown_timeout, int, 0644); 56MODULE_PARM_DESC(dvb_shutdown_timeout, "wait <shutdown_timeout> seconds after close() before suspending hardware"); 57module_param(dvb_force_auto_inversion, int, 0644); 58MODULE_PARM_DESC(dvb_force_auto_inversion, "0: normal (default), 1: INVERSION_AUTO forced always"); 59module_param(dvb_override_tune_delay, int, 0644); 60MODULE_PARM_DESC(dvb_override_tune_delay, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt"); 61module_param(dvb_powerdown_on_sleep, int, 0644); 62MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB voltage off on sleep (default)"); 63module_param(dvb_mfe_wait_time, int, 0644); 64MODULE_PARM_DESC(dvb_mfe_wait_time, "Wait up to <mfe_wait_time> seconds on open() for multi-frontend to become available (default:5 seconds)"); 65 66#define dprintk if (dvb_frontend_debug) printk 67 68#define FESTATE_IDLE 1 69#define FESTATE_RETUNE 2 70#define FESTATE_TUNING_FAST 4 71#define FESTATE_TUNING_SLOW 8 72#define FESTATE_TUNED 16 73#define FESTATE_ZIGZAG_FAST 32 74#define FESTATE_ZIGZAG_SLOW 64 75#define FESTATE_DISEQC 128 76#define FESTATE_ERROR 256 77#define FESTATE_WAITFORLOCK (FESTATE_TUNING_FAST | FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW | FESTATE_DISEQC) 78#define FESTATE_SEARCHING_FAST (FESTATE_TUNING_FAST | FESTATE_ZIGZAG_FAST) 79#define FESTATE_SEARCHING_SLOW (FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_SLOW) 80#define FESTATE_LOSTLOCK (FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW) 81 82#define FE_ALGO_HW 1 83/* 84 * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling. 85 * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune. 86 * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress. 87 * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower. 88 * FESTATE_TUNED. The frontend has successfully locked on. 89 * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it. 90 * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower. 91 * FESTATE_DISEQC. A DISEQC command has just been issued. 92 * FESTATE_WAITFORLOCK. When we're waiting for a lock. 93 * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan. 94 * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan. 95 * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again. 96 */ 97 98#define DVB_FE_NO_EXIT 0 99#define DVB_FE_NORMAL_EXIT 1 100#define DVB_FE_DEVICE_REMOVED 2 101 102static DEFINE_MUTEX(frontend_mutex); 103 104struct dvb_frontend_private { 105 106 /* thread/frontend values */ 107 struct dvb_device *dvbdev; 108 struct dvb_frontend_parameters parameters_in; 109 struct dvb_frontend_parameters parameters_out; 110 struct dvb_fe_events events; 111 struct semaphore sem; 112 struct list_head list_head; 113 wait_queue_head_t wait_queue; 114 struct task_struct *thread; 115 unsigned long release_jiffies; 116 unsigned int exit; 117 unsigned int wakeup; 118 fe_status_t status; 119 unsigned long tune_mode_flags; 120 unsigned int delay; 121 unsigned int reinitialise; 122 int tone; 123 int voltage; 124 125 /* swzigzag values */ 126 unsigned int state; 127 unsigned int bending; 128 int lnb_drift; 129 unsigned int inversion; 130 unsigned int auto_step; 131 unsigned int auto_sub_step; 132 unsigned int started_auto_step; 133 unsigned int min_delay; 134 unsigned int max_drift; 135 unsigned int step_size; 136 int quality; 137 unsigned int check_wrapped; 138 enum dvbfe_search algo_status; 139}; 140 141static void dvb_frontend_wakeup(struct dvb_frontend *fe); 142static int dtv_get_frontend(struct dvb_frontend *fe, 143 struct dtv_frontend_properties *c, 144 struct dvb_frontend_parameters *p_out); 145 146static bool has_get_frontend(struct dvb_frontend *fe) 147{ 148 return fe->ops.get_frontend; 149} 150 151static void dvb_frontend_add_event(struct dvb_frontend *fe, fe_status_t status) 152{ 153 struct dvb_frontend_private *fepriv = fe->frontend_priv; 154 struct dvb_fe_events *events = &fepriv->events; 155 struct dvb_frontend_event *e; 156 int wp; 157 158 dprintk ("%s\n", __func__); 159 160 if ((status & FE_HAS_LOCK) && has_get_frontend(fe)) 161 dtv_get_frontend(fe, NULL, &fepriv->parameters_out); 162 163 mutex_lock(&events->mtx); 164 165 wp = (events->eventw + 1) % MAX_EVENT; 166 if (wp == events->eventr) { 167 events->overflow = 1; 168 events->eventr = (events->eventr + 1) % MAX_EVENT; 169 } 170 171 e = &events->events[events->eventw]; 172 e->status = status; 173 e->parameters = fepriv->parameters_out; 174 175 events->eventw = wp; 176 177 mutex_unlock(&events->mtx); 178 179 wake_up_interruptible (&events->wait_queue); 180} 181 182static int dvb_frontend_get_event(struct dvb_frontend *fe, 183 struct dvb_frontend_event *event, int flags) 184{ 185 struct dvb_frontend_private *fepriv = fe->frontend_priv; 186 struct dvb_fe_events *events = &fepriv->events; 187 188 dprintk ("%s\n", __func__); 189 190 if (events->overflow) { 191 events->overflow = 0; 192 return -EOVERFLOW; 193 } 194 195 if (events->eventw == events->eventr) { 196 int ret; 197 198 if (flags & O_NONBLOCK) 199 return -EWOULDBLOCK; 200 201 up(&fepriv->sem); 202 203 ret = wait_event_interruptible (events->wait_queue, 204 events->eventw != events->eventr); 205 206 if (down_interruptible (&fepriv->sem)) 207 return -ERESTARTSYS; 208 209 if (ret < 0) 210 return ret; 211 } 212 213 mutex_lock(&events->mtx); 214 *event = events->events[events->eventr]; 215 events->eventr = (events->eventr + 1) % MAX_EVENT; 216 mutex_unlock(&events->mtx); 217 218 return 0; 219} 220 221static void dvb_frontend_clear_events(struct dvb_frontend *fe) 222{ 223 struct dvb_frontend_private *fepriv = fe->frontend_priv; 224 struct dvb_fe_events *events = &fepriv->events; 225 226 mutex_lock(&events->mtx); 227 events->eventr = events->eventw; 228 mutex_unlock(&events->mtx); 229} 230 231static void dvb_frontend_init(struct dvb_frontend *fe) 232{ 233 dprintk ("DVB: initialising adapter %i frontend %i (%s)...\n", 234 fe->dvb->num, 235 fe->id, 236 fe->ops.info.name); 237 238 if (fe->ops.init) 239 fe->ops.init(fe); 240 if (fe->ops.tuner_ops.init) { 241 if (fe->ops.i2c_gate_ctrl) 242 fe->ops.i2c_gate_ctrl(fe, 1); 243 fe->ops.tuner_ops.init(fe); 244 if (fe->ops.i2c_gate_ctrl) 245 fe->ops.i2c_gate_ctrl(fe, 0); 246 } 247} 248 249void dvb_frontend_reinitialise(struct dvb_frontend *fe) 250{ 251 struct dvb_frontend_private *fepriv = fe->frontend_priv; 252 253 fepriv->reinitialise = 1; 254 dvb_frontend_wakeup(fe); 255} 256EXPORT_SYMBOL(dvb_frontend_reinitialise); 257 258static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private *fepriv, int locked) 259{ 260 int q2; 261 262 dprintk ("%s\n", __func__); 263 264 if (locked) 265 (fepriv->quality) = (fepriv->quality * 220 + 36*256) / 256; 266 else 267 (fepriv->quality) = (fepriv->quality * 220 + 0) / 256; 268 269 q2 = fepriv->quality - 128; 270 q2 *= q2; 271 272 fepriv->delay = fepriv->min_delay + q2 * HZ / (128*128); 273} 274 275/** 276 * Performs automatic twiddling of frontend parameters. 277 * 278 * @param fe The frontend concerned. 279 * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT 280 * @returns Number of complete iterations that have been performed. 281 */ 282static int dvb_frontend_swzigzag_autotune(struct dvb_frontend *fe, int check_wrapped) 283{ 284 int autoinversion; 285 int ready = 0; 286 int fe_set_err = 0; 287 struct dvb_frontend_private *fepriv = fe->frontend_priv; 288 int original_inversion = fepriv->parameters_in.inversion; 289 u32 original_frequency = fepriv->parameters_in.frequency; 290 291 /* are we using autoinversion? */ 292 autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && 293 (fepriv->parameters_in.inversion == INVERSION_AUTO)); 294 295 /* setup parameters correctly */ 296 while(!ready) { 297 /* calculate the lnb_drift */ 298 fepriv->lnb_drift = fepriv->auto_step * fepriv->step_size; 299 300 /* wrap the auto_step if we've exceeded the maximum drift */ 301 if (fepriv->lnb_drift > fepriv->max_drift) { 302 fepriv->auto_step = 0; 303 fepriv->auto_sub_step = 0; 304 fepriv->lnb_drift = 0; 305 } 306 307 /* perform inversion and +/- zigzag */ 308 switch(fepriv->auto_sub_step) { 309 case 0: 310 /* try with the current inversion and current drift setting */ 311 ready = 1; 312 break; 313 314 case 1: 315 if (!autoinversion) break; 316 317 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF; 318 ready = 1; 319 break; 320 321 case 2: 322 if (fepriv->lnb_drift == 0) break; 323 324 fepriv->lnb_drift = -fepriv->lnb_drift; 325 ready = 1; 326 break; 327 328 case 3: 329 if (fepriv->lnb_drift == 0) break; 330 if (!autoinversion) break; 331 332 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF; 333 fepriv->lnb_drift = -fepriv->lnb_drift; 334 ready = 1; 335 break; 336 337 default: 338 fepriv->auto_step++; 339 fepriv->auto_sub_step = -1; /* it'll be incremented to 0 in a moment */ 340 break; 341 } 342 343 if (!ready) fepriv->auto_sub_step++; 344 } 345 346 /* if this attempt would hit where we started, indicate a complete 347 * iteration has occurred */ 348 if ((fepriv->auto_step == fepriv->started_auto_step) && 349 (fepriv->auto_sub_step == 0) && check_wrapped) { 350 return 1; 351 } 352 353 dprintk("%s: drift:%i inversion:%i auto_step:%i " 354 "auto_sub_step:%i started_auto_step:%i\n", 355 __func__, fepriv->lnb_drift, fepriv->inversion, 356 fepriv->auto_step, fepriv->auto_sub_step, fepriv->started_auto_step); 357 358 /* set the frontend itself */ 359 fepriv->parameters_in.frequency += fepriv->lnb_drift; 360 if (autoinversion) 361 fepriv->parameters_in.inversion = fepriv->inversion; 362 if (fe->ops.set_frontend) 363 fe_set_err = fe->ops.set_frontend(fe); 364 fepriv->parameters_out = fepriv->parameters_in; 365 if (fe_set_err < 0) { 366 fepriv->state = FESTATE_ERROR; 367 return fe_set_err; 368 } 369 370 fepriv->parameters_in.frequency = original_frequency; 371 fepriv->parameters_in.inversion = original_inversion; 372 373 fepriv->auto_sub_step++; 374 return 0; 375} 376 377static void dvb_frontend_swzigzag(struct dvb_frontend *fe) 378{ 379 fe_status_t s = 0; 380 int retval = 0; 381 struct dvb_frontend_private *fepriv = fe->frontend_priv; 382 383 /* if we've got no parameters, just keep idling */ 384 if (fepriv->state & FESTATE_IDLE) { 385 fepriv->delay = 3*HZ; 386 fepriv->quality = 0; 387 return; 388 } 389 390 /* in SCAN mode, we just set the frontend when asked and leave it alone */ 391 if (fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT) { 392 if (fepriv->state & FESTATE_RETUNE) { 393 if (fe->ops.set_frontend) 394 retval = fe->ops.set_frontend(fe); 395 fepriv->parameters_out = fepriv->parameters_in; 396 if (retval < 0) 397 fepriv->state = FESTATE_ERROR; 398 else 399 fepriv->state = FESTATE_TUNED; 400 } 401 fepriv->delay = 3*HZ; 402 fepriv->quality = 0; 403 return; 404 } 405 406 /* get the frontend status */ 407 if (fepriv->state & FESTATE_RETUNE) { 408 s = 0; 409 } else { 410 if (fe->ops.read_status) 411 fe->ops.read_status(fe, &s); 412 if (s != fepriv->status) { 413 dvb_frontend_add_event(fe, s); 414 fepriv->status = s; 415 } 416 } 417 418 /* if we're not tuned, and we have a lock, move to the TUNED state */ 419 if ((fepriv->state & FESTATE_WAITFORLOCK) && (s & FE_HAS_LOCK)) { 420 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 421 fepriv->state = FESTATE_TUNED; 422 423 /* if we're tuned, then we have determined the correct inversion */ 424 if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && 425 (fepriv->parameters_in.inversion == INVERSION_AUTO)) { 426 fepriv->parameters_in.inversion = fepriv->inversion; 427 } 428 return; 429 } 430 431 /* if we are tuned already, check we're still locked */ 432 if (fepriv->state & FESTATE_TUNED) { 433 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 434 435 /* we're tuned, and the lock is still good... */ 436 if (s & FE_HAS_LOCK) { 437 return; 438 } else { /* if we _WERE_ tuned, but now don't have a lock */ 439 fepriv->state = FESTATE_ZIGZAG_FAST; 440 fepriv->started_auto_step = fepriv->auto_step; 441 fepriv->check_wrapped = 0; 442 } 443 } 444 445 /* don't actually do anything if we're in the LOSTLOCK state, 446 * the frontend is set to FE_CAN_RECOVER, and the max_drift is 0 */ 447 if ((fepriv->state & FESTATE_LOSTLOCK) && 448 (fe->ops.info.caps & FE_CAN_RECOVER) && (fepriv->max_drift == 0)) { 449 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 450 return; 451 } 452 453 /* don't do anything if we're in the DISEQC state, since this 454 * might be someone with a motorized dish controlled by DISEQC. 455 * If its actually a re-tune, there will be a SET_FRONTEND soon enough. */ 456 if (fepriv->state & FESTATE_DISEQC) { 457 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 458 return; 459 } 460 461 /* if we're in the RETUNE state, set everything up for a brand 462 * new scan, keeping the current inversion setting, as the next 463 * tune is _very_ likely to require the same */ 464 if (fepriv->state & FESTATE_RETUNE) { 465 fepriv->lnb_drift = 0; 466 fepriv->auto_step = 0; 467 fepriv->auto_sub_step = 0; 468 fepriv->started_auto_step = 0; 469 fepriv->check_wrapped = 0; 470 } 471 472 /* fast zigzag. */ 473 if ((fepriv->state & FESTATE_SEARCHING_FAST) || (fepriv->state & FESTATE_RETUNE)) { 474 fepriv->delay = fepriv->min_delay; 475 476 /* perform a tune */ 477 retval = dvb_frontend_swzigzag_autotune(fe, 478 fepriv->check_wrapped); 479 if (retval < 0) { 480 return; 481 } else if (retval) { 482 /* OK, if we've run out of trials at the fast speed. 483 * Drop back to slow for the _next_ attempt */ 484 fepriv->state = FESTATE_SEARCHING_SLOW; 485 fepriv->started_auto_step = fepriv->auto_step; 486 return; 487 } 488 fepriv->check_wrapped = 1; 489 490 /* if we've just retuned, enter the ZIGZAG_FAST state. 491 * This ensures we cannot return from an 492 * FE_SET_FRONTEND ioctl before the first frontend tune 493 * occurs */ 494 if (fepriv->state & FESTATE_RETUNE) { 495 fepriv->state = FESTATE_TUNING_FAST; 496 } 497 } 498 499 /* slow zigzag */ 500 if (fepriv->state & FESTATE_SEARCHING_SLOW) { 501 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 502 503 /* Note: don't bother checking for wrapping; we stay in this 504 * state until we get a lock */ 505 dvb_frontend_swzigzag_autotune(fe, 0); 506 } 507} 508 509static int dvb_frontend_is_exiting(struct dvb_frontend *fe) 510{ 511 struct dvb_frontend_private *fepriv = fe->frontend_priv; 512 513 if (fepriv->exit != DVB_FE_NO_EXIT) 514 return 1; 515 516 if (fepriv->dvbdev->writers == 1) 517 if (time_after_eq(jiffies, fepriv->release_jiffies + 518 dvb_shutdown_timeout * HZ)) 519 return 1; 520 521 return 0; 522} 523 524static int dvb_frontend_should_wakeup(struct dvb_frontend *fe) 525{ 526 struct dvb_frontend_private *fepriv = fe->frontend_priv; 527 528 if (fepriv->wakeup) { 529 fepriv->wakeup = 0; 530 return 1; 531 } 532 return dvb_frontend_is_exiting(fe); 533} 534 535static void dvb_frontend_wakeup(struct dvb_frontend *fe) 536{ 537 struct dvb_frontend_private *fepriv = fe->frontend_priv; 538 539 fepriv->wakeup = 1; 540 wake_up_interruptible(&fepriv->wait_queue); 541} 542 543static int dvb_frontend_thread(void *data) 544{ 545 struct dvb_frontend *fe = data; 546 struct dvb_frontend_private *fepriv = fe->frontend_priv; 547 fe_status_t s; 548 enum dvbfe_algo algo; 549 550 bool re_tune = false; 551 552 dprintk("%s\n", __func__); 553 554 fepriv->check_wrapped = 0; 555 fepriv->quality = 0; 556 fepriv->delay = 3*HZ; 557 fepriv->status = 0; 558 fepriv->wakeup = 0; 559 fepriv->reinitialise = 0; 560 561 dvb_frontend_init(fe); 562 563 set_freezable(); 564 while (1) { 565 up(&fepriv->sem); /* is locked when we enter the thread... */ 566restart: 567 wait_event_interruptible_timeout(fepriv->wait_queue, 568 dvb_frontend_should_wakeup(fe) || kthread_should_stop() 569 || freezing(current), 570 fepriv->delay); 571 572 if (kthread_should_stop() || dvb_frontend_is_exiting(fe)) { 573 /* got signal or quitting */ 574 fepriv->exit = DVB_FE_NORMAL_EXIT; 575 break; 576 } 577 578 if (try_to_freeze()) 579 goto restart; 580 581 if (down_interruptible(&fepriv->sem)) 582 break; 583 584 if (fepriv->reinitialise) { 585 dvb_frontend_init(fe); 586 if (fe->ops.set_tone && fepriv->tone != -1) 587 fe->ops.set_tone(fe, fepriv->tone); 588 if (fe->ops.set_voltage && fepriv->voltage != -1) 589 fe->ops.set_voltage(fe, fepriv->voltage); 590 fepriv->reinitialise = 0; 591 } 592 593 /* do an iteration of the tuning loop */ 594 if (fe->ops.get_frontend_algo) { 595 algo = fe->ops.get_frontend_algo(fe); 596 switch (algo) { 597 case DVBFE_ALGO_HW: 598 dprintk("%s: Frontend ALGO = DVBFE_ALGO_HW\n", __func__); 599 600 if (fepriv->state & FESTATE_RETUNE) { 601 dprintk("%s: Retune requested, FESTATE_RETUNE\n", __func__); 602 re_tune = true; 603 fepriv->state = FESTATE_TUNED; 604 } 605 606 if (fe->ops.tune) 607 fe->ops.tune(fe, re_tune, fepriv->tune_mode_flags, &fepriv->delay, &s); 608 609 if (s != fepriv->status && !(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT)) { 610 dprintk("%s: state changed, adding current state\n", __func__); 611 dvb_frontend_add_event(fe, s); 612 fepriv->status = s; 613 } 614 break; 615 case DVBFE_ALGO_SW: 616 dprintk("%s: Frontend ALGO = DVBFE_ALGO_SW\n", __func__); 617 dvb_frontend_swzigzag(fe); 618 break; 619 case DVBFE_ALGO_CUSTOM: 620 dprintk("%s: Frontend ALGO = DVBFE_ALGO_CUSTOM, state=%d\n", __func__, fepriv->state); 621 if (fepriv->state & FESTATE_RETUNE) { 622 dprintk("%s: Retune requested, FESTAT_RETUNE\n", __func__); 623 fepriv->state = FESTATE_TUNED; 624 } 625 /* Case where we are going to search for a carrier 626 * User asked us to retune again for some reason, possibly 627 * requesting a search with a new set of parameters 628 */ 629 if (fepriv->algo_status & DVBFE_ALGO_SEARCH_AGAIN) { 630 if (fe->ops.search) { 631 fepriv->algo_status = fe->ops.search(fe, &fepriv->parameters_in); 632 /* We did do a search as was requested, the flags are 633 * now unset as well and has the flags wrt to search. 634 */ 635 } else { 636 fepriv->algo_status &= ~DVBFE_ALGO_SEARCH_AGAIN; 637 } 638 } 639 /* Track the carrier if the search was successful */ 640 if (fepriv->algo_status == DVBFE_ALGO_SEARCH_SUCCESS) { 641 if (fe->ops.track) 642 fe->ops.track(fe, &fepriv->parameters_in); 643 } else { 644 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN; 645 fepriv->delay = HZ / 2; 646 } 647 fepriv->parameters_out = fepriv->parameters_in; 648 fe->ops.read_status(fe, &s); 649 if (s != fepriv->status) { 650 dvb_frontend_add_event(fe, s); /* update event list */ 651 fepriv->status = s; 652 if (!(s & FE_HAS_LOCK)) { 653 fepriv->delay = HZ / 10; 654 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN; 655 } else { 656 fepriv->delay = 60 * HZ; 657 } 658 } 659 break; 660 default: 661 dprintk("%s: UNDEFINED ALGO !\n", __func__); 662 break; 663 } 664 } else { 665 dvb_frontend_swzigzag(fe); 666 } 667 } 668 669 if (dvb_powerdown_on_sleep) { 670 if (fe->ops.set_voltage) 671 fe->ops.set_voltage(fe, SEC_VOLTAGE_OFF); 672 if (fe->ops.tuner_ops.sleep) { 673 if (fe->ops.i2c_gate_ctrl) 674 fe->ops.i2c_gate_ctrl(fe, 1); 675 fe->ops.tuner_ops.sleep(fe); 676 if (fe->ops.i2c_gate_ctrl) 677 fe->ops.i2c_gate_ctrl(fe, 0); 678 } 679 if (fe->ops.sleep) 680 fe->ops.sleep(fe); 681 } 682 683 fepriv->thread = NULL; 684 if (kthread_should_stop()) 685 fepriv->exit = DVB_FE_DEVICE_REMOVED; 686 else 687 fepriv->exit = DVB_FE_NO_EXIT; 688 mb(); 689 690 dvb_frontend_wakeup(fe); 691 return 0; 692} 693 694static void dvb_frontend_stop(struct dvb_frontend *fe) 695{ 696 struct dvb_frontend_private *fepriv = fe->frontend_priv; 697 698 dprintk ("%s\n", __func__); 699 700 fepriv->exit = DVB_FE_NORMAL_EXIT; 701 mb(); 702 703 if (!fepriv->thread) 704 return; 705 706 kthread_stop(fepriv->thread); 707 708 sema_init(&fepriv->sem, 1); 709 fepriv->state = FESTATE_IDLE; 710 711 /* paranoia check in case a signal arrived */ 712 if (fepriv->thread) 713 printk("dvb_frontend_stop: warning: thread %p won't exit\n", 714 fepriv->thread); 715} 716 717s32 timeval_usec_diff(struct timeval lasttime, struct timeval curtime) 718{ 719 return ((curtime.tv_usec < lasttime.tv_usec) ? 720 1000000 - lasttime.tv_usec + curtime.tv_usec : 721 curtime.tv_usec - lasttime.tv_usec); 722} 723EXPORT_SYMBOL(timeval_usec_diff); 724 725static inline void timeval_usec_add(struct timeval *curtime, u32 add_usec) 726{ 727 curtime->tv_usec += add_usec; 728 if (curtime->tv_usec >= 1000000) { 729 curtime->tv_usec -= 1000000; 730 curtime->tv_sec++; 731 } 732} 733 734/* 735 * Sleep until gettimeofday() > waketime + add_usec 736 * This needs to be as precise as possible, but as the delay is 737 * usually between 2ms and 32ms, it is done using a scheduled msleep 738 * followed by usleep (normally a busy-wait loop) for the remainder 739 */ 740void dvb_frontend_sleep_until(struct timeval *waketime, u32 add_usec) 741{ 742 struct timeval lasttime; 743 s32 delta, newdelta; 744 745 timeval_usec_add(waketime, add_usec); 746 747 do_gettimeofday(&lasttime); 748 delta = timeval_usec_diff(lasttime, *waketime); 749 if (delta > 2500) { 750 msleep((delta - 1500) / 1000); 751 do_gettimeofday(&lasttime); 752 newdelta = timeval_usec_diff(lasttime, *waketime); 753 delta = (newdelta > delta) ? 0 : newdelta; 754 } 755 if (delta > 0) 756 udelay(delta); 757} 758EXPORT_SYMBOL(dvb_frontend_sleep_until); 759 760static int dvb_frontend_start(struct dvb_frontend *fe) 761{ 762 int ret; 763 struct dvb_frontend_private *fepriv = fe->frontend_priv; 764 struct task_struct *fe_thread; 765 766 dprintk ("%s\n", __func__); 767 768 if (fepriv->thread) { 769 if (fepriv->exit == DVB_FE_NO_EXIT) 770 return 0; 771 else 772 dvb_frontend_stop (fe); 773 } 774 775 if (signal_pending(current)) 776 return -EINTR; 777 if (down_interruptible (&fepriv->sem)) 778 return -EINTR; 779 780 fepriv->state = FESTATE_IDLE; 781 fepriv->exit = DVB_FE_NO_EXIT; 782 fepriv->thread = NULL; 783 mb(); 784 785 fe_thread = kthread_run(dvb_frontend_thread, fe, 786 "kdvb-ad-%i-fe-%i", fe->dvb->num,fe->id); 787 if (IS_ERR(fe_thread)) { 788 ret = PTR_ERR(fe_thread); 789 printk("dvb_frontend_start: failed to start kthread (%d)\n", ret); 790 up(&fepriv->sem); 791 return ret; 792 } 793 fepriv->thread = fe_thread; 794 return 0; 795} 796 797static void dvb_frontend_get_frequency_limits(struct dvb_frontend *fe, 798 u32 *freq_min, u32 *freq_max) 799{ 800 *freq_min = max(fe->ops.info.frequency_min, fe->ops.tuner_ops.info.frequency_min); 801 802 if (fe->ops.info.frequency_max == 0) 803 *freq_max = fe->ops.tuner_ops.info.frequency_max; 804 else if (fe->ops.tuner_ops.info.frequency_max == 0) 805 *freq_max = fe->ops.info.frequency_max; 806 else 807 *freq_max = min(fe->ops.info.frequency_max, fe->ops.tuner_ops.info.frequency_max); 808 809 if (*freq_min == 0 || *freq_max == 0) 810 printk(KERN_WARNING "DVB: adapter %i frontend %u frequency limits undefined - fix the driver\n", 811 fe->dvb->num,fe->id); 812} 813 814static int dvb_frontend_check_parameters(struct dvb_frontend *fe, 815 struct dvb_frontend_parameters *parms) 816{ 817 u32 freq_min; 818 u32 freq_max; 819 820 /* range check: frequency */ 821 dvb_frontend_get_frequency_limits(fe, &freq_min, &freq_max); 822 if ((freq_min && parms->frequency < freq_min) || 823 (freq_max && parms->frequency > freq_max)) { 824 printk(KERN_WARNING "DVB: adapter %i frontend %i frequency %u out of range (%u..%u)\n", 825 fe->dvb->num, fe->id, parms->frequency, freq_min, freq_max); 826 return -EINVAL; 827 } 828 829 /* range check: symbol rate */ 830 if (fe->ops.info.type == FE_QPSK) { 831 if ((fe->ops.info.symbol_rate_min && 832 parms->u.qpsk.symbol_rate < fe->ops.info.symbol_rate_min) || 833 (fe->ops.info.symbol_rate_max && 834 parms->u.qpsk.symbol_rate > fe->ops.info.symbol_rate_max)) { 835 printk(KERN_WARNING "DVB: adapter %i frontend %i symbol rate %u out of range (%u..%u)\n", 836 fe->dvb->num, fe->id, parms->u.qpsk.symbol_rate, 837 fe->ops.info.symbol_rate_min, fe->ops.info.symbol_rate_max); 838 return -EINVAL; 839 } 840 841 } else if (fe->ops.info.type == FE_QAM) { 842 if ((fe->ops.info.symbol_rate_min && 843 parms->u.qam.symbol_rate < fe->ops.info.symbol_rate_min) || 844 (fe->ops.info.symbol_rate_max && 845 parms->u.qam.symbol_rate > fe->ops.info.symbol_rate_max)) { 846 printk(KERN_WARNING "DVB: adapter %i frontend %i symbol rate %u out of range (%u..%u)\n", 847 fe->dvb->num, fe->id, parms->u.qam.symbol_rate, 848 fe->ops.info.symbol_rate_min, fe->ops.info.symbol_rate_max); 849 return -EINVAL; 850 } 851 } 852 853 /* check for supported modulation */ 854 if (fe->ops.info.type == FE_QAM && 855 (parms->u.qam.modulation > QAM_AUTO || 856 !((1 << (parms->u.qam.modulation + 10)) & fe->ops.info.caps))) { 857 printk(KERN_WARNING "DVB: adapter %i frontend %i modulation %u not supported\n", 858 fe->dvb->num, fe->id, parms->u.qam.modulation); 859 return -EINVAL; 860 } 861 862 return 0; 863} 864 865static int dvb_frontend_clear_cache(struct dvb_frontend *fe) 866{ 867 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 868 int i; 869 870 memset(c, 0, sizeof(struct dtv_frontend_properties)); 871 872 c->state = DTV_CLEAR; 873 c->delivery_system = SYS_UNDEFINED; 874 c->inversion = INVERSION_AUTO; 875 c->fec_inner = FEC_AUTO; 876 c->transmission_mode = TRANSMISSION_MODE_AUTO; 877 c->bandwidth_hz = BANDWIDTH_AUTO; 878 c->guard_interval = GUARD_INTERVAL_AUTO; 879 c->hierarchy = HIERARCHY_AUTO; 880 c->symbol_rate = QAM_AUTO; 881 c->code_rate_HP = FEC_AUTO; 882 c->code_rate_LP = FEC_AUTO; 883 c->rolloff = ROLLOFF_AUTO; 884 885 c->isdbt_partial_reception = -1; 886 c->isdbt_sb_mode = -1; 887 c->isdbt_sb_subchannel = -1; 888 c->isdbt_sb_segment_idx = -1; 889 c->isdbt_sb_segment_count = -1; 890 c->isdbt_layer_enabled = 0x7; 891 for (i = 0; i < 3; i++) { 892 c->layer[i].fec = FEC_AUTO; 893 c->layer[i].modulation = QAM_AUTO; 894 c->layer[i].interleaving = -1; 895 c->layer[i].segment_count = -1; 896 } 897 898 return 0; 899} 900 901#define _DTV_CMD(n, s, b) \ 902[n] = { \ 903 .name = #n, \ 904 .cmd = n, \ 905 .set = s,\ 906 .buffer = b \ 907} 908 909static struct dtv_cmds_h dtv_cmds[DTV_MAX_COMMAND + 1] = { 910 _DTV_CMD(DTV_TUNE, 1, 0), 911 _DTV_CMD(DTV_CLEAR, 1, 0), 912 913 /* Set */ 914 _DTV_CMD(DTV_FREQUENCY, 1, 0), 915 _DTV_CMD(DTV_BANDWIDTH_HZ, 1, 0), 916 _DTV_CMD(DTV_MODULATION, 1, 0), 917 _DTV_CMD(DTV_INVERSION, 1, 0), 918 _DTV_CMD(DTV_DISEQC_MASTER, 1, 1), 919 _DTV_CMD(DTV_SYMBOL_RATE, 1, 0), 920 _DTV_CMD(DTV_INNER_FEC, 1, 0), 921 _DTV_CMD(DTV_VOLTAGE, 1, 0), 922 _DTV_CMD(DTV_TONE, 1, 0), 923 _DTV_CMD(DTV_PILOT, 1, 0), 924 _DTV_CMD(DTV_ROLLOFF, 1, 0), 925 _DTV_CMD(DTV_DELIVERY_SYSTEM, 1, 0), 926 _DTV_CMD(DTV_HIERARCHY, 1, 0), 927 _DTV_CMD(DTV_CODE_RATE_HP, 1, 0), 928 _DTV_CMD(DTV_CODE_RATE_LP, 1, 0), 929 _DTV_CMD(DTV_GUARD_INTERVAL, 1, 0), 930 _DTV_CMD(DTV_TRANSMISSION_MODE, 1, 0), 931 932 _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 1, 0), 933 _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 1, 0), 934 _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 1, 0), 935 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 1, 0), 936 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 1, 0), 937 _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 1, 0), 938 _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 1, 0), 939 _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 1, 0), 940 _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 1, 0), 941 _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 1, 0), 942 _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 1, 0), 943 _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 1, 0), 944 _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 1, 0), 945 _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 1, 0), 946 _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 1, 0), 947 _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 1, 0), 948 _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 1, 0), 949 _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 1, 0), 950 951 _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 0, 0), 952 _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 0, 0), 953 _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 0, 0), 954 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 0, 0), 955 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 0, 0), 956 _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 0, 0), 957 _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 0, 0), 958 _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 0, 0), 959 _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 0, 0), 960 _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 0, 0), 961 _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 0, 0), 962 _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 0, 0), 963 _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 0, 0), 964 _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 0, 0), 965 _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 0, 0), 966 _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 0, 0), 967 _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 0, 0), 968 _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 0, 0), 969 970 _DTV_CMD(DTV_ISDBS_TS_ID, 1, 0), 971 _DTV_CMD(DTV_DVBT2_PLP_ID, 1, 0), 972 973 /* Get */ 974 _DTV_CMD(DTV_DISEQC_SLAVE_REPLY, 0, 1), 975 _DTV_CMD(DTV_API_VERSION, 0, 0), 976 _DTV_CMD(DTV_CODE_RATE_HP, 0, 0), 977 _DTV_CMD(DTV_CODE_RATE_LP, 0, 0), 978 _DTV_CMD(DTV_GUARD_INTERVAL, 0, 0), 979 _DTV_CMD(DTV_TRANSMISSION_MODE, 0, 0), 980 _DTV_CMD(DTV_HIERARCHY, 0, 0), 981 982 _DTV_CMD(DTV_ENUM_DELSYS, 0, 0), 983}; 984 985static void dtv_property_dump(struct dtv_property *tvp) 986{ 987 int i; 988 989 if (tvp->cmd <= 0 || tvp->cmd > DTV_MAX_COMMAND) { 990 printk(KERN_WARNING "%s: tvp.cmd = 0x%08x undefined\n", 991 __func__, tvp->cmd); 992 return; 993 } 994 995 dprintk("%s() tvp.cmd = 0x%08x (%s)\n" 996 ,__func__ 997 ,tvp->cmd 998 ,dtv_cmds[ tvp->cmd ].name); 999 1000 if(dtv_cmds[ tvp->cmd ].buffer) { 1001 1002 dprintk("%s() tvp.u.buffer.len = 0x%02x\n" 1003 ,__func__ 1004 ,tvp->u.buffer.len); 1005 1006 for(i = 0; i < tvp->u.buffer.len; i++) 1007 dprintk("%s() tvp.u.buffer.data[0x%02x] = 0x%02x\n" 1008 ,__func__ 1009 ,i 1010 ,tvp->u.buffer.data[i]); 1011 1012 } else 1013 dprintk("%s() tvp.u.data = 0x%08x\n", __func__, tvp->u.data); 1014} 1015 1016static int is_legacy_delivery_system(fe_delivery_system_t s) 1017{ 1018 if((s == SYS_UNDEFINED) || (s == SYS_DVBC_ANNEX_A) || 1019 (s == SYS_DVBC_ANNEX_B) || (s == SYS_DVBT) || (s == SYS_DVBS) || 1020 (s == SYS_ATSC)) 1021 return 1; 1022 1023 return 0; 1024} 1025 1026/* Initialize the cache with some default values derived from the 1027 * legacy frontend_info structure. 1028 */ 1029static void dtv_property_cache_init(struct dvb_frontend *fe, 1030 struct dtv_frontend_properties *c) 1031{ 1032 switch (fe->ops.info.type) { 1033 case FE_QPSK: 1034 c->modulation = QPSK; /* implied for DVB-S in legacy API */ 1035 c->rolloff = ROLLOFF_35;/* implied for DVB-S */ 1036 c->delivery_system = SYS_DVBS; 1037 break; 1038 case FE_QAM: 1039 c->delivery_system = SYS_DVBC_ANNEX_A; 1040 break; 1041 case FE_OFDM: 1042 c->delivery_system = SYS_DVBT; 1043 break; 1044 case FE_ATSC: 1045 break; 1046 } 1047} 1048 1049/* Synchronise the legacy tuning parameters into the cache, so that demodulator 1050 * drivers can use a single set_frontend tuning function, regardless of whether 1051 * it's being used for the legacy or new API, reducing code and complexity. 1052 */ 1053static void dtv_property_cache_sync(struct dvb_frontend *fe, 1054 struct dtv_frontend_properties *c, 1055 const struct dvb_frontend_parameters *p) 1056{ 1057 c->frequency = p->frequency; 1058 c->inversion = p->inversion; 1059 1060 switch (fe->ops.info.type) { 1061 case FE_QPSK: 1062 c->symbol_rate = p->u.qpsk.symbol_rate; 1063 c->fec_inner = p->u.qpsk.fec_inner; 1064 break; 1065 case FE_QAM: 1066 c->symbol_rate = p->u.qam.symbol_rate; 1067 c->fec_inner = p->u.qam.fec_inner; 1068 c->modulation = p->u.qam.modulation; 1069 break; 1070 case FE_OFDM: 1071 if (p->u.ofdm.bandwidth == BANDWIDTH_6_MHZ) 1072 c->bandwidth_hz = 6000000; 1073 else if (p->u.ofdm.bandwidth == BANDWIDTH_7_MHZ) 1074 c->bandwidth_hz = 7000000; 1075 else if (p->u.ofdm.bandwidth == BANDWIDTH_8_MHZ) 1076 c->bandwidth_hz = 8000000; 1077 else 1078 /* Including BANDWIDTH_AUTO */ 1079 c->bandwidth_hz = 0; 1080 c->code_rate_HP = p->u.ofdm.code_rate_HP; 1081 c->code_rate_LP = p->u.ofdm.code_rate_LP; 1082 c->modulation = p->u.ofdm.constellation; 1083 c->transmission_mode = p->u.ofdm.transmission_mode; 1084 c->guard_interval = p->u.ofdm.guard_interval; 1085 c->hierarchy = p->u.ofdm.hierarchy_information; 1086 break; 1087 case FE_ATSC: 1088 c->modulation = p->u.vsb.modulation; 1089 if ((c->modulation == VSB_8) || (c->modulation == VSB_16)) 1090 c->delivery_system = SYS_ATSC; 1091 else 1092 c->delivery_system = SYS_DVBC_ANNEX_B; 1093 break; 1094 } 1095} 1096 1097/* Ensure the cached values are set correctly in the frontend 1098 * legacy tuning structures, for the advanced tuning API. 1099 */ 1100static void dtv_property_legacy_params_sync(struct dvb_frontend *fe, 1101 struct dvb_frontend_parameters *p) 1102{ 1103 const struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1104 1105 p->frequency = c->frequency; 1106 p->inversion = c->inversion; 1107 1108 switch (fe->ops.info.type) { 1109 case FE_QPSK: 1110 dprintk("%s() Preparing QPSK req\n", __func__); 1111 p->u.qpsk.symbol_rate = c->symbol_rate; 1112 p->u.qpsk.fec_inner = c->fec_inner; 1113 break; 1114 case FE_QAM: 1115 dprintk("%s() Preparing QAM req\n", __func__); 1116 p->u.qam.symbol_rate = c->symbol_rate; 1117 p->u.qam.fec_inner = c->fec_inner; 1118 p->u.qam.modulation = c->modulation; 1119 break; 1120 case FE_OFDM: 1121 dprintk("%s() Preparing OFDM req\n", __func__); 1122 if (c->bandwidth_hz == 6000000) 1123 p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ; 1124 else if (c->bandwidth_hz == 7000000) 1125 p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ; 1126 else if (c->bandwidth_hz == 8000000) 1127 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ; 1128 else 1129 p->u.ofdm.bandwidth = BANDWIDTH_AUTO; 1130 p->u.ofdm.code_rate_HP = c->code_rate_HP; 1131 p->u.ofdm.code_rate_LP = c->code_rate_LP; 1132 p->u.ofdm.constellation = c->modulation; 1133 p->u.ofdm.transmission_mode = c->transmission_mode; 1134 p->u.ofdm.guard_interval = c->guard_interval; 1135 p->u.ofdm.hierarchy_information = c->hierarchy; 1136 break; 1137 case FE_ATSC: 1138 dprintk("%s() Preparing VSB req\n", __func__); 1139 p->u.vsb.modulation = c->modulation; 1140 break; 1141 } 1142} 1143 1144/* Ensure the cached values are set correctly in the frontend 1145 * legacy tuning structures, for the legacy tuning API. 1146 */ 1147static void dtv_property_adv_params_sync(struct dvb_frontend *fe) 1148{ 1149 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1150 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1151 struct dvb_frontend_parameters *p = &fepriv->parameters_in; 1152 u32 rolloff = 0; 1153 1154 p->frequency = c->frequency; 1155 p->inversion = c->inversion; 1156 1157 if (c->delivery_system == SYS_DSS || 1158 c->delivery_system == SYS_DVBS || 1159 c->delivery_system == SYS_DVBS2 || 1160 c->delivery_system == SYS_ISDBS || 1161 c->delivery_system == SYS_TURBO) { 1162 p->u.qpsk.symbol_rate = c->symbol_rate; 1163 p->u.qpsk.fec_inner = c->fec_inner; 1164 } 1165 1166 /* Fake out a generic DVB-T request so we pass validation in the ioctl */ 1167 if ((c->delivery_system == SYS_ISDBT) || 1168 (c->delivery_system == SYS_DVBT2)) { 1169 p->u.ofdm.constellation = QAM_AUTO; 1170 p->u.ofdm.code_rate_HP = FEC_AUTO; 1171 p->u.ofdm.code_rate_LP = FEC_AUTO; 1172 p->u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO; 1173 p->u.ofdm.guard_interval = GUARD_INTERVAL_AUTO; 1174 p->u.ofdm.hierarchy_information = HIERARCHY_AUTO; 1175 if (c->bandwidth_hz == 8000000) 1176 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ; 1177 else if (c->bandwidth_hz == 7000000) 1178 p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ; 1179 else if (c->bandwidth_hz == 6000000) 1180 p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ; 1181 else 1182 p->u.ofdm.bandwidth = BANDWIDTH_AUTO; 1183 } 1184 1185 /* 1186 * Be sure that the bandwidth will be filled for all 1187 * non-satellite systems, as tuners need to know what 1188 * low pass/Nyquist half filter should be applied, in 1189 * order to avoid inter-channel noise. 1190 * 1191 * ISDB-T and DVB-T/T2 already sets bandwidth. 1192 * ATSC and DVB-C don't set, so, the core should fill it. 1193 * 1194 * On DVB-C Annex A and C, the bandwidth is a function of 1195 * the roll-off and symbol rate. Annex B defines different 1196 * roll-off factors depending on the modulation. Fortunately, 1197 * Annex B is only used with 6MHz, so there's no need to 1198 * calculate it. 1199 * 1200 * While not officially supported, a side effect of handling it at 1201 * the cache level is that a program could retrieve the bandwidth 1202 * via DTV_BANDWIDTH_HZ, which may be useful for test programs. 1203 */ 1204 switch (c->delivery_system) { 1205 case SYS_ATSC: 1206 case SYS_DVBC_ANNEX_B: 1207 c->bandwidth_hz = 6000000; 1208 break; 1209 case SYS_DVBC_ANNEX_A: 1210 rolloff = 115; 1211 break; 1212 case SYS_DVBC_ANNEX_C: 1213 rolloff = 113; 1214 break; 1215 default: 1216 break; 1217 } 1218 if (rolloff) 1219 c->bandwidth_hz = (c->symbol_rate * rolloff) / 100; 1220} 1221 1222static void dtv_property_cache_submit(struct dvb_frontend *fe) 1223{ 1224 const struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1225 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1226 1227 /* For legacy delivery systems we don't need the delivery_system to 1228 * be specified, but we populate the older structures from the cache 1229 * so we can call set_frontend on older drivers. 1230 */ 1231 if(is_legacy_delivery_system(c->delivery_system)) { 1232 1233 dprintk("%s() legacy, modulation = %d\n", __func__, c->modulation); 1234 dtv_property_legacy_params_sync(fe, &fepriv->parameters_in); 1235 1236 } else { 1237 dprintk("%s() adv, modulation = %d\n", __func__, c->modulation); 1238 1239 /* For advanced delivery systems / modulation types ... 1240 * we seed the lecacy dvb_frontend_parameters structure 1241 * so that the sanity checking code later in the IOCTL processing 1242 * can validate our basic frequency ranges, symbolrates, modulation 1243 * etc. 1244 */ 1245 dtv_property_adv_params_sync(fe); 1246 } 1247} 1248 1249/** 1250 * dtv_get_frontend - calls a callback for retrieving DTV parameters 1251 * @fe: struct dvb_frontend pointer 1252 * @c: struct dtv_frontend_properties pointer (DVBv5 cache) 1253 * @p_out struct dvb_frontend_parameters pointer (DVBv3 FE struct) 1254 * 1255 * This routine calls either the DVBv3 or DVBv5 get_frontend call. 1256 * If c is not null, it will update the DVBv5 cache struct pointed by it. 1257 * If p_out is not null, it will update the DVBv3 params pointed by it. 1258 */ 1259static int dtv_get_frontend(struct dvb_frontend *fe, 1260 struct dtv_frontend_properties *c, 1261 struct dvb_frontend_parameters *p_out) 1262{ 1263 const struct dtv_frontend_properties *cache = &fe->dtv_property_cache; 1264 struct dtv_frontend_properties tmp_cache; 1265 struct dvb_frontend_parameters tmp_out; 1266 bool fill_params = (p_out != NULL); 1267 int r; 1268 1269 if (!p_out) 1270 p_out = &tmp_out; 1271 1272 if (!c) 1273 c = &tmp_cache; 1274 else 1275 memcpy(c, cache, sizeof(*c)); 1276 1277 if (fe->ops.get_frontend) { 1278 r = fe->ops.get_frontend(fe, c); 1279 if (unlikely(r < 0)) 1280 return r; 1281 if (fill_params) 1282 dtv_property_legacy_params_sync(fe, p_out); 1283 return 0; 1284 } 1285 1286 /* As everything is in cache, this is always supported */ 1287 return 0; 1288} 1289 1290static int dvb_frontend_ioctl_legacy(struct file *file, 1291 unsigned int cmd, void *parg); 1292static int dvb_frontend_ioctl_properties(struct file *file, 1293 unsigned int cmd, void *parg); 1294 1295static void dtv_set_default_delivery_caps(const struct dvb_frontend *fe, struct dtv_property *p) 1296{ 1297 const struct dvb_frontend_info *info = &fe->ops.info; 1298 u32 ncaps = 0; 1299 1300 /* 1301 * If the frontend explicitly sets a list, use it, instead of 1302 * filling based on the info->type 1303 */ 1304 if (fe->ops.delsys[ncaps]) { 1305 while (fe->ops.delsys[ncaps] && ncaps < MAX_DELSYS) { 1306 p->u.buffer.data[ncaps] = fe->ops.delsys[ncaps]; 1307 ncaps++; 1308 } 1309 p->u.buffer.len = ncaps; 1310 return; 1311 } 1312 1313 switch (info->type) { 1314 case FE_QPSK: 1315 p->u.buffer.data[ncaps++] = SYS_DVBS; 1316 if (info->caps & FE_CAN_2G_MODULATION) 1317 p->u.buffer.data[ncaps++] = SYS_DVBS2; 1318 if (info->caps & FE_CAN_TURBO_FEC) 1319 p->u.buffer.data[ncaps++] = SYS_TURBO; 1320 break; 1321 case FE_QAM: 1322 p->u.buffer.data[ncaps++] = SYS_DVBC_ANNEX_A; 1323 break; 1324 case FE_OFDM: 1325 p->u.buffer.data[ncaps++] = SYS_DVBT; 1326 if (info->caps & FE_CAN_2G_MODULATION) 1327 p->u.buffer.data[ncaps++] = SYS_DVBT2; 1328 break; 1329 case FE_ATSC: 1330 if (info->caps & (FE_CAN_8VSB | FE_CAN_16VSB)) 1331 p->u.buffer.data[ncaps++] = SYS_ATSC; 1332 if (info->caps & (FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_128 | FE_CAN_QAM_256)) 1333 p->u.buffer.data[ncaps++] = SYS_DVBC_ANNEX_B; 1334 break; 1335 } 1336 p->u.buffer.len = ncaps; 1337} 1338 1339static int dtv_property_process_get(struct dvb_frontend *fe, 1340 const struct dtv_frontend_properties *c, 1341 struct dtv_property *tvp, 1342 struct file *file) 1343{ 1344 int r; 1345 1346 switch(tvp->cmd) { 1347 case DTV_ENUM_DELSYS: 1348 dtv_set_default_delivery_caps(fe, tvp); 1349 break; 1350 case DTV_FREQUENCY: 1351 tvp->u.data = c->frequency; 1352 break; 1353 case DTV_MODULATION: 1354 tvp->u.data = c->modulation; 1355 break; 1356 case DTV_BANDWIDTH_HZ: 1357 tvp->u.data = c->bandwidth_hz; 1358 break; 1359 case DTV_INVERSION: 1360 tvp->u.data = c->inversion; 1361 break; 1362 case DTV_SYMBOL_RATE: 1363 tvp->u.data = c->symbol_rate; 1364 break; 1365 case DTV_INNER_FEC: 1366 tvp->u.data = c->fec_inner; 1367 break; 1368 case DTV_PILOT: 1369 tvp->u.data = c->pilot; 1370 break; 1371 case DTV_ROLLOFF: 1372 tvp->u.data = c->rolloff; 1373 break; 1374 case DTV_DELIVERY_SYSTEM: 1375 tvp->u.data = c->delivery_system; 1376 break; 1377 case DTV_VOLTAGE: 1378 tvp->u.data = c->voltage; 1379 break; 1380 case DTV_TONE: 1381 tvp->u.data = c->sectone; 1382 break; 1383 case DTV_API_VERSION: 1384 tvp->u.data = (DVB_API_VERSION << 8) | DVB_API_VERSION_MINOR; 1385 break; 1386 case DTV_CODE_RATE_HP: 1387 tvp->u.data = c->code_rate_HP; 1388 break; 1389 case DTV_CODE_RATE_LP: 1390 tvp->u.data = c->code_rate_LP; 1391 break; 1392 case DTV_GUARD_INTERVAL: 1393 tvp->u.data = c->guard_interval; 1394 break; 1395 case DTV_TRANSMISSION_MODE: 1396 tvp->u.data = c->transmission_mode; 1397 break; 1398 case DTV_HIERARCHY: 1399 tvp->u.data = c->hierarchy; 1400 break; 1401 1402 /* ISDB-T Support here */ 1403 case DTV_ISDBT_PARTIAL_RECEPTION: 1404 tvp->u.data = c->isdbt_partial_reception; 1405 break; 1406 case DTV_ISDBT_SOUND_BROADCASTING: 1407 tvp->u.data = c->isdbt_sb_mode; 1408 break; 1409 case DTV_ISDBT_SB_SUBCHANNEL_ID: 1410 tvp->u.data = c->isdbt_sb_subchannel; 1411 break; 1412 case DTV_ISDBT_SB_SEGMENT_IDX: 1413 tvp->u.data = c->isdbt_sb_segment_idx; 1414 break; 1415 case DTV_ISDBT_SB_SEGMENT_COUNT: 1416 tvp->u.data = c->isdbt_sb_segment_count; 1417 break; 1418 case DTV_ISDBT_LAYER_ENABLED: 1419 tvp->u.data = c->isdbt_layer_enabled; 1420 break; 1421 case DTV_ISDBT_LAYERA_FEC: 1422 tvp->u.data = c->layer[0].fec; 1423 break; 1424 case DTV_ISDBT_LAYERA_MODULATION: 1425 tvp->u.data = c->layer[0].modulation; 1426 break; 1427 case DTV_ISDBT_LAYERA_SEGMENT_COUNT: 1428 tvp->u.data = c->layer[0].segment_count; 1429 break; 1430 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING: 1431 tvp->u.data = c->layer[0].interleaving; 1432 break; 1433 case DTV_ISDBT_LAYERB_FEC: 1434 tvp->u.data = c->layer[1].fec; 1435 break; 1436 case DTV_ISDBT_LAYERB_MODULATION: 1437 tvp->u.data = c->layer[1].modulation; 1438 break; 1439 case DTV_ISDBT_LAYERB_SEGMENT_COUNT: 1440 tvp->u.data = c->layer[1].segment_count; 1441 break; 1442 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING: 1443 tvp->u.data = c->layer[1].interleaving; 1444 break; 1445 case DTV_ISDBT_LAYERC_FEC: 1446 tvp->u.data = c->layer[2].fec; 1447 break; 1448 case DTV_ISDBT_LAYERC_MODULATION: 1449 tvp->u.data = c->layer[2].modulation; 1450 break; 1451 case DTV_ISDBT_LAYERC_SEGMENT_COUNT: 1452 tvp->u.data = c->layer[2].segment_count; 1453 break; 1454 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING: 1455 tvp->u.data = c->layer[2].interleaving; 1456 break; 1457 case DTV_ISDBS_TS_ID: 1458 tvp->u.data = c->isdbs_ts_id; 1459 break; 1460 case DTV_DVBT2_PLP_ID: 1461 tvp->u.data = c->dvbt2_plp_id; 1462 break; 1463 default: 1464 return -EINVAL; 1465 } 1466 1467 /* Allow the frontend to override outgoing properties */ 1468 if (fe->ops.get_property) { 1469 r = fe->ops.get_property(fe, tvp); 1470 if (r < 0) 1471 return r; 1472 } 1473 1474 dtv_property_dump(tvp); 1475 1476 return 0; 1477} 1478 1479static int dtv_property_process_set(struct dvb_frontend *fe, 1480 struct dtv_property *tvp, 1481 struct file *file) 1482{ 1483 int r = 0; 1484 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1485 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1486 dtv_property_dump(tvp); 1487 1488 /* Allow the frontend to validate incoming properties */ 1489 if (fe->ops.set_property) { 1490 r = fe->ops.set_property(fe, tvp); 1491 if (r < 0) 1492 return r; 1493 } 1494 1495 switch(tvp->cmd) { 1496 case DTV_CLEAR: 1497 /* Reset a cache of data specific to the frontend here. This does 1498 * not effect hardware. 1499 */ 1500 dvb_frontend_clear_cache(fe); 1501 dprintk("%s() Flushing property cache\n", __func__); 1502 break; 1503 case DTV_TUNE: 1504 /* interpret the cache of data, build either a traditional frontend 1505 * tunerequest so we can pass validation in the FE_SET_FRONTEND 1506 * ioctl. 1507 */ 1508 c->state = tvp->cmd; 1509 dprintk("%s() Finalised property cache\n", __func__); 1510 dtv_property_cache_submit(fe); 1511 1512 r = dvb_frontend_ioctl_legacy(file, FE_SET_FRONTEND, 1513 &fepriv->parameters_in); 1514 break; 1515 case DTV_FREQUENCY: 1516 c->frequency = tvp->u.data; 1517 break; 1518 case DTV_MODULATION: 1519 c->modulation = tvp->u.data; 1520 break; 1521 case DTV_BANDWIDTH_HZ: 1522 c->bandwidth_hz = tvp->u.data; 1523 break; 1524 case DTV_INVERSION: 1525 c->inversion = tvp->u.data; 1526 break; 1527 case DTV_SYMBOL_RATE: 1528 c->symbol_rate = tvp->u.data; 1529 break; 1530 case DTV_INNER_FEC: 1531 c->fec_inner = tvp->u.data; 1532 break; 1533 case DTV_PILOT: 1534 c->pilot = tvp->u.data; 1535 break; 1536 case DTV_ROLLOFF: 1537 c->rolloff = tvp->u.data; 1538 break; 1539 case DTV_DELIVERY_SYSTEM: 1540 c->delivery_system = tvp->u.data; 1541 break; 1542 case DTV_VOLTAGE: 1543 c->voltage = tvp->u.data; 1544 r = dvb_frontend_ioctl_legacy(file, FE_SET_VOLTAGE, 1545 (void *)c->voltage); 1546 break; 1547 case DTV_TONE: 1548 c->sectone = tvp->u.data; 1549 r = dvb_frontend_ioctl_legacy(file, FE_SET_TONE, 1550 (void *)c->sectone); 1551 break; 1552 case DTV_CODE_RATE_HP: 1553 c->code_rate_HP = tvp->u.data; 1554 break; 1555 case DTV_CODE_RATE_LP: 1556 c->code_rate_LP = tvp->u.data; 1557 break; 1558 case DTV_GUARD_INTERVAL: 1559 c->guard_interval = tvp->u.data; 1560 break; 1561 case DTV_TRANSMISSION_MODE: 1562 c->transmission_mode = tvp->u.data; 1563 break; 1564 case DTV_HIERARCHY: 1565 c->hierarchy = tvp->u.data; 1566 break; 1567 1568 /* ISDB-T Support here */ 1569 case DTV_ISDBT_PARTIAL_RECEPTION: 1570 c->isdbt_partial_reception = tvp->u.data; 1571 break; 1572 case DTV_ISDBT_SOUND_BROADCASTING: 1573 c->isdbt_sb_mode = tvp->u.data; 1574 break; 1575 case DTV_ISDBT_SB_SUBCHANNEL_ID: 1576 c->isdbt_sb_subchannel = tvp->u.data; 1577 break; 1578 case DTV_ISDBT_SB_SEGMENT_IDX: 1579 c->isdbt_sb_segment_idx = tvp->u.data; 1580 break; 1581 case DTV_ISDBT_SB_SEGMENT_COUNT: 1582 c->isdbt_sb_segment_count = tvp->u.data; 1583 break; 1584 case DTV_ISDBT_LAYER_ENABLED: 1585 c->isdbt_layer_enabled = tvp->u.data; 1586 break; 1587 case DTV_ISDBT_LAYERA_FEC: 1588 c->layer[0].fec = tvp->u.data; 1589 break; 1590 case DTV_ISDBT_LAYERA_MODULATION: 1591 c->layer[0].modulation = tvp->u.data; 1592 break; 1593 case DTV_ISDBT_LAYERA_SEGMENT_COUNT: 1594 c->layer[0].segment_count = tvp->u.data; 1595 break; 1596 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING: 1597 c->layer[0].interleaving = tvp->u.data; 1598 break; 1599 case DTV_ISDBT_LAYERB_FEC: 1600 c->layer[1].fec = tvp->u.data; 1601 break; 1602 case DTV_ISDBT_LAYERB_MODULATION: 1603 c->layer[1].modulation = tvp->u.data; 1604 break; 1605 case DTV_ISDBT_LAYERB_SEGMENT_COUNT: 1606 c->layer[1].segment_count = tvp->u.data; 1607 break; 1608 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING: 1609 c->layer[1].interleaving = tvp->u.data; 1610 break; 1611 case DTV_ISDBT_LAYERC_FEC: 1612 c->layer[2].fec = tvp->u.data; 1613 break; 1614 case DTV_ISDBT_LAYERC_MODULATION: 1615 c->layer[2].modulation = tvp->u.data; 1616 break; 1617 case DTV_ISDBT_LAYERC_SEGMENT_COUNT: 1618 c->layer[2].segment_count = tvp->u.data; 1619 break; 1620 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING: 1621 c->layer[2].interleaving = tvp->u.data; 1622 break; 1623 case DTV_ISDBS_TS_ID: 1624 c->isdbs_ts_id = tvp->u.data; 1625 break; 1626 case DTV_DVBT2_PLP_ID: 1627 c->dvbt2_plp_id = tvp->u.data; 1628 break; 1629 default: 1630 return -EINVAL; 1631 } 1632 1633 return r; 1634} 1635 1636static int dvb_frontend_ioctl(struct file *file, 1637 unsigned int cmd, void *parg) 1638{ 1639 struct dvb_device *dvbdev = file->private_data; 1640 struct dvb_frontend *fe = dvbdev->priv; 1641 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1642 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1643 int err = -EOPNOTSUPP; 1644 1645 dprintk("%s (%d)\n", __func__, _IOC_NR(cmd)); 1646 1647 if (fepriv->exit != DVB_FE_NO_EXIT) 1648 return -ENODEV; 1649 1650 if ((file->f_flags & O_ACCMODE) == O_RDONLY && 1651 (_IOC_DIR(cmd) != _IOC_READ || cmd == FE_GET_EVENT || 1652 cmd == FE_DISEQC_RECV_SLAVE_REPLY)) 1653 return -EPERM; 1654 1655 if (down_interruptible (&fepriv->sem)) 1656 return -ERESTARTSYS; 1657 1658 if ((cmd == FE_SET_PROPERTY) || (cmd == FE_GET_PROPERTY)) 1659 err = dvb_frontend_ioctl_properties(file, cmd, parg); 1660 else { 1661 c->state = DTV_UNDEFINED; 1662 err = dvb_frontend_ioctl_legacy(file, cmd, parg); 1663 } 1664 1665 up(&fepriv->sem); 1666 return err; 1667} 1668 1669static int dvb_frontend_ioctl_properties(struct file *file, 1670 unsigned int cmd, void *parg) 1671{ 1672 struct dvb_device *dvbdev = file->private_data; 1673 struct dvb_frontend *fe = dvbdev->priv; 1674 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1675 int err = 0; 1676 1677 struct dtv_properties *tvps = NULL; 1678 struct dtv_property *tvp = NULL; 1679 int i; 1680 1681 dprintk("%s\n", __func__); 1682 1683 if(cmd == FE_SET_PROPERTY) { 1684 tvps = (struct dtv_properties __user *)parg; 1685 1686 dprintk("%s() properties.num = %d\n", __func__, tvps->num); 1687 dprintk("%s() properties.props = %p\n", __func__, tvps->props); 1688 1689 /* Put an arbitrary limit on the number of messages that can 1690 * be sent at once */ 1691 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS)) 1692 return -EINVAL; 1693 1694 tvp = kmalloc(tvps->num * sizeof(struct dtv_property), GFP_KERNEL); 1695 if (!tvp) { 1696 err = -ENOMEM; 1697 goto out; 1698 } 1699 1700 if (copy_from_user(tvp, tvps->props, tvps->num * sizeof(struct dtv_property))) { 1701 err = -EFAULT; 1702 goto out; 1703 } 1704 1705 for (i = 0; i < tvps->num; i++) { 1706 err = dtv_property_process_set(fe, tvp + i, file); 1707 if (err < 0) 1708 goto out; 1709 (tvp + i)->result = err; 1710 } 1711 1712 if (c->state == DTV_TUNE) 1713 dprintk("%s() Property cache is full, tuning\n", __func__); 1714 1715 } else 1716 if(cmd == FE_GET_PROPERTY) { 1717 struct dtv_frontend_properties cache_out; 1718 1719 tvps = (struct dtv_properties __user *)parg; 1720 1721 dprintk("%s() properties.num = %d\n", __func__, tvps->num); 1722 dprintk("%s() properties.props = %p\n", __func__, tvps->props); 1723 1724 /* Put an arbitrary limit on the number of messages that can 1725 * be sent at once */ 1726 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS)) 1727 return -EINVAL; 1728 1729 tvp = kmalloc(tvps->num * sizeof(struct dtv_property), GFP_KERNEL); 1730 if (!tvp) { 1731 err = -ENOMEM; 1732 goto out; 1733 } 1734 1735 if (copy_from_user(tvp, tvps->props, tvps->num * sizeof(struct dtv_property))) { 1736 err = -EFAULT; 1737 goto out; 1738 } 1739 1740 /* 1741 * Fills the cache out struct with the cache contents, plus 1742 * the data retrieved from get_frontend. 1743 */ 1744 dtv_get_frontend(fe, &cache_out, NULL); 1745 for (i = 0; i < tvps->num; i++) { 1746 err = dtv_property_process_get(fe, &cache_out, tvp + i, file); 1747 if (err < 0) 1748 goto out; 1749 (tvp + i)->result = err; 1750 } 1751 1752 if (copy_to_user(tvps->props, tvp, tvps->num * sizeof(struct dtv_property))) { 1753 err = -EFAULT; 1754 goto out; 1755 } 1756 1757 } else 1758 err = -EOPNOTSUPP; 1759 1760out: 1761 kfree(tvp); 1762 return err; 1763} 1764 1765static int dvb_frontend_ioctl_legacy(struct file *file, 1766 unsigned int cmd, void *parg) 1767{ 1768 struct dvb_device *dvbdev = file->private_data; 1769 struct dvb_frontend *fe = dvbdev->priv; 1770 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1771 int cb_err, err = -EOPNOTSUPP; 1772 1773 if (fe->dvb->fe_ioctl_override) { 1774 cb_err = fe->dvb->fe_ioctl_override(fe, cmd, parg, 1775 DVB_FE_IOCTL_PRE); 1776 if (cb_err < 0) 1777 return cb_err; 1778 if (cb_err > 0) 1779 return 0; 1780 /* fe_ioctl_override returning 0 allows 1781 * dvb-core to continue handling the ioctl */ 1782 } 1783 1784 switch (cmd) { 1785 case FE_GET_INFO: { 1786 struct dvb_frontend_info* info = parg; 1787 memcpy(info, &fe->ops.info, sizeof(struct dvb_frontend_info)); 1788 dvb_frontend_get_frequency_limits(fe, &info->frequency_min, &info->frequency_max); 1789 1790 /* Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't 1791 * do it, it is done for it. */ 1792 info->caps |= FE_CAN_INVERSION_AUTO; 1793 err = 0; 1794 break; 1795 } 1796 1797 case FE_READ_STATUS: { 1798 fe_status_t* status = parg; 1799 1800 /* if retune was requested but hasn't occurred yet, prevent 1801 * that user get signal state from previous tuning */ 1802 if (fepriv->state == FESTATE_RETUNE || 1803 fepriv->state == FESTATE_ERROR) { 1804 err=0; 1805 *status = 0; 1806 break; 1807 } 1808 1809 if (fe->ops.read_status) 1810 err = fe->ops.read_status(fe, status); 1811 break; 1812 } 1813 case FE_READ_BER: 1814 if (fe->ops.read_ber) 1815 err = fe->ops.read_ber(fe, (__u32*) parg); 1816 break; 1817 1818 case FE_READ_SIGNAL_STRENGTH: 1819 if (fe->ops.read_signal_strength) 1820 err = fe->ops.read_signal_strength(fe, (__u16*) parg); 1821 break; 1822 1823 case FE_READ_SNR: 1824 if (fe->ops.read_snr) 1825 err = fe->ops.read_snr(fe, (__u16*) parg); 1826 break; 1827 1828 case FE_READ_UNCORRECTED_BLOCKS: 1829 if (fe->ops.read_ucblocks) 1830 err = fe->ops.read_ucblocks(fe, (__u32*) parg); 1831 break; 1832 1833 1834 case FE_DISEQC_RESET_OVERLOAD: 1835 if (fe->ops.diseqc_reset_overload) { 1836 err = fe->ops.diseqc_reset_overload(fe); 1837 fepriv->state = FESTATE_DISEQC; 1838 fepriv->status = 0; 1839 } 1840 break; 1841 1842 case FE_DISEQC_SEND_MASTER_CMD: 1843 if (fe->ops.diseqc_send_master_cmd) { 1844 err = fe->ops.diseqc_send_master_cmd(fe, (struct dvb_diseqc_master_cmd*) parg); 1845 fepriv->state = FESTATE_DISEQC; 1846 fepriv->status = 0; 1847 } 1848 break; 1849 1850 case FE_DISEQC_SEND_BURST: 1851 if (fe->ops.diseqc_send_burst) { 1852 err = fe->ops.diseqc_send_burst(fe, (fe_sec_mini_cmd_t) parg); 1853 fepriv->state = FESTATE_DISEQC; 1854 fepriv->status = 0; 1855 } 1856 break; 1857 1858 case FE_SET_TONE: 1859 if (fe->ops.set_tone) { 1860 err = fe->ops.set_tone(fe, (fe_sec_tone_mode_t) parg); 1861 fepriv->tone = (fe_sec_tone_mode_t) parg; 1862 fepriv->state = FESTATE_DISEQC; 1863 fepriv->status = 0; 1864 } 1865 break; 1866 1867 case FE_SET_VOLTAGE: 1868 if (fe->ops.set_voltage) { 1869 err = fe->ops.set_voltage(fe, (fe_sec_voltage_t) parg); 1870 fepriv->voltage = (fe_sec_voltage_t) parg; 1871 fepriv->state = FESTATE_DISEQC; 1872 fepriv->status = 0; 1873 } 1874 break; 1875 1876 case FE_DISHNETWORK_SEND_LEGACY_CMD: 1877 if (fe->ops.dishnetwork_send_legacy_command) { 1878 err = fe->ops.dishnetwork_send_legacy_command(fe, (unsigned long) parg); 1879 fepriv->state = FESTATE_DISEQC; 1880 fepriv->status = 0; 1881 } else if (fe->ops.set_voltage) { 1882 /* 1883 * NOTE: This is a fallback condition. Some frontends 1884 * (stv0299 for instance) take longer than 8msec to 1885 * respond to a set_voltage command. Those switches 1886 * need custom routines to switch properly. For all 1887 * other frontends, the following should work ok. 1888 * Dish network legacy switches (as used by Dish500) 1889 * are controlled by sending 9-bit command words 1890 * spaced 8msec apart. 1891 * the actual command word is switch/port dependent 1892 * so it is up to the userspace application to send 1893 * the right command. 1894 * The command must always start with a '0' after 1895 * initialization, so parg is 8 bits and does not 1896 * include the initialization or start bit 1897 */ 1898 unsigned long swcmd = ((unsigned long) parg) << 1; 1899 struct timeval nexttime; 1900 struct timeval tv[10]; 1901 int i; 1902 u8 last = 1; 1903 if (dvb_frontend_debug) 1904 printk("%s switch command: 0x%04lx\n", __func__, swcmd); 1905 do_gettimeofday(&nexttime); 1906 if (dvb_frontend_debug) 1907 memcpy(&tv[0], &nexttime, sizeof(struct timeval)); 1908 /* before sending a command, initialize by sending 1909 * a 32ms 18V to the switch 1910 */ 1911 fe->ops.set_voltage(fe, SEC_VOLTAGE_18); 1912 dvb_frontend_sleep_until(&nexttime, 32000); 1913 1914 for (i = 0; i < 9; i++) { 1915 if (dvb_frontend_debug) 1916 do_gettimeofday(&tv[i + 1]); 1917 if ((swcmd & 0x01) != last) { 1918 /* set voltage to (last ? 13V : 18V) */ 1919 fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18); 1920 last = (last) ? 0 : 1; 1921 } 1922 swcmd = swcmd >> 1; 1923 if (i != 8) 1924 dvb_frontend_sleep_until(&nexttime, 8000); 1925 } 1926 if (dvb_frontend_debug) { 1927 printk("%s(%d): switch delay (should be 32k followed by all 8k\n", 1928 __func__, fe->dvb->num); 1929 for (i = 1; i < 10; i++) 1930 printk("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i])); 1931 } 1932 err = 0; 1933 fepriv->state = FESTATE_DISEQC; 1934 fepriv->status = 0; 1935 } 1936 break; 1937 1938 case FE_DISEQC_RECV_SLAVE_REPLY: 1939 if (fe->ops.diseqc_recv_slave_reply) 1940 err = fe->ops.diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg); 1941 break; 1942 1943 case FE_ENABLE_HIGH_LNB_VOLTAGE: 1944 if (fe->ops.enable_high_lnb_voltage) 1945 err = fe->ops.enable_high_lnb_voltage(fe, (long) parg); 1946 break; 1947 1948 case FE_SET_FRONTEND: { 1949 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1950 struct dvb_frontend_tune_settings fetunesettings; 1951 1952 if (c->state == DTV_TUNE) { 1953 if (dvb_frontend_check_parameters(fe, &fepriv->parameters_in) < 0) { 1954 err = -EINVAL; 1955 break; 1956 } 1957 } else { 1958 if (dvb_frontend_check_parameters(fe, parg) < 0) { 1959 err = -EINVAL; 1960 break; 1961 } 1962 1963 memcpy (&fepriv->parameters_in, parg, 1964 sizeof (struct dvb_frontend_parameters)); 1965 dtv_property_cache_init(fe, c); 1966 dtv_property_cache_sync(fe, c, &fepriv->parameters_in); 1967 } 1968 1969 /* 1970 * Initialize output parameters to match the values given by 1971 * the user. FE_SET_FRONTEND triggers an initial frontend event 1972 * with status = 0, which copies output parameters to userspace. 1973 */ 1974 fepriv->parameters_out = fepriv->parameters_in; 1975 1976 memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings)); 1977 1978 /* force auto frequency inversion if requested */ 1979 if (dvb_force_auto_inversion) { 1980 fepriv->parameters_in.inversion = INVERSION_AUTO; 1981 } 1982 if (fe->ops.info.type == FE_OFDM) { 1983 /* without hierarchical coding code_rate_LP is irrelevant, 1984 * so we tolerate the otherwise invalid FEC_NONE setting */ 1985 if (fepriv->parameters_in.u.ofdm.hierarchy_information == HIERARCHY_NONE && 1986 fepriv->parameters_in.u.ofdm.code_rate_LP == FEC_NONE) 1987 fepriv->parameters_in.u.ofdm.code_rate_LP = FEC_AUTO; 1988 } 1989 1990 /* get frontend-specific tuning settings */ 1991 if (fe->ops.get_tune_settings && (fe->ops.get_tune_settings(fe, &fetunesettings) == 0)) { 1992 fepriv->min_delay = (fetunesettings.min_delay_ms * HZ) / 1000; 1993 fepriv->max_drift = fetunesettings.max_drift; 1994 fepriv->step_size = fetunesettings.step_size; 1995 } else { 1996 /* default values */ 1997 switch(fe->ops.info.type) { 1998 case FE_QPSK: 1999 fepriv->min_delay = HZ/20; 2000 fepriv->step_size = fepriv->parameters_in.u.qpsk.symbol_rate / 16000; 2001 fepriv->max_drift = fepriv->parameters_in.u.qpsk.symbol_rate / 2000; 2002 break; 2003 2004 case FE_QAM: 2005 fepriv->min_delay = HZ/20; 2006 fepriv->step_size = 0; /* no zigzag */ 2007 fepriv->max_drift = 0; 2008 break; 2009 2010 case FE_OFDM: 2011 fepriv->min_delay = HZ/20; 2012 fepriv->step_size = fe->ops.info.frequency_stepsize * 2; 2013 fepriv->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1; 2014 break; 2015 case FE_ATSC: 2016 fepriv->min_delay = HZ/20; 2017 fepriv->step_size = 0; 2018 fepriv->max_drift = 0; 2019 break; 2020 } 2021 } 2022 if (dvb_override_tune_delay > 0) 2023 fepriv->min_delay = (dvb_override_tune_delay * HZ) / 1000; 2024 2025 fepriv->state = FESTATE_RETUNE; 2026 2027 /* Request the search algorithm to search */ 2028 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN; 2029 2030 dvb_frontend_clear_events(fe); 2031 dvb_frontend_add_event(fe, 0); 2032 dvb_frontend_wakeup(fe); 2033 fepriv->status = 0; 2034 err = 0; 2035 break; 2036 } 2037 2038 case FE_GET_EVENT: 2039 err = dvb_frontend_get_event (fe, parg, file->f_flags); 2040 break; 2041 2042 case FE_GET_FRONTEND: 2043 err = dtv_get_frontend(fe, NULL, &fepriv->parameters_out); 2044 if (err >= 0) 2045 memcpy(parg, &fepriv->parameters_out, 2046 sizeof(struct dvb_frontend_parameters)); 2047 break; 2048 2049 case FE_SET_FRONTEND_TUNE_MODE: 2050 fepriv->tune_mode_flags = (unsigned long) parg; 2051 err = 0; 2052 break; 2053 }; 2054 2055 if (fe->dvb->fe_ioctl_override) { 2056 cb_err = fe->dvb->fe_ioctl_override(fe, cmd, parg, 2057 DVB_FE_IOCTL_POST); 2058 if (cb_err < 0) 2059 return cb_err; 2060 } 2061 2062 return err; 2063} 2064 2065 2066static unsigned int dvb_frontend_poll(struct file *file, struct poll_table_struct *wait) 2067{ 2068 struct dvb_device *dvbdev = file->private_data; 2069 struct dvb_frontend *fe = dvbdev->priv; 2070 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2071 2072 dprintk ("%s\n", __func__); 2073 2074 poll_wait (file, &fepriv->events.wait_queue, wait); 2075 2076 if (fepriv->events.eventw != fepriv->events.eventr) 2077 return (POLLIN | POLLRDNORM | POLLPRI); 2078 2079 return 0; 2080} 2081 2082static int dvb_frontend_open(struct inode *inode, struct file *file) 2083{ 2084 struct dvb_device *dvbdev = file->private_data; 2085 struct dvb_frontend *fe = dvbdev->priv; 2086 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2087 struct dvb_adapter *adapter = fe->dvb; 2088 int ret; 2089 2090 dprintk ("%s\n", __func__); 2091 if (fepriv->exit == DVB_FE_DEVICE_REMOVED) 2092 return -ENODEV; 2093 2094 if (adapter->mfe_shared) { 2095 mutex_lock (&adapter->mfe_lock); 2096 2097 if (adapter->mfe_dvbdev == NULL) 2098 adapter->mfe_dvbdev = dvbdev; 2099 2100 else if (adapter->mfe_dvbdev != dvbdev) { 2101 struct dvb_device 2102 *mfedev = adapter->mfe_dvbdev; 2103 struct dvb_frontend 2104 *mfe = mfedev->priv; 2105 struct dvb_frontend_private 2106 *mfepriv = mfe->frontend_priv; 2107 int mferetry = (dvb_mfe_wait_time << 1); 2108 2109 mutex_unlock (&adapter->mfe_lock); 2110 while (mferetry-- && (mfedev->users != -1 || 2111 mfepriv->thread != NULL)) { 2112 if(msleep_interruptible(500)) { 2113 if(signal_pending(current)) 2114 return -EINTR; 2115 } 2116 } 2117 2118 mutex_lock (&adapter->mfe_lock); 2119 if(adapter->mfe_dvbdev != dvbdev) { 2120 mfedev = adapter->mfe_dvbdev; 2121 mfe = mfedev->priv; 2122 mfepriv = mfe->frontend_priv; 2123 if (mfedev->users != -1 || 2124 mfepriv->thread != NULL) { 2125 mutex_unlock (&adapter->mfe_lock); 2126 return -EBUSY; 2127 } 2128 adapter->mfe_dvbdev = dvbdev; 2129 } 2130 } 2131 } 2132 2133 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) { 2134 if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0) 2135 goto err0; 2136 2137 /* If we took control of the bus, we need to force 2138 reinitialization. This is because many ts_bus_ctrl() 2139 functions strobe the RESET pin on the demod, and if the 2140 frontend thread already exists then the dvb_init() routine 2141 won't get called (which is what usually does initial 2142 register configuration). */ 2143 fepriv->reinitialise = 1; 2144 } 2145 2146 if ((ret = dvb_generic_open (inode, file)) < 0) 2147 goto err1; 2148 2149 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 2150 /* normal tune mode when opened R/W */ 2151 fepriv->tune_mode_flags &= ~FE_TUNE_MODE_ONESHOT; 2152 fepriv->tone = -1; 2153 fepriv->voltage = -1; 2154 2155 ret = dvb_frontend_start (fe); 2156 if (ret) 2157 goto err2; 2158 2159 /* empty event queue */ 2160 fepriv->events.eventr = fepriv->events.eventw = 0; 2161 } 2162 2163 if (adapter->mfe_shared) 2164 mutex_unlock (&adapter->mfe_lock); 2165 return ret; 2166 2167err2: 2168 dvb_generic_release(inode, file); 2169err1: 2170 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) 2171 fe->ops.ts_bus_ctrl(fe, 0); 2172err0: 2173 if (adapter->mfe_shared) 2174 mutex_unlock (&adapter->mfe_lock); 2175 return ret; 2176} 2177 2178static int dvb_frontend_release(struct inode *inode, struct file *file) 2179{ 2180 struct dvb_device *dvbdev = file->private_data; 2181 struct dvb_frontend *fe = dvbdev->priv; 2182 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2183 int ret; 2184 2185 dprintk ("%s\n", __func__); 2186 2187 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 2188 fepriv->release_jiffies = jiffies; 2189 mb(); 2190 } 2191 2192 ret = dvb_generic_release (inode, file); 2193 2194 if (dvbdev->users == -1) { 2195 wake_up(&fepriv->wait_queue); 2196 if (fepriv->exit != DVB_FE_NO_EXIT) { 2197 fops_put(file->f_op); 2198 file->f_op = NULL; 2199 wake_up(&dvbdev->wait_queue); 2200 } 2201 if (fe->ops.ts_bus_ctrl) 2202 fe->ops.ts_bus_ctrl(fe, 0); 2203 } 2204 2205 return ret; 2206} 2207 2208static const struct file_operations dvb_frontend_fops = { 2209 .owner = THIS_MODULE, 2210 .unlocked_ioctl = dvb_generic_ioctl, 2211 .poll = dvb_frontend_poll, 2212 .open = dvb_frontend_open, 2213 .release = dvb_frontend_release, 2214 .llseek = noop_llseek, 2215}; 2216 2217int dvb_register_frontend(struct dvb_adapter* dvb, 2218 struct dvb_frontend* fe) 2219{ 2220 struct dvb_frontend_private *fepriv; 2221 static const struct dvb_device dvbdev_template = { 2222 .users = ~0, 2223 .writers = 1, 2224 .readers = (~0)-1, 2225 .fops = &dvb_frontend_fops, 2226 .kernel_ioctl = dvb_frontend_ioctl 2227 }; 2228 2229 dprintk ("%s\n", __func__); 2230 2231 if (mutex_lock_interruptible(&frontend_mutex)) 2232 return -ERESTARTSYS; 2233 2234 fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL); 2235 if (fe->frontend_priv == NULL) { 2236 mutex_unlock(&frontend_mutex); 2237 return -ENOMEM; 2238 } 2239 fepriv = fe->frontend_priv; 2240 2241 sema_init(&fepriv->sem, 1); 2242 init_waitqueue_head (&fepriv->wait_queue); 2243 init_waitqueue_head (&fepriv->events.wait_queue); 2244 mutex_init(&fepriv->events.mtx); 2245 fe->dvb = dvb; 2246 fepriv->inversion = INVERSION_OFF; 2247 2248 printk ("DVB: registering adapter %i frontend %i (%s)...\n", 2249 fe->dvb->num, 2250 fe->id, 2251 fe->ops.info.name); 2252 2253 dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template, 2254 fe, DVB_DEVICE_FRONTEND); 2255 2256 mutex_unlock(&frontend_mutex); 2257 return 0; 2258} 2259EXPORT_SYMBOL(dvb_register_frontend); 2260 2261int dvb_unregister_frontend(struct dvb_frontend* fe) 2262{ 2263 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2264 dprintk ("%s\n", __func__); 2265 2266 mutex_lock(&frontend_mutex); 2267 dvb_frontend_stop (fe); 2268 mutex_unlock(&frontend_mutex); 2269 2270 if (fepriv->dvbdev->users < -1) 2271 wait_event(fepriv->dvbdev->wait_queue, 2272 fepriv->dvbdev->users==-1); 2273 2274 mutex_lock(&frontend_mutex); 2275 dvb_unregister_device (fepriv->dvbdev); 2276 2277 /* fe is invalid now */ 2278 kfree(fepriv); 2279 mutex_unlock(&frontend_mutex); 2280 return 0; 2281} 2282EXPORT_SYMBOL(dvb_unregister_frontend); 2283 2284#ifdef CONFIG_MEDIA_ATTACH 2285void dvb_frontend_detach(struct dvb_frontend* fe) 2286{ 2287 void *ptr; 2288 2289 if (fe->ops.release_sec) { 2290 fe->ops.release_sec(fe); 2291 symbol_put_addr(fe->ops.release_sec); 2292 } 2293 if (fe->ops.tuner_ops.release) { 2294 fe->ops.tuner_ops.release(fe); 2295 symbol_put_addr(fe->ops.tuner_ops.release); 2296 } 2297 if (fe->ops.analog_ops.release) { 2298 fe->ops.analog_ops.release(fe); 2299 symbol_put_addr(fe->ops.analog_ops.release); 2300 } 2301 ptr = (void*)fe->ops.release; 2302 if (ptr) { 2303 fe->ops.release(fe); 2304 symbol_put_addr(ptr); 2305 } 2306} 2307#else 2308void dvb_frontend_detach(struct dvb_frontend* fe) 2309{ 2310 if (fe->ops.release_sec) 2311 fe->ops.release_sec(fe); 2312 if (fe->ops.tuner_ops.release) 2313 fe->ops.tuner_ops.release(fe); 2314 if (fe->ops.analog_ops.release) 2315 fe->ops.analog_ops.release(fe); 2316 if (fe->ops.release) 2317 fe->ops.release(fe); 2318} 2319#endif 2320EXPORT_SYMBOL(dvb_frontend_detach); 2321