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