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 /* Enables DVBv3 compatibility bits at the headers */ 29 #define __DVB_CORE__ 30 31 #include <linux/string.h> 32 #include <linux/kernel.h> 33 #include <linux/sched.h> 34 #include <linux/wait.h> 35 #include <linux/slab.h> 36 #include <linux/poll.h> 37 #include <linux/semaphore.h> 38 #include <linux/module.h> 39 #include <linux/list.h> 40 #include <linux/freezer.h> 41 #include <linux/jiffies.h> 42 #include <linux/kthread.h> 43 #include <linux/ktime.h> 44 #include <asm/processor.h> 45 46 #include "dvb_frontend.h" 47 #include "dvbdev.h" 48 #include <linux/dvb/version.h> 49 50 static int dvb_frontend_debug; 51 static int dvb_shutdown_timeout; 52 static int dvb_force_auto_inversion; 53 static int dvb_override_tune_delay; 54 static int dvb_powerdown_on_sleep = 1; 55 static int dvb_mfe_wait_time = 5; 56 57 module_param_named(frontend_debug, dvb_frontend_debug, int, 0644); 58 MODULE_PARM_DESC(frontend_debug, "Turn on/off frontend core debugging (default:off)."); 59 module_param(dvb_shutdown_timeout, int, 0644); 60 MODULE_PARM_DESC(dvb_shutdown_timeout, "wait <shutdown_timeout> seconds after close() before suspending hardware"); 61 module_param(dvb_force_auto_inversion, int, 0644); 62 MODULE_PARM_DESC(dvb_force_auto_inversion, "0: normal (default), 1: INVERSION_AUTO forced always"); 63 module_param(dvb_override_tune_delay, int, 0644); 64 MODULE_PARM_DESC(dvb_override_tune_delay, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt"); 65 module_param(dvb_powerdown_on_sleep, int, 0644); 66 MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB voltage off on sleep (default)"); 67 module_param(dvb_mfe_wait_time, int, 0644); 68 MODULE_PARM_DESC(dvb_mfe_wait_time, "Wait up to <mfe_wait_time> seconds on open() for multi-frontend to become available (default:5 seconds)"); 69 70 #define FESTATE_IDLE 1 71 #define FESTATE_RETUNE 2 72 #define FESTATE_TUNING_FAST 4 73 #define FESTATE_TUNING_SLOW 8 74 #define FESTATE_TUNED 16 75 #define FESTATE_ZIGZAG_FAST 32 76 #define FESTATE_ZIGZAG_SLOW 64 77 #define FESTATE_DISEQC 128 78 #define FESTATE_ERROR 256 79 #define FESTATE_WAITFORLOCK (FESTATE_TUNING_FAST | FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW | FESTATE_DISEQC) 80 #define FESTATE_SEARCHING_FAST (FESTATE_TUNING_FAST | FESTATE_ZIGZAG_FAST) 81 #define FESTATE_SEARCHING_SLOW (FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_SLOW) 82 #define FESTATE_LOSTLOCK (FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW) 83 84 /* 85 * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling. 86 * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune. 87 * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress. 88 * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower. 89 * FESTATE_TUNED. The frontend has successfully locked on. 90 * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it. 91 * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower. 92 * FESTATE_DISEQC. A DISEQC command has just been issued. 93 * FESTATE_WAITFORLOCK. When we're waiting for a lock. 94 * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan. 95 * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan. 96 * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again. 97 */ 98 99 static DEFINE_MUTEX(frontend_mutex); 100 101 struct dvb_frontend_private { 102 103 /* thread/frontend values */ 104 struct dvb_device *dvbdev; 105 struct dvb_frontend_parameters parameters_out; 106 struct dvb_fe_events events; 107 struct semaphore sem; 108 struct list_head list_head; 109 wait_queue_head_t wait_queue; 110 struct task_struct *thread; 111 unsigned long release_jiffies; 112 unsigned int wakeup; 113 enum fe_status status; 114 unsigned long tune_mode_flags; 115 unsigned int delay; 116 unsigned int reinitialise; 117 int tone; 118 int voltage; 119 120 /* swzigzag values */ 121 unsigned int state; 122 unsigned int bending; 123 int lnb_drift; 124 unsigned int inversion; 125 unsigned int auto_step; 126 unsigned int auto_sub_step; 127 unsigned int started_auto_step; 128 unsigned int min_delay; 129 unsigned int max_drift; 130 unsigned int step_size; 131 int quality; 132 unsigned int check_wrapped; 133 enum dvbfe_search algo_status; 134 135 #if defined(CONFIG_MEDIA_CONTROLLER_DVB) 136 struct media_pipeline pipe; 137 struct media_entity *pipe_start_entity; 138 #endif 139 }; 140 141 static void dvb_frontend_wakeup(struct dvb_frontend *fe); 142 static int dtv_get_frontend(struct dvb_frontend *fe, 143 struct dtv_frontend_properties *c, 144 struct dvb_frontend_parameters *p_out); 145 static int 146 dtv_property_legacy_params_sync(struct dvb_frontend *fe, 147 const struct dtv_frontend_properties *c, 148 struct dvb_frontend_parameters *p); 149 150 static bool has_get_frontend(struct dvb_frontend *fe) 151 { 152 return fe->ops.get_frontend != NULL; 153 } 154 155 /* 156 * Due to DVBv3 API calls, a delivery system should be mapped into one of 157 * the 4 DVBv3 delivery systems (FE_QPSK, FE_QAM, FE_OFDM or FE_ATSC), 158 * otherwise, a DVBv3 call will fail. 159 */ 160 enum dvbv3_emulation_type { 161 DVBV3_UNKNOWN, 162 DVBV3_QPSK, 163 DVBV3_QAM, 164 DVBV3_OFDM, 165 DVBV3_ATSC, 166 }; 167 168 static enum dvbv3_emulation_type dvbv3_type(u32 delivery_system) 169 { 170 switch (delivery_system) { 171 case SYS_DVBC_ANNEX_A: 172 case SYS_DVBC_ANNEX_C: 173 return DVBV3_QAM; 174 case SYS_DVBS: 175 case SYS_DVBS2: 176 case SYS_TURBO: 177 case SYS_ISDBS: 178 case SYS_DSS: 179 return DVBV3_QPSK; 180 case SYS_DVBT: 181 case SYS_DVBT2: 182 case SYS_ISDBT: 183 case SYS_DTMB: 184 return DVBV3_OFDM; 185 case SYS_ATSC: 186 case SYS_ATSCMH: 187 case SYS_DVBC_ANNEX_B: 188 return DVBV3_ATSC; 189 case SYS_UNDEFINED: 190 case SYS_ISDBC: 191 case SYS_DVBH: 192 case SYS_DAB: 193 default: 194 /* 195 * Doesn't know how to emulate those types and/or 196 * there's no frontend driver from this type yet 197 * with some emulation code, so, we're not sure yet how 198 * to handle them, or they're not compatible with a DVBv3 call. 199 */ 200 return DVBV3_UNKNOWN; 201 } 202 } 203 204 static void dvb_frontend_add_event(struct dvb_frontend *fe, 205 enum fe_status status) 206 { 207 struct dvb_frontend_private *fepriv = fe->frontend_priv; 208 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 209 struct dvb_fe_events *events = &fepriv->events; 210 struct dvb_frontend_event *e; 211 int wp; 212 213 dev_dbg(fe->dvb->device, "%s:\n", __func__); 214 215 if ((status & FE_HAS_LOCK) && has_get_frontend(fe)) 216 dtv_get_frontend(fe, c, &fepriv->parameters_out); 217 218 mutex_lock(&events->mtx); 219 220 wp = (events->eventw + 1) % MAX_EVENT; 221 if (wp == events->eventr) { 222 events->overflow = 1; 223 events->eventr = (events->eventr + 1) % MAX_EVENT; 224 } 225 226 e = &events->events[events->eventw]; 227 e->status = status; 228 e->parameters = fepriv->parameters_out; 229 230 events->eventw = wp; 231 232 mutex_unlock(&events->mtx); 233 234 wake_up_interruptible (&events->wait_queue); 235 } 236 237 static int dvb_frontend_get_event(struct dvb_frontend *fe, 238 struct dvb_frontend_event *event, int flags) 239 { 240 struct dvb_frontend_private *fepriv = fe->frontend_priv; 241 struct dvb_fe_events *events = &fepriv->events; 242 243 dev_dbg(fe->dvb->device, "%s:\n", __func__); 244 245 if (events->overflow) { 246 events->overflow = 0; 247 return -EOVERFLOW; 248 } 249 250 if (events->eventw == events->eventr) { 251 int ret; 252 253 if (flags & O_NONBLOCK) 254 return -EWOULDBLOCK; 255 256 up(&fepriv->sem); 257 258 ret = wait_event_interruptible (events->wait_queue, 259 events->eventw != events->eventr); 260 261 if (down_interruptible (&fepriv->sem)) 262 return -ERESTARTSYS; 263 264 if (ret < 0) 265 return ret; 266 } 267 268 mutex_lock(&events->mtx); 269 *event = events->events[events->eventr]; 270 events->eventr = (events->eventr + 1) % MAX_EVENT; 271 mutex_unlock(&events->mtx); 272 273 return 0; 274 } 275 276 static void dvb_frontend_clear_events(struct dvb_frontend *fe) 277 { 278 struct dvb_frontend_private *fepriv = fe->frontend_priv; 279 struct dvb_fe_events *events = &fepriv->events; 280 281 mutex_lock(&events->mtx); 282 events->eventr = events->eventw; 283 mutex_unlock(&events->mtx); 284 } 285 286 static void dvb_frontend_init(struct dvb_frontend *fe) 287 { 288 dev_dbg(fe->dvb->device, 289 "%s: initialising adapter %i frontend %i (%s)...\n", 290 __func__, fe->dvb->num, fe->id, fe->ops.info.name); 291 292 if (fe->ops.init) 293 fe->ops.init(fe); 294 if (fe->ops.tuner_ops.init) { 295 if (fe->ops.i2c_gate_ctrl) 296 fe->ops.i2c_gate_ctrl(fe, 1); 297 fe->ops.tuner_ops.init(fe); 298 if (fe->ops.i2c_gate_ctrl) 299 fe->ops.i2c_gate_ctrl(fe, 0); 300 } 301 } 302 303 void dvb_frontend_reinitialise(struct dvb_frontend *fe) 304 { 305 struct dvb_frontend_private *fepriv = fe->frontend_priv; 306 307 fepriv->reinitialise = 1; 308 dvb_frontend_wakeup(fe); 309 } 310 EXPORT_SYMBOL(dvb_frontend_reinitialise); 311 312 static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private *fepriv, int locked) 313 { 314 int q2; 315 struct dvb_frontend *fe = fepriv->dvbdev->priv; 316 317 dev_dbg(fe->dvb->device, "%s:\n", __func__); 318 319 if (locked) 320 (fepriv->quality) = (fepriv->quality * 220 + 36*256) / 256; 321 else 322 (fepriv->quality) = (fepriv->quality * 220 + 0) / 256; 323 324 q2 = fepriv->quality - 128; 325 q2 *= q2; 326 327 fepriv->delay = fepriv->min_delay + q2 * HZ / (128*128); 328 } 329 330 /** 331 * Performs automatic twiddling of frontend parameters. 332 * 333 * @param fe The frontend concerned. 334 * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT 335 * @returns Number of complete iterations that have been performed. 336 */ 337 static int dvb_frontend_swzigzag_autotune(struct dvb_frontend *fe, int check_wrapped) 338 { 339 int autoinversion; 340 int ready = 0; 341 int fe_set_err = 0; 342 struct dvb_frontend_private *fepriv = fe->frontend_priv; 343 struct dtv_frontend_properties *c = &fe->dtv_property_cache, tmp; 344 int original_inversion = c->inversion; 345 u32 original_frequency = c->frequency; 346 347 /* are we using autoinversion? */ 348 autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && 349 (c->inversion == INVERSION_AUTO)); 350 351 /* setup parameters correctly */ 352 while(!ready) { 353 /* calculate the lnb_drift */ 354 fepriv->lnb_drift = fepriv->auto_step * fepriv->step_size; 355 356 /* wrap the auto_step if we've exceeded the maximum drift */ 357 if (fepriv->lnb_drift > fepriv->max_drift) { 358 fepriv->auto_step = 0; 359 fepriv->auto_sub_step = 0; 360 fepriv->lnb_drift = 0; 361 } 362 363 /* perform inversion and +/- zigzag */ 364 switch(fepriv->auto_sub_step) { 365 case 0: 366 /* try with the current inversion and current drift setting */ 367 ready = 1; 368 break; 369 370 case 1: 371 if (!autoinversion) break; 372 373 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF; 374 ready = 1; 375 break; 376 377 case 2: 378 if (fepriv->lnb_drift == 0) break; 379 380 fepriv->lnb_drift = -fepriv->lnb_drift; 381 ready = 1; 382 break; 383 384 case 3: 385 if (fepriv->lnb_drift == 0) break; 386 if (!autoinversion) break; 387 388 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF; 389 fepriv->lnb_drift = -fepriv->lnb_drift; 390 ready = 1; 391 break; 392 393 default: 394 fepriv->auto_step++; 395 fepriv->auto_sub_step = -1; /* it'll be incremented to 0 in a moment */ 396 break; 397 } 398 399 if (!ready) fepriv->auto_sub_step++; 400 } 401 402 /* if this attempt would hit where we started, indicate a complete 403 * iteration has occurred */ 404 if ((fepriv->auto_step == fepriv->started_auto_step) && 405 (fepriv->auto_sub_step == 0) && check_wrapped) { 406 return 1; 407 } 408 409 dev_dbg(fe->dvb->device, "%s: drift:%i inversion:%i auto_step:%i " \ 410 "auto_sub_step:%i started_auto_step:%i\n", 411 __func__, fepriv->lnb_drift, fepriv->inversion, 412 fepriv->auto_step, fepriv->auto_sub_step, 413 fepriv->started_auto_step); 414 415 /* set the frontend itself */ 416 c->frequency += fepriv->lnb_drift; 417 if (autoinversion) 418 c->inversion = fepriv->inversion; 419 tmp = *c; 420 if (fe->ops.set_frontend) 421 fe_set_err = fe->ops.set_frontend(fe); 422 *c = tmp; 423 if (fe_set_err < 0) { 424 fepriv->state = FESTATE_ERROR; 425 return fe_set_err; 426 } 427 428 c->frequency = original_frequency; 429 c->inversion = original_inversion; 430 431 fepriv->auto_sub_step++; 432 return 0; 433 } 434 435 static void dvb_frontend_swzigzag(struct dvb_frontend *fe) 436 { 437 enum fe_status s = 0; 438 int retval = 0; 439 struct dvb_frontend_private *fepriv = fe->frontend_priv; 440 struct dtv_frontend_properties *c = &fe->dtv_property_cache, tmp; 441 442 /* if we've got no parameters, just keep idling */ 443 if (fepriv->state & FESTATE_IDLE) { 444 fepriv->delay = 3*HZ; 445 fepriv->quality = 0; 446 return; 447 } 448 449 /* in SCAN mode, we just set the frontend when asked and leave it alone */ 450 if (fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT) { 451 if (fepriv->state & FESTATE_RETUNE) { 452 tmp = *c; 453 if (fe->ops.set_frontend) 454 retval = fe->ops.set_frontend(fe); 455 *c = tmp; 456 if (retval < 0) 457 fepriv->state = FESTATE_ERROR; 458 else 459 fepriv->state = FESTATE_TUNED; 460 } 461 fepriv->delay = 3*HZ; 462 fepriv->quality = 0; 463 return; 464 } 465 466 /* get the frontend status */ 467 if (fepriv->state & FESTATE_RETUNE) { 468 s = 0; 469 } else { 470 if (fe->ops.read_status) 471 fe->ops.read_status(fe, &s); 472 if (s != fepriv->status) { 473 dvb_frontend_add_event(fe, s); 474 fepriv->status = s; 475 } 476 } 477 478 /* if we're not tuned, and we have a lock, move to the TUNED state */ 479 if ((fepriv->state & FESTATE_WAITFORLOCK) && (s & FE_HAS_LOCK)) { 480 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 481 fepriv->state = FESTATE_TUNED; 482 483 /* if we're tuned, then we have determined the correct inversion */ 484 if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && 485 (c->inversion == INVERSION_AUTO)) { 486 c->inversion = fepriv->inversion; 487 } 488 return; 489 } 490 491 /* if we are tuned already, check we're still locked */ 492 if (fepriv->state & FESTATE_TUNED) { 493 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 494 495 /* we're tuned, and the lock is still good... */ 496 if (s & FE_HAS_LOCK) { 497 return; 498 } else { /* if we _WERE_ tuned, but now don't have a lock */ 499 fepriv->state = FESTATE_ZIGZAG_FAST; 500 fepriv->started_auto_step = fepriv->auto_step; 501 fepriv->check_wrapped = 0; 502 } 503 } 504 505 /* don't actually do anything if we're in the LOSTLOCK state, 506 * the frontend is set to FE_CAN_RECOVER, and the max_drift is 0 */ 507 if ((fepriv->state & FESTATE_LOSTLOCK) && 508 (fe->ops.info.caps & FE_CAN_RECOVER) && (fepriv->max_drift == 0)) { 509 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 510 return; 511 } 512 513 /* don't do anything if we're in the DISEQC state, since this 514 * might be someone with a motorized dish controlled by DISEQC. 515 * If its actually a re-tune, there will be a SET_FRONTEND soon enough. */ 516 if (fepriv->state & FESTATE_DISEQC) { 517 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 518 return; 519 } 520 521 /* if we're in the RETUNE state, set everything up for a brand 522 * new scan, keeping the current inversion setting, as the next 523 * tune is _very_ likely to require the same */ 524 if (fepriv->state & FESTATE_RETUNE) { 525 fepriv->lnb_drift = 0; 526 fepriv->auto_step = 0; 527 fepriv->auto_sub_step = 0; 528 fepriv->started_auto_step = 0; 529 fepriv->check_wrapped = 0; 530 } 531 532 /* fast zigzag. */ 533 if ((fepriv->state & FESTATE_SEARCHING_FAST) || (fepriv->state & FESTATE_RETUNE)) { 534 fepriv->delay = fepriv->min_delay; 535 536 /* perform a tune */ 537 retval = dvb_frontend_swzigzag_autotune(fe, 538 fepriv->check_wrapped); 539 if (retval < 0) { 540 return; 541 } else if (retval) { 542 /* OK, if we've run out of trials at the fast speed. 543 * Drop back to slow for the _next_ attempt */ 544 fepriv->state = FESTATE_SEARCHING_SLOW; 545 fepriv->started_auto_step = fepriv->auto_step; 546 return; 547 } 548 fepriv->check_wrapped = 1; 549 550 /* if we've just retuned, enter the ZIGZAG_FAST state. 551 * This ensures we cannot return from an 552 * FE_SET_FRONTEND ioctl before the first frontend tune 553 * occurs */ 554 if (fepriv->state & FESTATE_RETUNE) { 555 fepriv->state = FESTATE_TUNING_FAST; 556 } 557 } 558 559 /* slow zigzag */ 560 if (fepriv->state & FESTATE_SEARCHING_SLOW) { 561 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 562 563 /* Note: don't bother checking for wrapping; we stay in this 564 * state until we get a lock */ 565 dvb_frontend_swzigzag_autotune(fe, 0); 566 } 567 } 568 569 static int dvb_frontend_is_exiting(struct dvb_frontend *fe) 570 { 571 struct dvb_frontend_private *fepriv = fe->frontend_priv; 572 573 if (fe->exit != DVB_FE_NO_EXIT) 574 return 1; 575 576 if (fepriv->dvbdev->writers == 1) 577 if (time_after_eq(jiffies, fepriv->release_jiffies + 578 dvb_shutdown_timeout * HZ)) 579 return 1; 580 581 return 0; 582 } 583 584 static int dvb_frontend_should_wakeup(struct dvb_frontend *fe) 585 { 586 struct dvb_frontend_private *fepriv = fe->frontend_priv; 587 588 if (fepriv->wakeup) { 589 fepriv->wakeup = 0; 590 return 1; 591 } 592 return dvb_frontend_is_exiting(fe); 593 } 594 595 static void dvb_frontend_wakeup(struct dvb_frontend *fe) 596 { 597 struct dvb_frontend_private *fepriv = fe->frontend_priv; 598 599 fepriv->wakeup = 1; 600 wake_up_interruptible(&fepriv->wait_queue); 601 } 602 603 /** 604 * dvb_enable_media_tuner() - tries to enable the DVB tuner 605 * 606 * @fe: struct dvb_frontend pointer 607 * 608 * This function ensures that just one media tuner is enabled for a given 609 * frontend. It has two different behaviors: 610 * - For trivial devices with just one tuner: 611 * it just enables the existing tuner->fe link 612 * - For devices with more than one tuner: 613 * It is up to the driver to implement the logic that will enable one tuner 614 * and disable the other ones. However, if more than one tuner is enabled for 615 * the same frontend, it will print an error message and return -EINVAL. 616 * 617 * At return, it will return the error code returned by media_entity_setup_link, 618 * or 0 if everything is OK, if no tuner is linked to the frontend or if the 619 * mdev is NULL. 620 */ 621 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 622 static int dvb_enable_media_tuner(struct dvb_frontend *fe) 623 { 624 struct dvb_frontend_private *fepriv = fe->frontend_priv; 625 struct dvb_adapter *adapter = fe->dvb; 626 struct media_device *mdev = adapter->mdev; 627 struct media_entity *entity, *source; 628 struct media_link *link, *found_link = NULL; 629 int ret, n_links = 0, active_links = 0; 630 631 fepriv->pipe_start_entity = NULL; 632 633 if (!mdev) 634 return 0; 635 636 entity = fepriv->dvbdev->entity; 637 fepriv->pipe_start_entity = entity; 638 639 list_for_each_entry(link, &entity->links, list) { 640 if (link->sink->entity == entity) { 641 found_link = link; 642 n_links++; 643 if (link->flags & MEDIA_LNK_FL_ENABLED) 644 active_links++; 645 } 646 } 647 648 if (!n_links || active_links == 1 || !found_link) 649 return 0; 650 651 /* 652 * If a frontend has more than one tuner linked, it is up to the driver 653 * to select with one will be the active one, as the frontend core can't 654 * guess. If the driver doesn't do that, it is a bug. 655 */ 656 if (n_links > 1 && active_links != 1) { 657 dev_err(fe->dvb->device, 658 "WARNING: there are %d active links among %d tuners. This is a driver's bug!\n", 659 active_links, n_links); 660 return -EINVAL; 661 } 662 663 source = found_link->source->entity; 664 fepriv->pipe_start_entity = source; 665 list_for_each_entry(link, &source->links, list) { 666 struct media_entity *sink; 667 int flags = 0; 668 669 sink = link->sink->entity; 670 if (sink == entity) 671 flags = MEDIA_LNK_FL_ENABLED; 672 673 ret = media_entity_setup_link(link, flags); 674 if (ret) { 675 dev_err(fe->dvb->device, 676 "Couldn't change link %s->%s to %s. Error %d\n", 677 source->name, sink->name, 678 flags ? "enabled" : "disabled", 679 ret); 680 return ret; 681 } else 682 dev_dbg(fe->dvb->device, 683 "link %s->%s was %s\n", 684 source->name, sink->name, 685 flags ? "ENABLED" : "disabled"); 686 } 687 return 0; 688 } 689 #endif 690 691 static int dvb_frontend_thread(void *data) 692 { 693 struct dvb_frontend *fe = data; 694 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 695 struct dvb_frontend_private *fepriv = fe->frontend_priv; 696 enum fe_status s; 697 enum dvbfe_algo algo; 698 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 699 int ret; 700 #endif 701 702 bool re_tune = false; 703 bool semheld = false; 704 705 dev_dbg(fe->dvb->device, "%s:\n", __func__); 706 707 fepriv->check_wrapped = 0; 708 fepriv->quality = 0; 709 fepriv->delay = 3*HZ; 710 fepriv->status = 0; 711 fepriv->wakeup = 0; 712 fepriv->reinitialise = 0; 713 714 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 715 ret = dvb_enable_media_tuner(fe); 716 if (ret) { 717 /* FIXME: return an error if it fails */ 718 dev_info(fe->dvb->device, 719 "proceeding with FE task\n"); 720 } else if (fepriv->pipe_start_entity) { 721 ret = media_entity_pipeline_start(fepriv->pipe_start_entity, 722 &fepriv->pipe); 723 if (ret) 724 return ret; 725 } 726 #endif 727 728 dvb_frontend_init(fe); 729 730 set_freezable(); 731 while (1) { 732 up(&fepriv->sem); /* is locked when we enter the thread... */ 733 restart: 734 wait_event_interruptible_timeout(fepriv->wait_queue, 735 dvb_frontend_should_wakeup(fe) || kthread_should_stop() 736 || freezing(current), 737 fepriv->delay); 738 739 if (kthread_should_stop() || dvb_frontend_is_exiting(fe)) { 740 /* got signal or quitting */ 741 if (!down_interruptible(&fepriv->sem)) 742 semheld = true; 743 fe->exit = DVB_FE_NORMAL_EXIT; 744 break; 745 } 746 747 if (try_to_freeze()) 748 goto restart; 749 750 if (down_interruptible(&fepriv->sem)) 751 break; 752 753 if (fepriv->reinitialise) { 754 dvb_frontend_init(fe); 755 if (fe->ops.set_tone && fepriv->tone != -1) 756 fe->ops.set_tone(fe, fepriv->tone); 757 if (fe->ops.set_voltage && fepriv->voltage != -1) 758 fe->ops.set_voltage(fe, fepriv->voltage); 759 fepriv->reinitialise = 0; 760 } 761 762 /* do an iteration of the tuning loop */ 763 if (fe->ops.get_frontend_algo) { 764 algo = fe->ops.get_frontend_algo(fe); 765 switch (algo) { 766 case DVBFE_ALGO_HW: 767 dev_dbg(fe->dvb->device, "%s: Frontend ALGO = DVBFE_ALGO_HW\n", __func__); 768 769 if (fepriv->state & FESTATE_RETUNE) { 770 dev_dbg(fe->dvb->device, "%s: Retune requested, FESTATE_RETUNE\n", __func__); 771 re_tune = true; 772 fepriv->state = FESTATE_TUNED; 773 } else { 774 re_tune = false; 775 } 776 777 if (fe->ops.tune) 778 fe->ops.tune(fe, re_tune, fepriv->tune_mode_flags, &fepriv->delay, &s); 779 780 if (s != fepriv->status && !(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT)) { 781 dev_dbg(fe->dvb->device, "%s: state changed, adding current state\n", __func__); 782 dvb_frontend_add_event(fe, s); 783 fepriv->status = s; 784 } 785 break; 786 case DVBFE_ALGO_SW: 787 dev_dbg(fe->dvb->device, "%s: Frontend ALGO = DVBFE_ALGO_SW\n", __func__); 788 dvb_frontend_swzigzag(fe); 789 break; 790 case DVBFE_ALGO_CUSTOM: 791 dev_dbg(fe->dvb->device, "%s: Frontend ALGO = DVBFE_ALGO_CUSTOM, state=%d\n", __func__, fepriv->state); 792 if (fepriv->state & FESTATE_RETUNE) { 793 dev_dbg(fe->dvb->device, "%s: Retune requested, FESTAT_RETUNE\n", __func__); 794 fepriv->state = FESTATE_TUNED; 795 } 796 /* Case where we are going to search for a carrier 797 * User asked us to retune again for some reason, possibly 798 * requesting a search with a new set of parameters 799 */ 800 if (fepriv->algo_status & DVBFE_ALGO_SEARCH_AGAIN) { 801 if (fe->ops.search) { 802 fepriv->algo_status = fe->ops.search(fe); 803 /* We did do a search as was requested, the flags are 804 * now unset as well and has the flags wrt to search. 805 */ 806 } else { 807 fepriv->algo_status &= ~DVBFE_ALGO_SEARCH_AGAIN; 808 } 809 } 810 /* Track the carrier if the search was successful */ 811 if (fepriv->algo_status != DVBFE_ALGO_SEARCH_SUCCESS) { 812 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN; 813 fepriv->delay = HZ / 2; 814 } 815 dtv_property_legacy_params_sync(fe, c, &fepriv->parameters_out); 816 fe->ops.read_status(fe, &s); 817 if (s != fepriv->status) { 818 dvb_frontend_add_event(fe, s); /* update event list */ 819 fepriv->status = s; 820 if (!(s & FE_HAS_LOCK)) { 821 fepriv->delay = HZ / 10; 822 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN; 823 } else { 824 fepriv->delay = 60 * HZ; 825 } 826 } 827 break; 828 default: 829 dev_dbg(fe->dvb->device, "%s: UNDEFINED ALGO !\n", __func__); 830 break; 831 } 832 } else { 833 dvb_frontend_swzigzag(fe); 834 } 835 } 836 837 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 838 if (fepriv->pipe_start_entity) 839 media_entity_pipeline_stop(fepriv->pipe_start_entity); 840 fepriv->pipe_start_entity = NULL; 841 #endif 842 843 if (dvb_powerdown_on_sleep) { 844 if (fe->ops.set_voltage) 845 fe->ops.set_voltage(fe, SEC_VOLTAGE_OFF); 846 if (fe->ops.tuner_ops.sleep) { 847 if (fe->ops.i2c_gate_ctrl) 848 fe->ops.i2c_gate_ctrl(fe, 1); 849 fe->ops.tuner_ops.sleep(fe); 850 if (fe->ops.i2c_gate_ctrl) 851 fe->ops.i2c_gate_ctrl(fe, 0); 852 } 853 if (fe->ops.sleep) 854 fe->ops.sleep(fe); 855 } 856 857 fepriv->thread = NULL; 858 if (kthread_should_stop()) 859 fe->exit = DVB_FE_DEVICE_REMOVED; 860 else 861 fe->exit = DVB_FE_NO_EXIT; 862 mb(); 863 864 if (semheld) 865 up(&fepriv->sem); 866 dvb_frontend_wakeup(fe); 867 return 0; 868 } 869 870 static void dvb_frontend_stop(struct dvb_frontend *fe) 871 { 872 struct dvb_frontend_private *fepriv = fe->frontend_priv; 873 874 dev_dbg(fe->dvb->device, "%s:\n", __func__); 875 876 if (fe->exit != DVB_FE_DEVICE_REMOVED) 877 fe->exit = DVB_FE_NORMAL_EXIT; 878 mb(); 879 880 if (!fepriv->thread) 881 return; 882 883 kthread_stop(fepriv->thread); 884 885 sema_init(&fepriv->sem, 1); 886 fepriv->state = FESTATE_IDLE; 887 888 /* paranoia check in case a signal arrived */ 889 if (fepriv->thread) 890 dev_warn(fe->dvb->device, 891 "dvb_frontend_stop: warning: thread %p won't exit\n", 892 fepriv->thread); 893 } 894 895 /* 896 * Sleep for the amount of time given by add_usec parameter 897 * 898 * This needs to be as precise as possible, as it affects the detection of 899 * the dish tone command at the satellite subsystem. The precision is improved 900 * by using a scheduled msleep followed by udelay for the remainder. 901 */ 902 void dvb_frontend_sleep_until(ktime_t *waketime, u32 add_usec) 903 { 904 s32 delta; 905 906 *waketime = ktime_add_us(*waketime, add_usec); 907 delta = ktime_us_delta(ktime_get_boottime(), *waketime); 908 if (delta > 2500) { 909 msleep((delta - 1500) / 1000); 910 delta = ktime_us_delta(ktime_get_boottime(), *waketime); 911 } 912 if (delta > 0) 913 udelay(delta); 914 } 915 EXPORT_SYMBOL(dvb_frontend_sleep_until); 916 917 static int dvb_frontend_start(struct dvb_frontend *fe) 918 { 919 int ret; 920 struct dvb_frontend_private *fepriv = fe->frontend_priv; 921 struct task_struct *fe_thread; 922 923 dev_dbg(fe->dvb->device, "%s:\n", __func__); 924 925 if (fepriv->thread) { 926 if (fe->exit == DVB_FE_NO_EXIT) 927 return 0; 928 else 929 dvb_frontend_stop (fe); 930 } 931 932 if (signal_pending(current)) 933 return -EINTR; 934 if (down_interruptible (&fepriv->sem)) 935 return -EINTR; 936 937 fepriv->state = FESTATE_IDLE; 938 fe->exit = DVB_FE_NO_EXIT; 939 fepriv->thread = NULL; 940 mb(); 941 942 fe_thread = kthread_run(dvb_frontend_thread, fe, 943 "kdvb-ad-%i-fe-%i", fe->dvb->num,fe->id); 944 if (IS_ERR(fe_thread)) { 945 ret = PTR_ERR(fe_thread); 946 dev_warn(fe->dvb->device, 947 "dvb_frontend_start: failed to start kthread (%d)\n", 948 ret); 949 up(&fepriv->sem); 950 return ret; 951 } 952 fepriv->thread = fe_thread; 953 return 0; 954 } 955 956 static void dvb_frontend_get_frequency_limits(struct dvb_frontend *fe, 957 u32 *freq_min, u32 *freq_max) 958 { 959 *freq_min = max(fe->ops.info.frequency_min, fe->ops.tuner_ops.info.frequency_min); 960 961 if (fe->ops.info.frequency_max == 0) 962 *freq_max = fe->ops.tuner_ops.info.frequency_max; 963 else if (fe->ops.tuner_ops.info.frequency_max == 0) 964 *freq_max = fe->ops.info.frequency_max; 965 else 966 *freq_max = min(fe->ops.info.frequency_max, fe->ops.tuner_ops.info.frequency_max); 967 968 if (*freq_min == 0 || *freq_max == 0) 969 dev_warn(fe->dvb->device, "DVB: adapter %i frontend %u frequency limits undefined - fix the driver\n", 970 fe->dvb->num, fe->id); 971 } 972 973 static int dvb_frontend_check_parameters(struct dvb_frontend *fe) 974 { 975 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 976 u32 freq_min; 977 u32 freq_max; 978 979 /* range check: frequency */ 980 dvb_frontend_get_frequency_limits(fe, &freq_min, &freq_max); 981 if ((freq_min && c->frequency < freq_min) || 982 (freq_max && c->frequency > freq_max)) { 983 dev_warn(fe->dvb->device, "DVB: adapter %i frontend %i frequency %u out of range (%u..%u)\n", 984 fe->dvb->num, fe->id, c->frequency, 985 freq_min, freq_max); 986 return -EINVAL; 987 } 988 989 /* range check: symbol rate */ 990 switch (c->delivery_system) { 991 case SYS_DVBS: 992 case SYS_DVBS2: 993 case SYS_TURBO: 994 case SYS_DVBC_ANNEX_A: 995 case SYS_DVBC_ANNEX_C: 996 if ((fe->ops.info.symbol_rate_min && 997 c->symbol_rate < fe->ops.info.symbol_rate_min) || 998 (fe->ops.info.symbol_rate_max && 999 c->symbol_rate > fe->ops.info.symbol_rate_max)) { 1000 dev_warn(fe->dvb->device, "DVB: adapter %i frontend %i symbol rate %u out of range (%u..%u)\n", 1001 fe->dvb->num, fe->id, c->symbol_rate, 1002 fe->ops.info.symbol_rate_min, 1003 fe->ops.info.symbol_rate_max); 1004 return -EINVAL; 1005 } 1006 default: 1007 break; 1008 } 1009 1010 return 0; 1011 } 1012 1013 static int dvb_frontend_clear_cache(struct dvb_frontend *fe) 1014 { 1015 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1016 int i; 1017 u32 delsys; 1018 1019 delsys = c->delivery_system; 1020 memset(c, 0, offsetof(struct dtv_frontend_properties, strength)); 1021 c->delivery_system = delsys; 1022 1023 c->state = DTV_CLEAR; 1024 1025 dev_dbg(fe->dvb->device, "%s: Clearing cache for delivery system %d\n", 1026 __func__, c->delivery_system); 1027 1028 c->transmission_mode = TRANSMISSION_MODE_AUTO; 1029 c->bandwidth_hz = 0; /* AUTO */ 1030 c->guard_interval = GUARD_INTERVAL_AUTO; 1031 c->hierarchy = HIERARCHY_AUTO; 1032 c->symbol_rate = 0; 1033 c->code_rate_HP = FEC_AUTO; 1034 c->code_rate_LP = FEC_AUTO; 1035 c->fec_inner = FEC_AUTO; 1036 c->rolloff = ROLLOFF_AUTO; 1037 c->voltage = SEC_VOLTAGE_OFF; 1038 c->sectone = SEC_TONE_OFF; 1039 c->pilot = PILOT_AUTO; 1040 1041 c->isdbt_partial_reception = 0; 1042 c->isdbt_sb_mode = 0; 1043 c->isdbt_sb_subchannel = 0; 1044 c->isdbt_sb_segment_idx = 0; 1045 c->isdbt_sb_segment_count = 0; 1046 c->isdbt_layer_enabled = 0; 1047 for (i = 0; i < 3; i++) { 1048 c->layer[i].fec = FEC_AUTO; 1049 c->layer[i].modulation = QAM_AUTO; 1050 c->layer[i].interleaving = 0; 1051 c->layer[i].segment_count = 0; 1052 } 1053 1054 c->stream_id = NO_STREAM_ID_FILTER; 1055 1056 switch (c->delivery_system) { 1057 case SYS_DVBS: 1058 case SYS_DVBS2: 1059 case SYS_TURBO: 1060 c->modulation = QPSK; /* implied for DVB-S in legacy API */ 1061 c->rolloff = ROLLOFF_35;/* implied for DVB-S */ 1062 break; 1063 case SYS_ATSC: 1064 c->modulation = VSB_8; 1065 break; 1066 case SYS_ISDBS: 1067 c->symbol_rate = 28860000; 1068 c->rolloff = ROLLOFF_35; 1069 c->bandwidth_hz = c->symbol_rate / 100 * 135; 1070 break; 1071 default: 1072 c->modulation = QAM_AUTO; 1073 break; 1074 } 1075 1076 c->lna = LNA_AUTO; 1077 1078 return 0; 1079 } 1080 1081 #define _DTV_CMD(n, s, b) \ 1082 [n] = { \ 1083 .name = #n, \ 1084 .cmd = n, \ 1085 .set = s,\ 1086 .buffer = b \ 1087 } 1088 1089 static struct dtv_cmds_h dtv_cmds[DTV_MAX_COMMAND + 1] = { 1090 _DTV_CMD(DTV_TUNE, 1, 0), 1091 _DTV_CMD(DTV_CLEAR, 1, 0), 1092 1093 /* Set */ 1094 _DTV_CMD(DTV_FREQUENCY, 1, 0), 1095 _DTV_CMD(DTV_BANDWIDTH_HZ, 1, 0), 1096 _DTV_CMD(DTV_MODULATION, 1, 0), 1097 _DTV_CMD(DTV_INVERSION, 1, 0), 1098 _DTV_CMD(DTV_DISEQC_MASTER, 1, 1), 1099 _DTV_CMD(DTV_SYMBOL_RATE, 1, 0), 1100 _DTV_CMD(DTV_INNER_FEC, 1, 0), 1101 _DTV_CMD(DTV_VOLTAGE, 1, 0), 1102 _DTV_CMD(DTV_TONE, 1, 0), 1103 _DTV_CMD(DTV_PILOT, 1, 0), 1104 _DTV_CMD(DTV_ROLLOFF, 1, 0), 1105 _DTV_CMD(DTV_DELIVERY_SYSTEM, 1, 0), 1106 _DTV_CMD(DTV_HIERARCHY, 1, 0), 1107 _DTV_CMD(DTV_CODE_RATE_HP, 1, 0), 1108 _DTV_CMD(DTV_CODE_RATE_LP, 1, 0), 1109 _DTV_CMD(DTV_GUARD_INTERVAL, 1, 0), 1110 _DTV_CMD(DTV_TRANSMISSION_MODE, 1, 0), 1111 _DTV_CMD(DTV_INTERLEAVING, 1, 0), 1112 1113 _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 1, 0), 1114 _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 1, 0), 1115 _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 1, 0), 1116 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 1, 0), 1117 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 1, 0), 1118 _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 1, 0), 1119 _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 1, 0), 1120 _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 1, 0), 1121 _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 1, 0), 1122 _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 1, 0), 1123 _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 1, 0), 1124 _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 1, 0), 1125 _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 1, 0), 1126 _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 1, 0), 1127 _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 1, 0), 1128 _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 1, 0), 1129 _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 1, 0), 1130 _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 1, 0), 1131 1132 _DTV_CMD(DTV_STREAM_ID, 1, 0), 1133 _DTV_CMD(DTV_DVBT2_PLP_ID_LEGACY, 1, 0), 1134 _DTV_CMD(DTV_LNA, 1, 0), 1135 1136 /* Get */ 1137 _DTV_CMD(DTV_DISEQC_SLAVE_REPLY, 0, 1), 1138 _DTV_CMD(DTV_API_VERSION, 0, 0), 1139 1140 _DTV_CMD(DTV_ENUM_DELSYS, 0, 0), 1141 1142 _DTV_CMD(DTV_ATSCMH_PARADE_ID, 1, 0), 1143 _DTV_CMD(DTV_ATSCMH_RS_FRAME_ENSEMBLE, 1, 0), 1144 1145 _DTV_CMD(DTV_ATSCMH_FIC_VER, 0, 0), 1146 _DTV_CMD(DTV_ATSCMH_NOG, 0, 0), 1147 _DTV_CMD(DTV_ATSCMH_TNOG, 0, 0), 1148 _DTV_CMD(DTV_ATSCMH_SGN, 0, 0), 1149 _DTV_CMD(DTV_ATSCMH_PRC, 0, 0), 1150 _DTV_CMD(DTV_ATSCMH_RS_FRAME_MODE, 0, 0), 1151 _DTV_CMD(DTV_ATSCMH_RS_CODE_MODE_PRI, 0, 0), 1152 _DTV_CMD(DTV_ATSCMH_RS_CODE_MODE_SEC, 0, 0), 1153 _DTV_CMD(DTV_ATSCMH_SCCC_BLOCK_MODE, 0, 0), 1154 _DTV_CMD(DTV_ATSCMH_SCCC_CODE_MODE_A, 0, 0), 1155 _DTV_CMD(DTV_ATSCMH_SCCC_CODE_MODE_B, 0, 0), 1156 _DTV_CMD(DTV_ATSCMH_SCCC_CODE_MODE_C, 0, 0), 1157 _DTV_CMD(DTV_ATSCMH_SCCC_CODE_MODE_D, 0, 0), 1158 1159 /* Statistics API */ 1160 _DTV_CMD(DTV_STAT_SIGNAL_STRENGTH, 0, 0), 1161 _DTV_CMD(DTV_STAT_CNR, 0, 0), 1162 _DTV_CMD(DTV_STAT_PRE_ERROR_BIT_COUNT, 0, 0), 1163 _DTV_CMD(DTV_STAT_PRE_TOTAL_BIT_COUNT, 0, 0), 1164 _DTV_CMD(DTV_STAT_POST_ERROR_BIT_COUNT, 0, 0), 1165 _DTV_CMD(DTV_STAT_POST_TOTAL_BIT_COUNT, 0, 0), 1166 _DTV_CMD(DTV_STAT_ERROR_BLOCK_COUNT, 0, 0), 1167 _DTV_CMD(DTV_STAT_TOTAL_BLOCK_COUNT, 0, 0), 1168 }; 1169 1170 static void dtv_property_dump(struct dvb_frontend *fe, 1171 bool is_set, 1172 struct dtv_property *tvp) 1173 { 1174 int i; 1175 1176 if (tvp->cmd <= 0 || tvp->cmd > DTV_MAX_COMMAND) { 1177 dev_warn(fe->dvb->device, "%s: %s tvp.cmd = 0x%08x undefined\n", 1178 __func__, 1179 is_set ? "SET" : "GET", 1180 tvp->cmd); 1181 return; 1182 } 1183 1184 dev_dbg(fe->dvb->device, "%s: %s tvp.cmd = 0x%08x (%s)\n", __func__, 1185 is_set ? "SET" : "GET", 1186 tvp->cmd, 1187 dtv_cmds[tvp->cmd].name); 1188 1189 if (dtv_cmds[tvp->cmd].buffer) { 1190 dev_dbg(fe->dvb->device, "%s: tvp.u.buffer.len = 0x%02x\n", 1191 __func__, tvp->u.buffer.len); 1192 1193 for(i = 0; i < tvp->u.buffer.len; i++) 1194 dev_dbg(fe->dvb->device, 1195 "%s: tvp.u.buffer.data[0x%02x] = 0x%02x\n", 1196 __func__, i, tvp->u.buffer.data[i]); 1197 } else { 1198 dev_dbg(fe->dvb->device, "%s: tvp.u.data = 0x%08x\n", __func__, 1199 tvp->u.data); 1200 } 1201 } 1202 1203 /* Synchronise the legacy tuning parameters into the cache, so that demodulator 1204 * drivers can use a single set_frontend tuning function, regardless of whether 1205 * it's being used for the legacy or new API, reducing code and complexity. 1206 */ 1207 static int dtv_property_cache_sync(struct dvb_frontend *fe, 1208 struct dtv_frontend_properties *c, 1209 const struct dvb_frontend_parameters *p) 1210 { 1211 c->frequency = p->frequency; 1212 c->inversion = p->inversion; 1213 1214 switch (dvbv3_type(c->delivery_system)) { 1215 case DVBV3_QPSK: 1216 dev_dbg(fe->dvb->device, "%s: Preparing QPSK req\n", __func__); 1217 c->symbol_rate = p->u.qpsk.symbol_rate; 1218 c->fec_inner = p->u.qpsk.fec_inner; 1219 break; 1220 case DVBV3_QAM: 1221 dev_dbg(fe->dvb->device, "%s: Preparing QAM req\n", __func__); 1222 c->symbol_rate = p->u.qam.symbol_rate; 1223 c->fec_inner = p->u.qam.fec_inner; 1224 c->modulation = p->u.qam.modulation; 1225 break; 1226 case DVBV3_OFDM: 1227 dev_dbg(fe->dvb->device, "%s: Preparing OFDM req\n", __func__); 1228 1229 switch (p->u.ofdm.bandwidth) { 1230 case BANDWIDTH_10_MHZ: 1231 c->bandwidth_hz = 10000000; 1232 break; 1233 case BANDWIDTH_8_MHZ: 1234 c->bandwidth_hz = 8000000; 1235 break; 1236 case BANDWIDTH_7_MHZ: 1237 c->bandwidth_hz = 7000000; 1238 break; 1239 case BANDWIDTH_6_MHZ: 1240 c->bandwidth_hz = 6000000; 1241 break; 1242 case BANDWIDTH_5_MHZ: 1243 c->bandwidth_hz = 5000000; 1244 break; 1245 case BANDWIDTH_1_712_MHZ: 1246 c->bandwidth_hz = 1712000; 1247 break; 1248 case BANDWIDTH_AUTO: 1249 c->bandwidth_hz = 0; 1250 } 1251 1252 c->code_rate_HP = p->u.ofdm.code_rate_HP; 1253 c->code_rate_LP = p->u.ofdm.code_rate_LP; 1254 c->modulation = p->u.ofdm.constellation; 1255 c->transmission_mode = p->u.ofdm.transmission_mode; 1256 c->guard_interval = p->u.ofdm.guard_interval; 1257 c->hierarchy = p->u.ofdm.hierarchy_information; 1258 break; 1259 case DVBV3_ATSC: 1260 dev_dbg(fe->dvb->device, "%s: Preparing ATSC req\n", __func__); 1261 c->modulation = p->u.vsb.modulation; 1262 if (c->delivery_system == SYS_ATSCMH) 1263 break; 1264 if ((c->modulation == VSB_8) || (c->modulation == VSB_16)) 1265 c->delivery_system = SYS_ATSC; 1266 else 1267 c->delivery_system = SYS_DVBC_ANNEX_B; 1268 break; 1269 case DVBV3_UNKNOWN: 1270 dev_err(fe->dvb->device, 1271 "%s: doesn't know how to handle a DVBv3 call to delivery system %i\n", 1272 __func__, c->delivery_system); 1273 return -EINVAL; 1274 } 1275 1276 return 0; 1277 } 1278 1279 /* Ensure the cached values are set correctly in the frontend 1280 * legacy tuning structures, for the advanced tuning API. 1281 */ 1282 static int 1283 dtv_property_legacy_params_sync(struct dvb_frontend *fe, 1284 const struct dtv_frontend_properties *c, 1285 struct dvb_frontend_parameters *p) 1286 { 1287 p->frequency = c->frequency; 1288 p->inversion = c->inversion; 1289 1290 switch (dvbv3_type(c->delivery_system)) { 1291 case DVBV3_UNKNOWN: 1292 dev_err(fe->dvb->device, 1293 "%s: doesn't know how to handle a DVBv3 call to delivery system %i\n", 1294 __func__, c->delivery_system); 1295 return -EINVAL; 1296 case DVBV3_QPSK: 1297 dev_dbg(fe->dvb->device, "%s: Preparing QPSK req\n", __func__); 1298 p->u.qpsk.symbol_rate = c->symbol_rate; 1299 p->u.qpsk.fec_inner = c->fec_inner; 1300 break; 1301 case DVBV3_QAM: 1302 dev_dbg(fe->dvb->device, "%s: Preparing QAM req\n", __func__); 1303 p->u.qam.symbol_rate = c->symbol_rate; 1304 p->u.qam.fec_inner = c->fec_inner; 1305 p->u.qam.modulation = c->modulation; 1306 break; 1307 case DVBV3_OFDM: 1308 dev_dbg(fe->dvb->device, "%s: Preparing OFDM req\n", __func__); 1309 switch (c->bandwidth_hz) { 1310 case 10000000: 1311 p->u.ofdm.bandwidth = BANDWIDTH_10_MHZ; 1312 break; 1313 case 8000000: 1314 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ; 1315 break; 1316 case 7000000: 1317 p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ; 1318 break; 1319 case 6000000: 1320 p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ; 1321 break; 1322 case 5000000: 1323 p->u.ofdm.bandwidth = BANDWIDTH_5_MHZ; 1324 break; 1325 case 1712000: 1326 p->u.ofdm.bandwidth = BANDWIDTH_1_712_MHZ; 1327 break; 1328 case 0: 1329 default: 1330 p->u.ofdm.bandwidth = BANDWIDTH_AUTO; 1331 } 1332 p->u.ofdm.code_rate_HP = c->code_rate_HP; 1333 p->u.ofdm.code_rate_LP = c->code_rate_LP; 1334 p->u.ofdm.constellation = c->modulation; 1335 p->u.ofdm.transmission_mode = c->transmission_mode; 1336 p->u.ofdm.guard_interval = c->guard_interval; 1337 p->u.ofdm.hierarchy_information = c->hierarchy; 1338 break; 1339 case DVBV3_ATSC: 1340 dev_dbg(fe->dvb->device, "%s: Preparing VSB req\n", __func__); 1341 p->u.vsb.modulation = c->modulation; 1342 break; 1343 } 1344 return 0; 1345 } 1346 1347 /** 1348 * dtv_get_frontend - calls a callback for retrieving DTV parameters 1349 * @fe: struct dvb_frontend pointer 1350 * @c: struct dtv_frontend_properties pointer (DVBv5 cache) 1351 * @p_out struct dvb_frontend_parameters pointer (DVBv3 FE struct) 1352 * 1353 * This routine calls either the DVBv3 or DVBv5 get_frontend call. 1354 * If c is not null, it will update the DVBv5 cache struct pointed by it. 1355 * If p_out is not null, it will update the DVBv3 params pointed by it. 1356 */ 1357 static int dtv_get_frontend(struct dvb_frontend *fe, 1358 struct dtv_frontend_properties *c, 1359 struct dvb_frontend_parameters *p_out) 1360 { 1361 int r; 1362 1363 if (fe->ops.get_frontend) { 1364 r = fe->ops.get_frontend(fe, c); 1365 if (unlikely(r < 0)) 1366 return r; 1367 if (p_out) 1368 dtv_property_legacy_params_sync(fe, c, p_out); 1369 return 0; 1370 } 1371 1372 /* As everything is in cache, get_frontend fops are always supported */ 1373 return 0; 1374 } 1375 1376 static int dvb_frontend_ioctl_legacy(struct file *file, 1377 unsigned int cmd, void *parg); 1378 static int dvb_frontend_ioctl_properties(struct file *file, 1379 unsigned int cmd, void *parg); 1380 1381 static int dtv_property_process_get(struct dvb_frontend *fe, 1382 const struct dtv_frontend_properties *c, 1383 struct dtv_property *tvp, 1384 struct file *file) 1385 { 1386 int r, ncaps; 1387 1388 switch(tvp->cmd) { 1389 case DTV_ENUM_DELSYS: 1390 ncaps = 0; 1391 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { 1392 tvp->u.buffer.data[ncaps] = fe->ops.delsys[ncaps]; 1393 ncaps++; 1394 } 1395 tvp->u.buffer.len = ncaps; 1396 break; 1397 case DTV_FREQUENCY: 1398 tvp->u.data = c->frequency; 1399 break; 1400 case DTV_MODULATION: 1401 tvp->u.data = c->modulation; 1402 break; 1403 case DTV_BANDWIDTH_HZ: 1404 tvp->u.data = c->bandwidth_hz; 1405 break; 1406 case DTV_INVERSION: 1407 tvp->u.data = c->inversion; 1408 break; 1409 case DTV_SYMBOL_RATE: 1410 tvp->u.data = c->symbol_rate; 1411 break; 1412 case DTV_INNER_FEC: 1413 tvp->u.data = c->fec_inner; 1414 break; 1415 case DTV_PILOT: 1416 tvp->u.data = c->pilot; 1417 break; 1418 case DTV_ROLLOFF: 1419 tvp->u.data = c->rolloff; 1420 break; 1421 case DTV_DELIVERY_SYSTEM: 1422 tvp->u.data = c->delivery_system; 1423 break; 1424 case DTV_VOLTAGE: 1425 tvp->u.data = c->voltage; 1426 break; 1427 case DTV_TONE: 1428 tvp->u.data = c->sectone; 1429 break; 1430 case DTV_API_VERSION: 1431 tvp->u.data = (DVB_API_VERSION << 8) | DVB_API_VERSION_MINOR; 1432 break; 1433 case DTV_CODE_RATE_HP: 1434 tvp->u.data = c->code_rate_HP; 1435 break; 1436 case DTV_CODE_RATE_LP: 1437 tvp->u.data = c->code_rate_LP; 1438 break; 1439 case DTV_GUARD_INTERVAL: 1440 tvp->u.data = c->guard_interval; 1441 break; 1442 case DTV_TRANSMISSION_MODE: 1443 tvp->u.data = c->transmission_mode; 1444 break; 1445 case DTV_HIERARCHY: 1446 tvp->u.data = c->hierarchy; 1447 break; 1448 case DTV_INTERLEAVING: 1449 tvp->u.data = c->interleaving; 1450 break; 1451 1452 /* ISDB-T Support here */ 1453 case DTV_ISDBT_PARTIAL_RECEPTION: 1454 tvp->u.data = c->isdbt_partial_reception; 1455 break; 1456 case DTV_ISDBT_SOUND_BROADCASTING: 1457 tvp->u.data = c->isdbt_sb_mode; 1458 break; 1459 case DTV_ISDBT_SB_SUBCHANNEL_ID: 1460 tvp->u.data = c->isdbt_sb_subchannel; 1461 break; 1462 case DTV_ISDBT_SB_SEGMENT_IDX: 1463 tvp->u.data = c->isdbt_sb_segment_idx; 1464 break; 1465 case DTV_ISDBT_SB_SEGMENT_COUNT: 1466 tvp->u.data = c->isdbt_sb_segment_count; 1467 break; 1468 case DTV_ISDBT_LAYER_ENABLED: 1469 tvp->u.data = c->isdbt_layer_enabled; 1470 break; 1471 case DTV_ISDBT_LAYERA_FEC: 1472 tvp->u.data = c->layer[0].fec; 1473 break; 1474 case DTV_ISDBT_LAYERA_MODULATION: 1475 tvp->u.data = c->layer[0].modulation; 1476 break; 1477 case DTV_ISDBT_LAYERA_SEGMENT_COUNT: 1478 tvp->u.data = c->layer[0].segment_count; 1479 break; 1480 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING: 1481 tvp->u.data = c->layer[0].interleaving; 1482 break; 1483 case DTV_ISDBT_LAYERB_FEC: 1484 tvp->u.data = c->layer[1].fec; 1485 break; 1486 case DTV_ISDBT_LAYERB_MODULATION: 1487 tvp->u.data = c->layer[1].modulation; 1488 break; 1489 case DTV_ISDBT_LAYERB_SEGMENT_COUNT: 1490 tvp->u.data = c->layer[1].segment_count; 1491 break; 1492 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING: 1493 tvp->u.data = c->layer[1].interleaving; 1494 break; 1495 case DTV_ISDBT_LAYERC_FEC: 1496 tvp->u.data = c->layer[2].fec; 1497 break; 1498 case DTV_ISDBT_LAYERC_MODULATION: 1499 tvp->u.data = c->layer[2].modulation; 1500 break; 1501 case DTV_ISDBT_LAYERC_SEGMENT_COUNT: 1502 tvp->u.data = c->layer[2].segment_count; 1503 break; 1504 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING: 1505 tvp->u.data = c->layer[2].interleaving; 1506 break; 1507 1508 /* Multistream support */ 1509 case DTV_STREAM_ID: 1510 case DTV_DVBT2_PLP_ID_LEGACY: 1511 tvp->u.data = c->stream_id; 1512 break; 1513 1514 /* ATSC-MH */ 1515 case DTV_ATSCMH_FIC_VER: 1516 tvp->u.data = fe->dtv_property_cache.atscmh_fic_ver; 1517 break; 1518 case DTV_ATSCMH_PARADE_ID: 1519 tvp->u.data = fe->dtv_property_cache.atscmh_parade_id; 1520 break; 1521 case DTV_ATSCMH_NOG: 1522 tvp->u.data = fe->dtv_property_cache.atscmh_nog; 1523 break; 1524 case DTV_ATSCMH_TNOG: 1525 tvp->u.data = fe->dtv_property_cache.atscmh_tnog; 1526 break; 1527 case DTV_ATSCMH_SGN: 1528 tvp->u.data = fe->dtv_property_cache.atscmh_sgn; 1529 break; 1530 case DTV_ATSCMH_PRC: 1531 tvp->u.data = fe->dtv_property_cache.atscmh_prc; 1532 break; 1533 case DTV_ATSCMH_RS_FRAME_MODE: 1534 tvp->u.data = fe->dtv_property_cache.atscmh_rs_frame_mode; 1535 break; 1536 case DTV_ATSCMH_RS_FRAME_ENSEMBLE: 1537 tvp->u.data = fe->dtv_property_cache.atscmh_rs_frame_ensemble; 1538 break; 1539 case DTV_ATSCMH_RS_CODE_MODE_PRI: 1540 tvp->u.data = fe->dtv_property_cache.atscmh_rs_code_mode_pri; 1541 break; 1542 case DTV_ATSCMH_RS_CODE_MODE_SEC: 1543 tvp->u.data = fe->dtv_property_cache.atscmh_rs_code_mode_sec; 1544 break; 1545 case DTV_ATSCMH_SCCC_BLOCK_MODE: 1546 tvp->u.data = fe->dtv_property_cache.atscmh_sccc_block_mode; 1547 break; 1548 case DTV_ATSCMH_SCCC_CODE_MODE_A: 1549 tvp->u.data = fe->dtv_property_cache.atscmh_sccc_code_mode_a; 1550 break; 1551 case DTV_ATSCMH_SCCC_CODE_MODE_B: 1552 tvp->u.data = fe->dtv_property_cache.atscmh_sccc_code_mode_b; 1553 break; 1554 case DTV_ATSCMH_SCCC_CODE_MODE_C: 1555 tvp->u.data = fe->dtv_property_cache.atscmh_sccc_code_mode_c; 1556 break; 1557 case DTV_ATSCMH_SCCC_CODE_MODE_D: 1558 tvp->u.data = fe->dtv_property_cache.atscmh_sccc_code_mode_d; 1559 break; 1560 1561 case DTV_LNA: 1562 tvp->u.data = c->lna; 1563 break; 1564 1565 /* Fill quality measures */ 1566 case DTV_STAT_SIGNAL_STRENGTH: 1567 tvp->u.st = c->strength; 1568 break; 1569 case DTV_STAT_CNR: 1570 tvp->u.st = c->cnr; 1571 break; 1572 case DTV_STAT_PRE_ERROR_BIT_COUNT: 1573 tvp->u.st = c->pre_bit_error; 1574 break; 1575 case DTV_STAT_PRE_TOTAL_BIT_COUNT: 1576 tvp->u.st = c->pre_bit_count; 1577 break; 1578 case DTV_STAT_POST_ERROR_BIT_COUNT: 1579 tvp->u.st = c->post_bit_error; 1580 break; 1581 case DTV_STAT_POST_TOTAL_BIT_COUNT: 1582 tvp->u.st = c->post_bit_count; 1583 break; 1584 case DTV_STAT_ERROR_BLOCK_COUNT: 1585 tvp->u.st = c->block_error; 1586 break; 1587 case DTV_STAT_TOTAL_BLOCK_COUNT: 1588 tvp->u.st = c->block_count; 1589 break; 1590 default: 1591 dev_dbg(fe->dvb->device, 1592 "%s: FE property %d doesn't exist\n", 1593 __func__, tvp->cmd); 1594 return -EINVAL; 1595 } 1596 1597 /* Allow the frontend to override outgoing properties */ 1598 if (fe->ops.get_property) { 1599 r = fe->ops.get_property(fe, tvp); 1600 if (r < 0) 1601 return r; 1602 } 1603 1604 dtv_property_dump(fe, false, tvp); 1605 1606 return 0; 1607 } 1608 1609 static int dtv_set_frontend(struct dvb_frontend *fe); 1610 1611 static bool is_dvbv3_delsys(u32 delsys) 1612 { 1613 bool status; 1614 1615 status = (delsys == SYS_DVBT) || (delsys == SYS_DVBC_ANNEX_A) || 1616 (delsys == SYS_DVBS) || (delsys == SYS_ATSC); 1617 1618 return status; 1619 } 1620 1621 /** 1622 * emulate_delivery_system - emulate a DVBv5 delivery system with a DVBv3 type 1623 * @fe: struct frontend; 1624 * @delsys: DVBv5 type that will be used for emulation 1625 * 1626 * Provides emulation for delivery systems that are compatible with the old 1627 * DVBv3 call. Among its usages, it provices support for ISDB-T, and allows 1628 * using a DVB-S2 only frontend just like it were a DVB-S, if the frontent 1629 * parameters are compatible with DVB-S spec. 1630 */ 1631 static int emulate_delivery_system(struct dvb_frontend *fe, u32 delsys) 1632 { 1633 int i; 1634 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1635 1636 c->delivery_system = delsys; 1637 1638 /* 1639 * If the call is for ISDB-T, put it into full-seg, auto mode, TV 1640 */ 1641 if (c->delivery_system == SYS_ISDBT) { 1642 dev_dbg(fe->dvb->device, 1643 "%s: Using defaults for SYS_ISDBT\n", 1644 __func__); 1645 1646 if (!c->bandwidth_hz) 1647 c->bandwidth_hz = 6000000; 1648 1649 c->isdbt_partial_reception = 0; 1650 c->isdbt_sb_mode = 0; 1651 c->isdbt_sb_subchannel = 0; 1652 c->isdbt_sb_segment_idx = 0; 1653 c->isdbt_sb_segment_count = 0; 1654 c->isdbt_layer_enabled = 7; 1655 for (i = 0; i < 3; i++) { 1656 c->layer[i].fec = FEC_AUTO; 1657 c->layer[i].modulation = QAM_AUTO; 1658 c->layer[i].interleaving = 0; 1659 c->layer[i].segment_count = 0; 1660 } 1661 } 1662 dev_dbg(fe->dvb->device, "%s: change delivery system on cache to %d\n", 1663 __func__, c->delivery_system); 1664 1665 return 0; 1666 } 1667 1668 /** 1669 * dvbv5_set_delivery_system - Sets the delivery system for a DVBv5 API call 1670 * @fe: frontend struct 1671 * @desired_system: delivery system requested by the user 1672 * 1673 * A DVBv5 call know what's the desired system it wants. So, set it. 1674 * 1675 * There are, however, a few known issues with early DVBv5 applications that 1676 * are also handled by this logic: 1677 * 1678 * 1) Some early apps use SYS_UNDEFINED as the desired delivery system. 1679 * This is an API violation, but, as we don't want to break userspace, 1680 * convert it to the first supported delivery system. 1681 * 2) Some apps might be using a DVBv5 call in a wrong way, passing, for 1682 * example, SYS_DVBT instead of SYS_ISDBT. This is because early usage of 1683 * ISDB-T provided backward compat with DVB-T. 1684 */ 1685 static int dvbv5_set_delivery_system(struct dvb_frontend *fe, 1686 u32 desired_system) 1687 { 1688 int ncaps; 1689 u32 delsys = SYS_UNDEFINED; 1690 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1691 enum dvbv3_emulation_type type; 1692 1693 /* 1694 * It was reported that some old DVBv5 applications were 1695 * filling delivery_system with SYS_UNDEFINED. If this happens, 1696 * assume that the application wants to use the first supported 1697 * delivery system. 1698 */ 1699 if (desired_system == SYS_UNDEFINED) 1700 desired_system = fe->ops.delsys[0]; 1701 1702 /* 1703 * This is a DVBv5 call. So, it likely knows the supported 1704 * delivery systems. So, check if the desired delivery system is 1705 * supported 1706 */ 1707 ncaps = 0; 1708 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { 1709 if (fe->ops.delsys[ncaps] == desired_system) { 1710 c->delivery_system = desired_system; 1711 dev_dbg(fe->dvb->device, 1712 "%s: Changing delivery system to %d\n", 1713 __func__, desired_system); 1714 return 0; 1715 } 1716 ncaps++; 1717 } 1718 1719 /* 1720 * The requested delivery system isn't supported. Maybe userspace 1721 * is requesting a DVBv3 compatible delivery system. 1722 * 1723 * The emulation only works if the desired system is one of the 1724 * delivery systems supported by DVBv3 API 1725 */ 1726 if (!is_dvbv3_delsys(desired_system)) { 1727 dev_dbg(fe->dvb->device, 1728 "%s: Delivery system %d not supported.\n", 1729 __func__, desired_system); 1730 return -EINVAL; 1731 } 1732 1733 type = dvbv3_type(desired_system); 1734 1735 /* 1736 * Get the last non-DVBv3 delivery system that has the same type 1737 * of the desired system 1738 */ 1739 ncaps = 0; 1740 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { 1741 if (dvbv3_type(fe->ops.delsys[ncaps]) == type) 1742 delsys = fe->ops.delsys[ncaps]; 1743 ncaps++; 1744 } 1745 1746 /* There's nothing compatible with the desired delivery system */ 1747 if (delsys == SYS_UNDEFINED) { 1748 dev_dbg(fe->dvb->device, 1749 "%s: Delivery system %d not supported on emulation mode.\n", 1750 __func__, desired_system); 1751 return -EINVAL; 1752 } 1753 1754 dev_dbg(fe->dvb->device, 1755 "%s: Using delivery system %d emulated as if it were %d\n", 1756 __func__, delsys, desired_system); 1757 1758 return emulate_delivery_system(fe, desired_system); 1759 } 1760 1761 /** 1762 * dvbv3_set_delivery_system - Sets the delivery system for a DVBv3 API call 1763 * @fe: frontend struct 1764 * 1765 * A DVBv3 call doesn't know what's the desired system it wants. It also 1766 * doesn't allow to switch between different types. Due to that, userspace 1767 * should use DVBv5 instead. 1768 * However, in order to avoid breaking userspace API, limited backward 1769 * compatibility support is provided. 1770 * 1771 * There are some delivery systems that are incompatible with DVBv3 calls. 1772 * 1773 * This routine should work fine for frontends that support just one delivery 1774 * system. 1775 * 1776 * For frontends that support multiple frontends: 1777 * 1) It defaults to use the first supported delivery system. There's an 1778 * userspace application that allows changing it at runtime; 1779 * 1780 * 2) If the current delivery system is not compatible with DVBv3, it gets 1781 * the first one that it is compatible. 1782 * 1783 * NOTE: in order for this to work with applications like Kaffeine that 1784 * uses a DVBv5 call for DVB-S2 and a DVBv3 call to go back to 1785 * DVB-S, drivers that support both DVB-S and DVB-S2 should have the 1786 * SYS_DVBS entry before the SYS_DVBS2, otherwise it won't switch back 1787 * to DVB-S. 1788 */ 1789 static int dvbv3_set_delivery_system(struct dvb_frontend *fe) 1790 { 1791 int ncaps; 1792 u32 delsys = SYS_UNDEFINED; 1793 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1794 1795 /* If not set yet, defaults to the first supported delivery system */ 1796 if (c->delivery_system == SYS_UNDEFINED) 1797 c->delivery_system = fe->ops.delsys[0]; 1798 1799 /* 1800 * Trivial case: just use the current one, if it already a DVBv3 1801 * delivery system 1802 */ 1803 if (is_dvbv3_delsys(c->delivery_system)) { 1804 dev_dbg(fe->dvb->device, 1805 "%s: Using delivery system to %d\n", 1806 __func__, c->delivery_system); 1807 return 0; 1808 } 1809 1810 /* 1811 * Seek for the first delivery system that it is compatible with a 1812 * DVBv3 standard 1813 */ 1814 ncaps = 0; 1815 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { 1816 if (dvbv3_type(fe->ops.delsys[ncaps]) != DVBV3_UNKNOWN) { 1817 delsys = fe->ops.delsys[ncaps]; 1818 break; 1819 } 1820 ncaps++; 1821 } 1822 if (delsys == SYS_UNDEFINED) { 1823 dev_dbg(fe->dvb->device, 1824 "%s: Couldn't find a delivery system that works with FE_SET_FRONTEND\n", 1825 __func__); 1826 return -EINVAL; 1827 } 1828 return emulate_delivery_system(fe, delsys); 1829 } 1830 1831 static int dtv_property_process_set(struct dvb_frontend *fe, 1832 struct dtv_property *tvp, 1833 struct file *file) 1834 { 1835 int r = 0; 1836 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1837 1838 /* Allow the frontend to validate incoming properties */ 1839 if (fe->ops.set_property) { 1840 r = fe->ops.set_property(fe, tvp); 1841 if (r < 0) 1842 return r; 1843 } 1844 1845 dtv_property_dump(fe, true, tvp); 1846 1847 switch(tvp->cmd) { 1848 case DTV_CLEAR: 1849 /* 1850 * Reset a cache of data specific to the frontend here. This does 1851 * not effect hardware. 1852 */ 1853 dvb_frontend_clear_cache(fe); 1854 break; 1855 case DTV_TUNE: 1856 /* interpret the cache of data, build either a traditional frontend 1857 * tunerequest so we can pass validation in the FE_SET_FRONTEND 1858 * ioctl. 1859 */ 1860 c->state = tvp->cmd; 1861 dev_dbg(fe->dvb->device, "%s: Finalised property cache\n", 1862 __func__); 1863 1864 r = dtv_set_frontend(fe); 1865 break; 1866 case DTV_FREQUENCY: 1867 c->frequency = tvp->u.data; 1868 break; 1869 case DTV_MODULATION: 1870 c->modulation = tvp->u.data; 1871 break; 1872 case DTV_BANDWIDTH_HZ: 1873 c->bandwidth_hz = tvp->u.data; 1874 break; 1875 case DTV_INVERSION: 1876 c->inversion = tvp->u.data; 1877 break; 1878 case DTV_SYMBOL_RATE: 1879 c->symbol_rate = tvp->u.data; 1880 break; 1881 case DTV_INNER_FEC: 1882 c->fec_inner = tvp->u.data; 1883 break; 1884 case DTV_PILOT: 1885 c->pilot = tvp->u.data; 1886 break; 1887 case DTV_ROLLOFF: 1888 c->rolloff = tvp->u.data; 1889 break; 1890 case DTV_DELIVERY_SYSTEM: 1891 r = dvbv5_set_delivery_system(fe, tvp->u.data); 1892 break; 1893 case DTV_VOLTAGE: 1894 c->voltage = tvp->u.data; 1895 r = dvb_frontend_ioctl_legacy(file, FE_SET_VOLTAGE, 1896 (void *)c->voltage); 1897 break; 1898 case DTV_TONE: 1899 c->sectone = tvp->u.data; 1900 r = dvb_frontend_ioctl_legacy(file, FE_SET_TONE, 1901 (void *)c->sectone); 1902 break; 1903 case DTV_CODE_RATE_HP: 1904 c->code_rate_HP = tvp->u.data; 1905 break; 1906 case DTV_CODE_RATE_LP: 1907 c->code_rate_LP = tvp->u.data; 1908 break; 1909 case DTV_GUARD_INTERVAL: 1910 c->guard_interval = tvp->u.data; 1911 break; 1912 case DTV_TRANSMISSION_MODE: 1913 c->transmission_mode = tvp->u.data; 1914 break; 1915 case DTV_HIERARCHY: 1916 c->hierarchy = tvp->u.data; 1917 break; 1918 case DTV_INTERLEAVING: 1919 c->interleaving = tvp->u.data; 1920 break; 1921 1922 /* ISDB-T Support here */ 1923 case DTV_ISDBT_PARTIAL_RECEPTION: 1924 c->isdbt_partial_reception = tvp->u.data; 1925 break; 1926 case DTV_ISDBT_SOUND_BROADCASTING: 1927 c->isdbt_sb_mode = tvp->u.data; 1928 break; 1929 case DTV_ISDBT_SB_SUBCHANNEL_ID: 1930 c->isdbt_sb_subchannel = tvp->u.data; 1931 break; 1932 case DTV_ISDBT_SB_SEGMENT_IDX: 1933 c->isdbt_sb_segment_idx = tvp->u.data; 1934 break; 1935 case DTV_ISDBT_SB_SEGMENT_COUNT: 1936 c->isdbt_sb_segment_count = tvp->u.data; 1937 break; 1938 case DTV_ISDBT_LAYER_ENABLED: 1939 c->isdbt_layer_enabled = tvp->u.data; 1940 break; 1941 case DTV_ISDBT_LAYERA_FEC: 1942 c->layer[0].fec = tvp->u.data; 1943 break; 1944 case DTV_ISDBT_LAYERA_MODULATION: 1945 c->layer[0].modulation = tvp->u.data; 1946 break; 1947 case DTV_ISDBT_LAYERA_SEGMENT_COUNT: 1948 c->layer[0].segment_count = tvp->u.data; 1949 break; 1950 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING: 1951 c->layer[0].interleaving = tvp->u.data; 1952 break; 1953 case DTV_ISDBT_LAYERB_FEC: 1954 c->layer[1].fec = tvp->u.data; 1955 break; 1956 case DTV_ISDBT_LAYERB_MODULATION: 1957 c->layer[1].modulation = tvp->u.data; 1958 break; 1959 case DTV_ISDBT_LAYERB_SEGMENT_COUNT: 1960 c->layer[1].segment_count = tvp->u.data; 1961 break; 1962 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING: 1963 c->layer[1].interleaving = tvp->u.data; 1964 break; 1965 case DTV_ISDBT_LAYERC_FEC: 1966 c->layer[2].fec = tvp->u.data; 1967 break; 1968 case DTV_ISDBT_LAYERC_MODULATION: 1969 c->layer[2].modulation = tvp->u.data; 1970 break; 1971 case DTV_ISDBT_LAYERC_SEGMENT_COUNT: 1972 c->layer[2].segment_count = tvp->u.data; 1973 break; 1974 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING: 1975 c->layer[2].interleaving = tvp->u.data; 1976 break; 1977 1978 /* Multistream support */ 1979 case DTV_STREAM_ID: 1980 case DTV_DVBT2_PLP_ID_LEGACY: 1981 c->stream_id = tvp->u.data; 1982 break; 1983 1984 /* ATSC-MH */ 1985 case DTV_ATSCMH_PARADE_ID: 1986 fe->dtv_property_cache.atscmh_parade_id = tvp->u.data; 1987 break; 1988 case DTV_ATSCMH_RS_FRAME_ENSEMBLE: 1989 fe->dtv_property_cache.atscmh_rs_frame_ensemble = tvp->u.data; 1990 break; 1991 1992 case DTV_LNA: 1993 c->lna = tvp->u.data; 1994 if (fe->ops.set_lna) 1995 r = fe->ops.set_lna(fe); 1996 if (r < 0) 1997 c->lna = LNA_AUTO; 1998 break; 1999 2000 default: 2001 return -EINVAL; 2002 } 2003 2004 return r; 2005 } 2006 2007 static int dvb_frontend_ioctl(struct file *file, 2008 unsigned int cmd, void *parg) 2009 { 2010 struct dvb_device *dvbdev = file->private_data; 2011 struct dvb_frontend *fe = dvbdev->priv; 2012 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 2013 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2014 int err = -EOPNOTSUPP; 2015 2016 dev_dbg(fe->dvb->device, "%s: (%d)\n", __func__, _IOC_NR(cmd)); 2017 if (down_interruptible(&fepriv->sem)) 2018 return -ERESTARTSYS; 2019 2020 if (fe->exit != DVB_FE_NO_EXIT) { 2021 up(&fepriv->sem); 2022 return -ENODEV; 2023 } 2024 2025 if ((file->f_flags & O_ACCMODE) == O_RDONLY && 2026 (_IOC_DIR(cmd) != _IOC_READ || cmd == FE_GET_EVENT || 2027 cmd == FE_DISEQC_RECV_SLAVE_REPLY)) { 2028 up(&fepriv->sem); 2029 return -EPERM; 2030 } 2031 2032 if ((cmd == FE_SET_PROPERTY) || (cmd == FE_GET_PROPERTY)) 2033 err = dvb_frontend_ioctl_properties(file, cmd, parg); 2034 else { 2035 c->state = DTV_UNDEFINED; 2036 err = dvb_frontend_ioctl_legacy(file, cmd, parg); 2037 } 2038 2039 up(&fepriv->sem); 2040 return err; 2041 } 2042 2043 static int dvb_frontend_ioctl_properties(struct file *file, 2044 unsigned int cmd, void *parg) 2045 { 2046 struct dvb_device *dvbdev = file->private_data; 2047 struct dvb_frontend *fe = dvbdev->priv; 2048 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2049 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 2050 int err = 0; 2051 2052 struct dtv_properties *tvps = parg; 2053 struct dtv_property *tvp = NULL; 2054 int i; 2055 2056 dev_dbg(fe->dvb->device, "%s:\n", __func__); 2057 2058 if (cmd == FE_SET_PROPERTY) { 2059 dev_dbg(fe->dvb->device, "%s: properties.num = %d\n", __func__, tvps->num); 2060 dev_dbg(fe->dvb->device, "%s: properties.props = %p\n", __func__, tvps->props); 2061 2062 /* Put an arbitrary limit on the number of messages that can 2063 * be sent at once */ 2064 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS)) 2065 return -EINVAL; 2066 2067 tvp = kmalloc(tvps->num * sizeof(struct dtv_property), GFP_KERNEL); 2068 if (!tvp) { 2069 err = -ENOMEM; 2070 goto out; 2071 } 2072 2073 if (copy_from_user(tvp, (void __user *)tvps->props, 2074 tvps->num * sizeof(struct dtv_property))) { 2075 err = -EFAULT; 2076 goto out; 2077 } 2078 2079 for (i = 0; i < tvps->num; i++) { 2080 err = dtv_property_process_set(fe, tvp + i, file); 2081 if (err < 0) 2082 goto out; 2083 (tvp + i)->result = err; 2084 } 2085 2086 if (c->state == DTV_TUNE) 2087 dev_dbg(fe->dvb->device, "%s: Property cache is full, tuning\n", __func__); 2088 2089 } else if (cmd == FE_GET_PROPERTY) { 2090 struct dtv_frontend_properties getp = fe->dtv_property_cache; 2091 2092 dev_dbg(fe->dvb->device, "%s: properties.num = %d\n", __func__, tvps->num); 2093 dev_dbg(fe->dvb->device, "%s: properties.props = %p\n", __func__, tvps->props); 2094 2095 /* Put an arbitrary limit on the number of messages that can 2096 * be sent at once */ 2097 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS)) 2098 return -EINVAL; 2099 2100 tvp = kmalloc(tvps->num * sizeof(struct dtv_property), GFP_KERNEL); 2101 if (!tvp) { 2102 err = -ENOMEM; 2103 goto out; 2104 } 2105 2106 if (copy_from_user(tvp, (void __user *)tvps->props, 2107 tvps->num * sizeof(struct dtv_property))) { 2108 err = -EFAULT; 2109 goto out; 2110 } 2111 2112 /* 2113 * Let's use our own copy of property cache, in order to 2114 * avoid mangling with DTV zigzag logic, as drivers might 2115 * return crap, if they don't check if the data is available 2116 * before updating the properties cache. 2117 */ 2118 if (fepriv->state != FESTATE_IDLE) { 2119 err = dtv_get_frontend(fe, &getp, NULL); 2120 if (err < 0) 2121 goto out; 2122 } 2123 for (i = 0; i < tvps->num; i++) { 2124 err = dtv_property_process_get(fe, &getp, tvp + i, file); 2125 if (err < 0) 2126 goto out; 2127 (tvp + i)->result = err; 2128 } 2129 2130 if (copy_to_user((void __user *)tvps->props, tvp, 2131 tvps->num * sizeof(struct dtv_property))) { 2132 err = -EFAULT; 2133 goto out; 2134 } 2135 2136 } else 2137 err = -EOPNOTSUPP; 2138 2139 out: 2140 kfree(tvp); 2141 return err; 2142 } 2143 2144 static int dtv_set_frontend(struct dvb_frontend *fe) 2145 { 2146 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2147 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 2148 struct dvb_frontend_tune_settings fetunesettings; 2149 u32 rolloff = 0; 2150 2151 if (dvb_frontend_check_parameters(fe) < 0) 2152 return -EINVAL; 2153 2154 /* 2155 * Initialize output parameters to match the values given by 2156 * the user. FE_SET_FRONTEND triggers an initial frontend event 2157 * with status = 0, which copies output parameters to userspace. 2158 */ 2159 dtv_property_legacy_params_sync(fe, c, &fepriv->parameters_out); 2160 2161 /* 2162 * Be sure that the bandwidth will be filled for all 2163 * non-satellite systems, as tuners need to know what 2164 * low pass/Nyquist half filter should be applied, in 2165 * order to avoid inter-channel noise. 2166 * 2167 * ISDB-T and DVB-T/T2 already sets bandwidth. 2168 * ATSC and DVB-C don't set, so, the core should fill it. 2169 * 2170 * On DVB-C Annex A and C, the bandwidth is a function of 2171 * the roll-off and symbol rate. Annex B defines different 2172 * roll-off factors depending on the modulation. Fortunately, 2173 * Annex B is only used with 6MHz, so there's no need to 2174 * calculate it. 2175 * 2176 * While not officially supported, a side effect of handling it at 2177 * the cache level is that a program could retrieve the bandwidth 2178 * via DTV_BANDWIDTH_HZ, which may be useful for test programs. 2179 */ 2180 switch (c->delivery_system) { 2181 case SYS_ATSC: 2182 case SYS_DVBC_ANNEX_B: 2183 c->bandwidth_hz = 6000000; 2184 break; 2185 case SYS_DVBC_ANNEX_A: 2186 rolloff = 115; 2187 break; 2188 case SYS_DVBC_ANNEX_C: 2189 rolloff = 113; 2190 break; 2191 case SYS_DVBS: 2192 case SYS_TURBO: 2193 case SYS_ISDBS: 2194 rolloff = 135; 2195 break; 2196 case SYS_DVBS2: 2197 switch (c->rolloff) { 2198 case ROLLOFF_20: 2199 rolloff = 120; 2200 break; 2201 case ROLLOFF_25: 2202 rolloff = 125; 2203 break; 2204 default: 2205 case ROLLOFF_35: 2206 rolloff = 135; 2207 } 2208 break; 2209 default: 2210 break; 2211 } 2212 if (rolloff) 2213 c->bandwidth_hz = mult_frac(c->symbol_rate, rolloff, 100); 2214 2215 /* force auto frequency inversion if requested */ 2216 if (dvb_force_auto_inversion) 2217 c->inversion = INVERSION_AUTO; 2218 2219 /* 2220 * without hierarchical coding code_rate_LP is irrelevant, 2221 * so we tolerate the otherwise invalid FEC_NONE setting 2222 */ 2223 if (c->hierarchy == HIERARCHY_NONE && c->code_rate_LP == FEC_NONE) 2224 c->code_rate_LP = FEC_AUTO; 2225 2226 /* get frontend-specific tuning settings */ 2227 memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings)); 2228 if (fe->ops.get_tune_settings && (fe->ops.get_tune_settings(fe, &fetunesettings) == 0)) { 2229 fepriv->min_delay = (fetunesettings.min_delay_ms * HZ) / 1000; 2230 fepriv->max_drift = fetunesettings.max_drift; 2231 fepriv->step_size = fetunesettings.step_size; 2232 } else { 2233 /* default values */ 2234 switch (c->delivery_system) { 2235 case SYS_DVBS: 2236 case SYS_DVBS2: 2237 case SYS_ISDBS: 2238 case SYS_TURBO: 2239 case SYS_DVBC_ANNEX_A: 2240 case SYS_DVBC_ANNEX_C: 2241 fepriv->min_delay = HZ / 20; 2242 fepriv->step_size = c->symbol_rate / 16000; 2243 fepriv->max_drift = c->symbol_rate / 2000; 2244 break; 2245 case SYS_DVBT: 2246 case SYS_DVBT2: 2247 case SYS_ISDBT: 2248 case SYS_DTMB: 2249 fepriv->min_delay = HZ / 20; 2250 fepriv->step_size = fe->ops.info.frequency_stepsize * 2; 2251 fepriv->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1; 2252 break; 2253 default: 2254 /* 2255 * FIXME: This sounds wrong! if freqency_stepsize is 2256 * defined by the frontend, why not use it??? 2257 */ 2258 fepriv->min_delay = HZ / 20; 2259 fepriv->step_size = 0; /* no zigzag */ 2260 fepriv->max_drift = 0; 2261 break; 2262 } 2263 } 2264 if (dvb_override_tune_delay > 0) 2265 fepriv->min_delay = (dvb_override_tune_delay * HZ) / 1000; 2266 2267 fepriv->state = FESTATE_RETUNE; 2268 2269 /* Request the search algorithm to search */ 2270 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN; 2271 2272 dvb_frontend_clear_events(fe); 2273 dvb_frontend_add_event(fe, 0); 2274 dvb_frontend_wakeup(fe); 2275 fepriv->status = 0; 2276 2277 return 0; 2278 } 2279 2280 2281 static int dvb_frontend_ioctl_legacy(struct file *file, 2282 unsigned int cmd, void *parg) 2283 { 2284 struct dvb_device *dvbdev = file->private_data; 2285 struct dvb_frontend *fe = dvbdev->priv; 2286 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2287 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 2288 int err = -EOPNOTSUPP; 2289 2290 switch (cmd) { 2291 case FE_GET_INFO: { 2292 struct dvb_frontend_info* info = parg; 2293 2294 memcpy(info, &fe->ops.info, sizeof(struct dvb_frontend_info)); 2295 dvb_frontend_get_frequency_limits(fe, &info->frequency_min, &info->frequency_max); 2296 2297 /* 2298 * Associate the 4 delivery systems supported by DVBv3 2299 * API with their DVBv5 counterpart. For the other standards, 2300 * use the closest type, assuming that it would hopefully 2301 * work with a DVBv3 application. 2302 * It should be noticed that, on multi-frontend devices with 2303 * different types (terrestrial and cable, for example), 2304 * a pure DVBv3 application won't be able to use all delivery 2305 * systems. Yet, changing the DVBv5 cache to the other delivery 2306 * system should be enough for making it work. 2307 */ 2308 switch (dvbv3_type(c->delivery_system)) { 2309 case DVBV3_QPSK: 2310 info->type = FE_QPSK; 2311 break; 2312 case DVBV3_ATSC: 2313 info->type = FE_ATSC; 2314 break; 2315 case DVBV3_QAM: 2316 info->type = FE_QAM; 2317 break; 2318 case DVBV3_OFDM: 2319 info->type = FE_OFDM; 2320 break; 2321 default: 2322 dev_err(fe->dvb->device, 2323 "%s: doesn't know how to handle a DVBv3 call to delivery system %i\n", 2324 __func__, c->delivery_system); 2325 fe->ops.info.type = FE_OFDM; 2326 } 2327 dev_dbg(fe->dvb->device, "%s: current delivery system on cache: %d, V3 type: %d\n", 2328 __func__, c->delivery_system, fe->ops.info.type); 2329 2330 /* Set CAN_INVERSION_AUTO bit on in other than oneshot mode */ 2331 if (!(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT)) 2332 info->caps |= FE_CAN_INVERSION_AUTO; 2333 err = 0; 2334 break; 2335 } 2336 2337 case FE_READ_STATUS: { 2338 enum fe_status *status = parg; 2339 2340 /* if retune was requested but hasn't occurred yet, prevent 2341 * that user get signal state from previous tuning */ 2342 if (fepriv->state == FESTATE_RETUNE || 2343 fepriv->state == FESTATE_ERROR) { 2344 err=0; 2345 *status = 0; 2346 break; 2347 } 2348 2349 if (fe->ops.read_status) 2350 err = fe->ops.read_status(fe, status); 2351 break; 2352 } 2353 2354 case FE_READ_BER: 2355 if (fe->ops.read_ber) { 2356 if (fepriv->thread) 2357 err = fe->ops.read_ber(fe, (__u32 *) parg); 2358 else 2359 err = -EAGAIN; 2360 } 2361 break; 2362 2363 case FE_READ_SIGNAL_STRENGTH: 2364 if (fe->ops.read_signal_strength) { 2365 if (fepriv->thread) 2366 err = fe->ops.read_signal_strength(fe, (__u16 *) parg); 2367 else 2368 err = -EAGAIN; 2369 } 2370 break; 2371 2372 case FE_READ_SNR: 2373 if (fe->ops.read_snr) { 2374 if (fepriv->thread) 2375 err = fe->ops.read_snr(fe, (__u16 *) parg); 2376 else 2377 err = -EAGAIN; 2378 } 2379 break; 2380 2381 case FE_READ_UNCORRECTED_BLOCKS: 2382 if (fe->ops.read_ucblocks) { 2383 if (fepriv->thread) 2384 err = fe->ops.read_ucblocks(fe, (__u32 *) parg); 2385 else 2386 err = -EAGAIN; 2387 } 2388 break; 2389 2390 case FE_DISEQC_RESET_OVERLOAD: 2391 if (fe->ops.diseqc_reset_overload) { 2392 err = fe->ops.diseqc_reset_overload(fe); 2393 fepriv->state = FESTATE_DISEQC; 2394 fepriv->status = 0; 2395 } 2396 break; 2397 2398 case FE_DISEQC_SEND_MASTER_CMD: 2399 if (fe->ops.diseqc_send_master_cmd) { 2400 struct dvb_diseqc_master_cmd *cmd = parg; 2401 2402 if (cmd->msg_len > sizeof(cmd->msg)) { 2403 err = -EINVAL; 2404 break; 2405 } 2406 err = fe->ops.diseqc_send_master_cmd(fe, cmd); 2407 fepriv->state = FESTATE_DISEQC; 2408 fepriv->status = 0; 2409 } 2410 break; 2411 2412 case FE_DISEQC_SEND_BURST: 2413 if (fe->ops.diseqc_send_burst) { 2414 err = fe->ops.diseqc_send_burst(fe, 2415 (enum fe_sec_mini_cmd)parg); 2416 fepriv->state = FESTATE_DISEQC; 2417 fepriv->status = 0; 2418 } 2419 break; 2420 2421 case FE_SET_TONE: 2422 if (fe->ops.set_tone) { 2423 err = fe->ops.set_tone(fe, 2424 (enum fe_sec_tone_mode)parg); 2425 fepriv->tone = (enum fe_sec_tone_mode)parg; 2426 fepriv->state = FESTATE_DISEQC; 2427 fepriv->status = 0; 2428 } 2429 break; 2430 2431 case FE_SET_VOLTAGE: 2432 if (fe->ops.set_voltage) { 2433 err = fe->ops.set_voltage(fe, 2434 (enum fe_sec_voltage)parg); 2435 fepriv->voltage = (enum fe_sec_voltage)parg; 2436 fepriv->state = FESTATE_DISEQC; 2437 fepriv->status = 0; 2438 } 2439 break; 2440 2441 case FE_DISHNETWORK_SEND_LEGACY_CMD: 2442 if (fe->ops.dishnetwork_send_legacy_command) { 2443 err = fe->ops.dishnetwork_send_legacy_command(fe, 2444 (unsigned long)parg); 2445 fepriv->state = FESTATE_DISEQC; 2446 fepriv->status = 0; 2447 } else if (fe->ops.set_voltage) { 2448 /* 2449 * NOTE: This is a fallback condition. Some frontends 2450 * (stv0299 for instance) take longer than 8msec to 2451 * respond to a set_voltage command. Those switches 2452 * need custom routines to switch properly. For all 2453 * other frontends, the following should work ok. 2454 * Dish network legacy switches (as used by Dish500) 2455 * are controlled by sending 9-bit command words 2456 * spaced 8msec apart. 2457 * the actual command word is switch/port dependent 2458 * so it is up to the userspace application to send 2459 * the right command. 2460 * The command must always start with a '0' after 2461 * initialization, so parg is 8 bits and does not 2462 * include the initialization or start bit 2463 */ 2464 unsigned long swcmd = ((unsigned long) parg) << 1; 2465 ktime_t nexttime; 2466 ktime_t tv[10]; 2467 int i; 2468 u8 last = 1; 2469 if (dvb_frontend_debug) 2470 printk("%s switch command: 0x%04lx\n", __func__, swcmd); 2471 nexttime = ktime_get_boottime(); 2472 if (dvb_frontend_debug) 2473 tv[0] = nexttime; 2474 /* before sending a command, initialize by sending 2475 * a 32ms 18V to the switch 2476 */ 2477 fe->ops.set_voltage(fe, SEC_VOLTAGE_18); 2478 dvb_frontend_sleep_until(&nexttime, 32000); 2479 2480 for (i = 0; i < 9; i++) { 2481 if (dvb_frontend_debug) 2482 tv[i+1] = ktime_get_boottime(); 2483 if ((swcmd & 0x01) != last) { 2484 /* set voltage to (last ? 13V : 18V) */ 2485 fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18); 2486 last = (last) ? 0 : 1; 2487 } 2488 swcmd = swcmd >> 1; 2489 if (i != 8) 2490 dvb_frontend_sleep_until(&nexttime, 8000); 2491 } 2492 if (dvb_frontend_debug) { 2493 printk("%s(%d): switch delay (should be 32k followed by all 8k\n", 2494 __func__, fe->dvb->num); 2495 for (i = 1; i < 10; i++) 2496 printk("%d: %d\n", i, 2497 (int) ktime_us_delta(tv[i], tv[i-1])); 2498 } 2499 err = 0; 2500 fepriv->state = FESTATE_DISEQC; 2501 fepriv->status = 0; 2502 } 2503 break; 2504 2505 case FE_DISEQC_RECV_SLAVE_REPLY: 2506 if (fe->ops.diseqc_recv_slave_reply) 2507 err = fe->ops.diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg); 2508 break; 2509 2510 case FE_ENABLE_HIGH_LNB_VOLTAGE: 2511 if (fe->ops.enable_high_lnb_voltage) 2512 err = fe->ops.enable_high_lnb_voltage(fe, (long) parg); 2513 break; 2514 2515 case FE_SET_FRONTEND: 2516 err = dvbv3_set_delivery_system(fe); 2517 if (err) 2518 break; 2519 2520 err = dtv_property_cache_sync(fe, c, parg); 2521 if (err) 2522 break; 2523 err = dtv_set_frontend(fe); 2524 break; 2525 case FE_GET_EVENT: 2526 err = dvb_frontend_get_event (fe, parg, file->f_flags); 2527 break; 2528 2529 case FE_GET_FRONTEND: { 2530 struct dtv_frontend_properties getp = fe->dtv_property_cache; 2531 2532 /* 2533 * Let's use our own copy of property cache, in order to 2534 * avoid mangling with DTV zigzag logic, as drivers might 2535 * return crap, if they don't check if the data is available 2536 * before updating the properties cache. 2537 */ 2538 err = dtv_get_frontend(fe, &getp, parg); 2539 break; 2540 } 2541 case FE_SET_FRONTEND_TUNE_MODE: 2542 fepriv->tune_mode_flags = (unsigned long) parg; 2543 err = 0; 2544 break; 2545 } 2546 2547 return err; 2548 } 2549 2550 2551 static unsigned int dvb_frontend_poll(struct file *file, struct poll_table_struct *wait) 2552 { 2553 struct dvb_device *dvbdev = file->private_data; 2554 struct dvb_frontend *fe = dvbdev->priv; 2555 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2556 2557 dev_dbg_ratelimited(fe->dvb->device, "%s:\n", __func__); 2558 2559 poll_wait (file, &fepriv->events.wait_queue, wait); 2560 2561 if (fepriv->events.eventw != fepriv->events.eventr) 2562 return (POLLIN | POLLRDNORM | POLLPRI); 2563 2564 return 0; 2565 } 2566 2567 static int dvb_frontend_open(struct inode *inode, struct file *file) 2568 { 2569 struct dvb_device *dvbdev = file->private_data; 2570 struct dvb_frontend *fe = dvbdev->priv; 2571 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2572 struct dvb_adapter *adapter = fe->dvb; 2573 int ret; 2574 2575 dev_dbg(fe->dvb->device, "%s:\n", __func__); 2576 if (fe->exit == DVB_FE_DEVICE_REMOVED) 2577 return -ENODEV; 2578 2579 if (adapter->mfe_shared) { 2580 mutex_lock (&adapter->mfe_lock); 2581 2582 if (adapter->mfe_dvbdev == NULL) 2583 adapter->mfe_dvbdev = dvbdev; 2584 2585 else if (adapter->mfe_dvbdev != dvbdev) { 2586 struct dvb_device 2587 *mfedev = adapter->mfe_dvbdev; 2588 struct dvb_frontend 2589 *mfe = mfedev->priv; 2590 struct dvb_frontend_private 2591 *mfepriv = mfe->frontend_priv; 2592 int mferetry = (dvb_mfe_wait_time << 1); 2593 2594 mutex_unlock (&adapter->mfe_lock); 2595 while (mferetry-- && (mfedev->users != -1 || 2596 mfepriv->thread != NULL)) { 2597 if(msleep_interruptible(500)) { 2598 if(signal_pending(current)) 2599 return -EINTR; 2600 } 2601 } 2602 2603 mutex_lock (&adapter->mfe_lock); 2604 if(adapter->mfe_dvbdev != dvbdev) { 2605 mfedev = adapter->mfe_dvbdev; 2606 mfe = mfedev->priv; 2607 mfepriv = mfe->frontend_priv; 2608 if (mfedev->users != -1 || 2609 mfepriv->thread != NULL) { 2610 mutex_unlock (&adapter->mfe_lock); 2611 return -EBUSY; 2612 } 2613 adapter->mfe_dvbdev = dvbdev; 2614 } 2615 } 2616 } 2617 2618 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) { 2619 if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0) 2620 goto err0; 2621 2622 /* If we took control of the bus, we need to force 2623 reinitialization. This is because many ts_bus_ctrl() 2624 functions strobe the RESET pin on the demod, and if the 2625 frontend thread already exists then the dvb_init() routine 2626 won't get called (which is what usually does initial 2627 register configuration). */ 2628 fepriv->reinitialise = 1; 2629 } 2630 2631 if ((ret = dvb_generic_open (inode, file)) < 0) 2632 goto err1; 2633 2634 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 2635 /* normal tune mode when opened R/W */ 2636 fepriv->tune_mode_flags &= ~FE_TUNE_MODE_ONESHOT; 2637 fepriv->tone = -1; 2638 fepriv->voltage = -1; 2639 2640 ret = dvb_frontend_start (fe); 2641 if (ret) 2642 goto err2; 2643 2644 /* empty event queue */ 2645 fepriv->events.eventr = fepriv->events.eventw = 0; 2646 } 2647 2648 if (adapter->mfe_shared) 2649 mutex_unlock (&adapter->mfe_lock); 2650 return ret; 2651 2652 err2: 2653 dvb_generic_release(inode, file); 2654 err1: 2655 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) 2656 fe->ops.ts_bus_ctrl(fe, 0); 2657 err0: 2658 if (adapter->mfe_shared) 2659 mutex_unlock (&adapter->mfe_lock); 2660 return ret; 2661 } 2662 2663 static int dvb_frontend_release(struct inode *inode, struct file *file) 2664 { 2665 struct dvb_device *dvbdev = file->private_data; 2666 struct dvb_frontend *fe = dvbdev->priv; 2667 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2668 int ret; 2669 2670 dev_dbg(fe->dvb->device, "%s:\n", __func__); 2671 2672 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 2673 fepriv->release_jiffies = jiffies; 2674 mb(); 2675 } 2676 2677 ret = dvb_generic_release (inode, file); 2678 2679 if (dvbdev->users == -1) { 2680 wake_up(&fepriv->wait_queue); 2681 if (fe->exit != DVB_FE_NO_EXIT) 2682 wake_up(&dvbdev->wait_queue); 2683 if (fe->ops.ts_bus_ctrl) 2684 fe->ops.ts_bus_ctrl(fe, 0); 2685 } 2686 2687 return ret; 2688 } 2689 2690 static const struct file_operations dvb_frontend_fops = { 2691 .owner = THIS_MODULE, 2692 .unlocked_ioctl = dvb_generic_ioctl, 2693 .poll = dvb_frontend_poll, 2694 .open = dvb_frontend_open, 2695 .release = dvb_frontend_release, 2696 .llseek = noop_llseek, 2697 }; 2698 2699 int dvb_frontend_suspend(struct dvb_frontend *fe) 2700 { 2701 int ret = 0; 2702 2703 dev_dbg(fe->dvb->device, "%s: adap=%d fe=%d\n", __func__, fe->dvb->num, 2704 fe->id); 2705 2706 if (fe->ops.tuner_ops.suspend) 2707 ret = fe->ops.tuner_ops.suspend(fe); 2708 else if (fe->ops.tuner_ops.sleep) 2709 ret = fe->ops.tuner_ops.sleep(fe); 2710 2711 if (fe->ops.sleep) 2712 ret = fe->ops.sleep(fe); 2713 2714 return ret; 2715 } 2716 EXPORT_SYMBOL(dvb_frontend_suspend); 2717 2718 int dvb_frontend_resume(struct dvb_frontend *fe) 2719 { 2720 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2721 int ret = 0; 2722 2723 dev_dbg(fe->dvb->device, "%s: adap=%d fe=%d\n", __func__, fe->dvb->num, 2724 fe->id); 2725 2726 fe->exit = DVB_FE_DEVICE_RESUME; 2727 if (fe->ops.init) 2728 ret = fe->ops.init(fe); 2729 2730 if (fe->ops.tuner_ops.resume) 2731 ret = fe->ops.tuner_ops.resume(fe); 2732 else if (fe->ops.tuner_ops.init) 2733 ret = fe->ops.tuner_ops.init(fe); 2734 2735 if (fe->ops.set_tone && fepriv->tone != -1) 2736 fe->ops.set_tone(fe, fepriv->tone); 2737 if (fe->ops.set_voltage && fepriv->voltage != -1) 2738 fe->ops.set_voltage(fe, fepriv->voltage); 2739 2740 fe->exit = DVB_FE_NO_EXIT; 2741 fepriv->state = FESTATE_RETUNE; 2742 dvb_frontend_wakeup(fe); 2743 2744 return ret; 2745 } 2746 EXPORT_SYMBOL(dvb_frontend_resume); 2747 2748 int dvb_register_frontend(struct dvb_adapter* dvb, 2749 struct dvb_frontend* fe) 2750 { 2751 struct dvb_frontend_private *fepriv; 2752 const struct dvb_device dvbdev_template = { 2753 .users = ~0, 2754 .writers = 1, 2755 .readers = (~0)-1, 2756 .fops = &dvb_frontend_fops, 2757 #if defined(CONFIG_MEDIA_CONTROLLER_DVB) 2758 .name = fe->ops.info.name, 2759 #endif 2760 .kernel_ioctl = dvb_frontend_ioctl 2761 }; 2762 2763 dev_dbg(dvb->device, "%s:\n", __func__); 2764 2765 if (mutex_lock_interruptible(&frontend_mutex)) 2766 return -ERESTARTSYS; 2767 2768 fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL); 2769 if (fe->frontend_priv == NULL) { 2770 mutex_unlock(&frontend_mutex); 2771 return -ENOMEM; 2772 } 2773 fepriv = fe->frontend_priv; 2774 2775 sema_init(&fepriv->sem, 1); 2776 init_waitqueue_head (&fepriv->wait_queue); 2777 init_waitqueue_head (&fepriv->events.wait_queue); 2778 mutex_init(&fepriv->events.mtx); 2779 fe->dvb = dvb; 2780 fepriv->inversion = INVERSION_OFF; 2781 2782 dev_info(fe->dvb->device, 2783 "DVB: registering adapter %i frontend %i (%s)...\n", 2784 fe->dvb->num, fe->id, fe->ops.info.name); 2785 2786 dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template, 2787 fe, DVB_DEVICE_FRONTEND, 0); 2788 2789 /* 2790 * Initialize the cache to the proper values according with the 2791 * first supported delivery system (ops->delsys[0]) 2792 */ 2793 2794 fe->dtv_property_cache.delivery_system = fe->ops.delsys[0]; 2795 dvb_frontend_clear_cache(fe); 2796 2797 mutex_unlock(&frontend_mutex); 2798 return 0; 2799 } 2800 EXPORT_SYMBOL(dvb_register_frontend); 2801 2802 int dvb_unregister_frontend(struct dvb_frontend* fe) 2803 { 2804 struct dvb_frontend_private *fepriv = fe->frontend_priv; 2805 dev_dbg(fe->dvb->device, "%s:\n", __func__); 2806 2807 mutex_lock(&frontend_mutex); 2808 dvb_frontend_stop (fe); 2809 mutex_unlock(&frontend_mutex); 2810 2811 if (fepriv->dvbdev->users < -1) 2812 wait_event(fepriv->dvbdev->wait_queue, 2813 fepriv->dvbdev->users==-1); 2814 2815 mutex_lock(&frontend_mutex); 2816 dvb_unregister_device (fepriv->dvbdev); 2817 2818 /* fe is invalid now */ 2819 kfree(fepriv); 2820 mutex_unlock(&frontend_mutex); 2821 return 0; 2822 } 2823 EXPORT_SYMBOL(dvb_unregister_frontend); 2824 2825 #ifdef CONFIG_MEDIA_ATTACH 2826 void dvb_frontend_detach(struct dvb_frontend* fe) 2827 { 2828 void *ptr; 2829 2830 if (fe->ops.release_sec) { 2831 fe->ops.release_sec(fe); 2832 dvb_detach(fe->ops.release_sec); 2833 } 2834 if (fe->ops.tuner_ops.release) { 2835 fe->ops.tuner_ops.release(fe); 2836 dvb_detach(fe->ops.tuner_ops.release); 2837 } 2838 if (fe->ops.analog_ops.release) { 2839 fe->ops.analog_ops.release(fe); 2840 dvb_detach(fe->ops.analog_ops.release); 2841 } 2842 ptr = (void*)fe->ops.release; 2843 if (ptr) { 2844 fe->ops.release(fe); 2845 dvb_detach(ptr); 2846 } 2847 } 2848 #else 2849 void dvb_frontend_detach(struct dvb_frontend* fe) 2850 { 2851 if (fe->ops.release_sec) 2852 fe->ops.release_sec(fe); 2853 if (fe->ops.tuner_ops.release) 2854 fe->ops.tuner_ops.release(fe); 2855 if (fe->ops.analog_ops.release) 2856 fe->ops.analog_ops.release(fe); 2857 if (fe->ops.release) 2858 fe->ops.release(fe); 2859 } 2860 #endif 2861 EXPORT_SYMBOL(dvb_frontend_detach); 2862