1/* 2 * dvb_frontend.c: DVB frontend tuning interface/thread 3 * 4 * 5 * Copyright (C) 1999-2001 Ralph Metzler 6 * Marcus Metzler 7 * Holger Waechtler 8 * for convergence integrated media GmbH 9 * 10 * Copyright (C) 2004 Andrew de Quincey (tuning thread cleanup) 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 2 15 * of the License, or (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 25 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html 26 */ 27 28#include <linux/string.h> 29#include <linux/kernel.h> 30#include <linux/sched.h> 31#include <linux/wait.h> 32#include <linux/slab.h> 33#include <linux/poll.h> 34#include <linux/module.h> 35#include <linux/moduleparam.h> 36#include <linux/list.h> 37#include <linux/freezer.h> 38#include <linux/jiffies.h> 39#include <linux/kthread.h> 40#include <asm/processor.h> 41 42#include "dvb_frontend.h" 43#include "dvbdev.h" 44 45static int dvb_frontend_debug; 46static int dvb_shutdown_timeout = 5; 47static int dvb_force_auto_inversion; 48static int dvb_override_tune_delay; 49static int dvb_powerdown_on_sleep = 1; 50 51module_param_named(frontend_debug, dvb_frontend_debug, int, 0644); 52MODULE_PARM_DESC(frontend_debug, "Turn on/off frontend core debugging (default:off)."); 53module_param(dvb_shutdown_timeout, int, 0644); 54MODULE_PARM_DESC(dvb_shutdown_timeout, "wait <shutdown_timeout> seconds after close() before suspending hardware"); 55module_param(dvb_force_auto_inversion, int, 0644); 56MODULE_PARM_DESC(dvb_force_auto_inversion, "0: normal (default), 1: INVERSION_AUTO forced always"); 57module_param(dvb_override_tune_delay, int, 0644); 58MODULE_PARM_DESC(dvb_override_tune_delay, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt"); 59module_param(dvb_powerdown_on_sleep, int, 0644); 60MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB voltage off on sleep (default)"); 61 62#define dprintk if (dvb_frontend_debug) printk 63 64#define FESTATE_IDLE 1 65#define FESTATE_RETUNE 2 66#define FESTATE_TUNING_FAST 4 67#define FESTATE_TUNING_SLOW 8 68#define FESTATE_TUNED 16 69#define FESTATE_ZIGZAG_FAST 32 70#define FESTATE_ZIGZAG_SLOW 64 71#define FESTATE_DISEQC 128 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#define FE_ALGO_HW 1 78/* 79 * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling. 80 * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune. 81 * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress. 82 * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower. 83 * FESTATE_TUNED. The frontend has successfully locked on. 84 * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it. 85 * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower. 86 * FESTATE_DISEQC. A DISEQC command has just been issued. 87 * FESTATE_WAITFORLOCK. When we're waiting for a lock. 88 * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan. 89 * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan. 90 * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again. 91 */ 92 93static DEFINE_MUTEX(frontend_mutex); 94 95struct dvb_frontend_private { 96 97 /* thread/frontend values */ 98 struct dvb_device *dvbdev; 99 struct dvb_frontend_parameters parameters; 100 struct dvb_fe_events events; 101 struct semaphore sem; 102 struct list_head list_head; 103 wait_queue_head_t wait_queue; 104 struct task_struct *thread; 105 unsigned long release_jiffies; 106 unsigned int exit; 107 unsigned int wakeup; 108 fe_status_t status; 109 unsigned long tune_mode_flags; 110 unsigned int delay; 111 unsigned int reinitialise; 112 int tone; 113 int voltage; 114 115 /* swzigzag values */ 116 unsigned int state; 117 unsigned int bending; 118 int lnb_drift; 119 unsigned int inversion; 120 unsigned int auto_step; 121 unsigned int auto_sub_step; 122 unsigned int started_auto_step; 123 unsigned int min_delay; 124 unsigned int max_drift; 125 unsigned int step_size; 126 int quality; 127 unsigned int check_wrapped; 128}; 129 130static void dvb_frontend_wakeup(struct dvb_frontend *fe); 131 132static void dvb_frontend_add_event(struct dvb_frontend *fe, fe_status_t status) 133{ 134 struct dvb_frontend_private *fepriv = fe->frontend_priv; 135 struct dvb_fe_events *events = &fepriv->events; 136 struct dvb_frontend_event *e; 137 int wp; 138 139 dprintk ("%s\n", __FUNCTION__); 140 141 if (down_interruptible (&events->sem)) 142 return; 143 144 wp = (events->eventw + 1) % MAX_EVENT; 145 146 if (wp == events->eventr) { 147 events->overflow = 1; 148 events->eventr = (events->eventr + 1) % MAX_EVENT; 149 } 150 151 e = &events->events[events->eventw]; 152 153 memcpy (&e->parameters, &fepriv->parameters, 154 sizeof (struct dvb_frontend_parameters)); 155 156 if (status & FE_HAS_LOCK) 157 if (fe->ops.get_frontend) 158 fe->ops.get_frontend(fe, &e->parameters); 159 160 events->eventw = wp; 161 162 up (&events->sem); 163 164 e->status = status; 165 166 wake_up_interruptible (&events->wait_queue); 167} 168 169static int dvb_frontend_get_event(struct dvb_frontend *fe, 170 struct dvb_frontend_event *event, int flags) 171{ 172 struct dvb_frontend_private *fepriv = fe->frontend_priv; 173 struct dvb_fe_events *events = &fepriv->events; 174 175 dprintk ("%s\n", __FUNCTION__); 176 177 if (events->overflow) { 178 events->overflow = 0; 179 return -EOVERFLOW; 180 } 181 182 if (events->eventw == events->eventr) { 183 int ret; 184 185 if (flags & O_NONBLOCK) 186 return -EWOULDBLOCK; 187 188 up(&fepriv->sem); 189 190 ret = wait_event_interruptible (events->wait_queue, 191 events->eventw != events->eventr); 192 193 if (down_interruptible (&fepriv->sem)) 194 return -ERESTARTSYS; 195 196 if (ret < 0) 197 return ret; 198 } 199 200 if (down_interruptible (&events->sem)) 201 return -ERESTARTSYS; 202 203 memcpy (event, &events->events[events->eventr], 204 sizeof(struct dvb_frontend_event)); 205 206 events->eventr = (events->eventr + 1) % MAX_EVENT; 207 208 up (&events->sem); 209 210 return 0; 211} 212 213static void dvb_frontend_init(struct dvb_frontend *fe) 214{ 215 dprintk ("DVB: initialising frontend %i (%s)...\n", 216 fe->dvb->num, 217 fe->ops.info.name); 218 219 if (fe->ops.init) 220 fe->ops.init(fe); 221 if (fe->ops.tuner_ops.init) { 222 fe->ops.tuner_ops.init(fe); 223 if (fe->ops.i2c_gate_ctrl) 224 fe->ops.i2c_gate_ctrl(fe, 0); 225 } 226} 227 228void dvb_frontend_reinitialise(struct dvb_frontend *fe) 229{ 230 struct dvb_frontend_private *fepriv = fe->frontend_priv; 231 232 fepriv->reinitialise = 1; 233 dvb_frontend_wakeup(fe); 234} 235EXPORT_SYMBOL(dvb_frontend_reinitialise); 236 237static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private *fepriv, int locked) 238{ 239 int q2; 240 241 dprintk ("%s\n", __FUNCTION__); 242 243 if (locked) 244 (fepriv->quality) = (fepriv->quality * 220 + 36*256) / 256; 245 else 246 (fepriv->quality) = (fepriv->quality * 220 + 0) / 256; 247 248 q2 = fepriv->quality - 128; 249 q2 *= q2; 250 251 fepriv->delay = fepriv->min_delay + q2 * HZ / (128*128); 252} 253 254/** 255 * Performs automatic twiddling of frontend parameters. 256 * 257 * @param fe The frontend concerned. 258 * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT 259 * @returns Number of complete iterations that have been performed. 260 */ 261static int dvb_frontend_swzigzag_autotune(struct dvb_frontend *fe, int check_wrapped) 262{ 263 int autoinversion; 264 int ready = 0; 265 struct dvb_frontend_private *fepriv = fe->frontend_priv; 266 int original_inversion = fepriv->parameters.inversion; 267 u32 original_frequency = fepriv->parameters.frequency; 268 269 /* are we using autoinversion? */ 270 autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && 271 (fepriv->parameters.inversion == INVERSION_AUTO)); 272 273 /* setup parameters correctly */ 274 while(!ready) { 275 /* calculate the lnb_drift */ 276 fepriv->lnb_drift = fepriv->auto_step * fepriv->step_size; 277 278 /* wrap the auto_step if we've exceeded the maximum drift */ 279 if (fepriv->lnb_drift > fepriv->max_drift) { 280 fepriv->auto_step = 0; 281 fepriv->auto_sub_step = 0; 282 fepriv->lnb_drift = 0; 283 } 284 285 /* perform inversion and +/- zigzag */ 286 switch(fepriv->auto_sub_step) { 287 case 0: 288 /* try with the current inversion and current drift setting */ 289 ready = 1; 290 break; 291 292 case 1: 293 if (!autoinversion) break; 294 295 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF; 296 ready = 1; 297 break; 298 299 case 2: 300 if (fepriv->lnb_drift == 0) break; 301 302 fepriv->lnb_drift = -fepriv->lnb_drift; 303 ready = 1; 304 break; 305 306 case 3: 307 if (fepriv->lnb_drift == 0) break; 308 if (!autoinversion) break; 309 310 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF; 311 fepriv->lnb_drift = -fepriv->lnb_drift; 312 ready = 1; 313 break; 314 315 default: 316 fepriv->auto_step++; 317 fepriv->auto_sub_step = -1; /* it'll be incremented to 0 in a moment */ 318 break; 319 } 320 321 if (!ready) fepriv->auto_sub_step++; 322 } 323 324 /* if this attempt would hit where we started, indicate a complete 325 * iteration has occurred */ 326 if ((fepriv->auto_step == fepriv->started_auto_step) && 327 (fepriv->auto_sub_step == 0) && check_wrapped) { 328 return 1; 329 } 330 331 dprintk("%s: drift:%i inversion:%i auto_step:%i " 332 "auto_sub_step:%i started_auto_step:%i\n", 333 __FUNCTION__, fepriv->lnb_drift, fepriv->inversion, 334 fepriv->auto_step, fepriv->auto_sub_step, fepriv->started_auto_step); 335 336 /* set the frontend itself */ 337 fepriv->parameters.frequency += fepriv->lnb_drift; 338 if (autoinversion) 339 fepriv->parameters.inversion = fepriv->inversion; 340 if (fe->ops.set_frontend) 341 fe->ops.set_frontend(fe, &fepriv->parameters); 342 343 fepriv->parameters.frequency = original_frequency; 344 fepriv->parameters.inversion = original_inversion; 345 346 fepriv->auto_sub_step++; 347 return 0; 348} 349 350static void dvb_frontend_swzigzag(struct dvb_frontend *fe) 351{ 352 fe_status_t s = 0; 353 struct dvb_frontend_private *fepriv = fe->frontend_priv; 354 355 /* if we've got no parameters, just keep idling */ 356 if (fepriv->state & FESTATE_IDLE) { 357 fepriv->delay = 3*HZ; 358 fepriv->quality = 0; 359 return; 360 } 361 362 /* in SCAN mode, we just set the frontend when asked and leave it alone */ 363 if (fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT) { 364 if (fepriv->state & FESTATE_RETUNE) { 365 if (fe->ops.set_frontend) 366 fe->ops.set_frontend(fe, &fepriv->parameters); 367 fepriv->state = FESTATE_TUNED; 368 } 369 fepriv->delay = 3*HZ; 370 fepriv->quality = 0; 371 return; 372 } 373 374 /* get the frontend status */ 375 if (fepriv->state & FESTATE_RETUNE) { 376 s = 0; 377 } else { 378 if (fe->ops.read_status) 379 fe->ops.read_status(fe, &s); 380 if (s != fepriv->status) { 381 dvb_frontend_add_event(fe, s); 382 fepriv->status = s; 383 } 384 } 385 386 /* if we're not tuned, and we have a lock, move to the TUNED state */ 387 if ((fepriv->state & FESTATE_WAITFORLOCK) && (s & FE_HAS_LOCK)) { 388 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 389 fepriv->state = FESTATE_TUNED; 390 391 /* if we're tuned, then we have determined the correct inversion */ 392 if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && 393 (fepriv->parameters.inversion == INVERSION_AUTO)) { 394 fepriv->parameters.inversion = fepriv->inversion; 395 } 396 return; 397 } 398 399 /* if we are tuned already, check we're still locked */ 400 if (fepriv->state & FESTATE_TUNED) { 401 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 402 403 /* we're tuned, and the lock is still good... */ 404 if (s & FE_HAS_LOCK) { 405 return; 406 } else { /* if we _WERE_ tuned, but now don't have a lock */ 407 fepriv->state = FESTATE_ZIGZAG_FAST; 408 fepriv->started_auto_step = fepriv->auto_step; 409 fepriv->check_wrapped = 0; 410 } 411 } 412 413 /* don't actually do anything if we're in the LOSTLOCK state, 414 * the frontend is set to FE_CAN_RECOVER, and the max_drift is 0 */ 415 if ((fepriv->state & FESTATE_LOSTLOCK) && 416 (fe->ops.info.caps & FE_CAN_RECOVER) && (fepriv->max_drift == 0)) { 417 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 418 return; 419 } 420 421 /* don't do anything if we're in the DISEQC state, since this 422 * might be someone with a motorized dish controlled by DISEQC. 423 * If its actually a re-tune, there will be a SET_FRONTEND soon enough. */ 424 if (fepriv->state & FESTATE_DISEQC) { 425 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 426 return; 427 } 428 429 /* if we're in the RETUNE state, set everything up for a brand 430 * new scan, keeping the current inversion setting, as the next 431 * tune is _very_ likely to require the same */ 432 if (fepriv->state & FESTATE_RETUNE) { 433 fepriv->lnb_drift = 0; 434 fepriv->auto_step = 0; 435 fepriv->auto_sub_step = 0; 436 fepriv->started_auto_step = 0; 437 fepriv->check_wrapped = 0; 438 } 439 440 /* fast zigzag. */ 441 if ((fepriv->state & FESTATE_SEARCHING_FAST) || (fepriv->state & FESTATE_RETUNE)) { 442 fepriv->delay = fepriv->min_delay; 443 444 /* peform a tune */ 445 if (dvb_frontend_swzigzag_autotune(fe, fepriv->check_wrapped)) { 446 /* OK, if we've run out of trials at the fast speed. 447 * Drop back to slow for the _next_ attempt */ 448 fepriv->state = FESTATE_SEARCHING_SLOW; 449 fepriv->started_auto_step = fepriv->auto_step; 450 return; 451 } 452 fepriv->check_wrapped = 1; 453 454 /* if we've just retuned, enter the ZIGZAG_FAST state. 455 * This ensures we cannot return from an 456 * FE_SET_FRONTEND ioctl before the first frontend tune 457 * occurs */ 458 if (fepriv->state & FESTATE_RETUNE) { 459 fepriv->state = FESTATE_TUNING_FAST; 460 } 461 } 462 463 /* slow zigzag */ 464 if (fepriv->state & FESTATE_SEARCHING_SLOW) { 465 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK); 466 467 /* Note: don't bother checking for wrapping; we stay in this 468 * state until we get a lock */ 469 dvb_frontend_swzigzag_autotune(fe, 0); 470 } 471} 472 473static int dvb_frontend_is_exiting(struct dvb_frontend *fe) 474{ 475 struct dvb_frontend_private *fepriv = fe->frontend_priv; 476 477 if (fepriv->exit) 478 return 1; 479 480 if (fepriv->dvbdev->writers == 1) 481 if (time_after(jiffies, fepriv->release_jiffies + 482 dvb_shutdown_timeout * HZ)) 483 return 1; 484 485 return 0; 486} 487 488static int dvb_frontend_should_wakeup(struct dvb_frontend *fe) 489{ 490 struct dvb_frontend_private *fepriv = fe->frontend_priv; 491 492 if (fepriv->wakeup) { 493 fepriv->wakeup = 0; 494 return 1; 495 } 496 return dvb_frontend_is_exiting(fe); 497} 498 499static void dvb_frontend_wakeup(struct dvb_frontend *fe) 500{ 501 struct dvb_frontend_private *fepriv = fe->frontend_priv; 502 503 fepriv->wakeup = 1; 504 wake_up_interruptible(&fepriv->wait_queue); 505} 506 507static int dvb_frontend_thread(void *data) 508{ 509 struct dvb_frontend *fe = data; 510 struct dvb_frontend_private *fepriv = fe->frontend_priv; 511 unsigned long timeout; 512 fe_status_t s; 513 struct dvb_frontend_parameters *params; 514 515 dprintk("%s\n", __FUNCTION__); 516 517 fepriv->check_wrapped = 0; 518 fepriv->quality = 0; 519 fepriv->delay = 3*HZ; 520 fepriv->status = 0; 521 fepriv->wakeup = 0; 522 fepriv->reinitialise = 0; 523 524 dvb_frontend_init(fe); 525 526 while (1) { 527 up(&fepriv->sem); /* is locked when we enter the thread... */ 528restart: 529 timeout = wait_event_interruptible_timeout(fepriv->wait_queue, 530 dvb_frontend_should_wakeup(fe) || kthread_should_stop(), 531 fepriv->delay); 532 533 if (kthread_should_stop() || dvb_frontend_is_exiting(fe)) { 534 /* got signal or quitting */ 535 break; 536 } 537 538 if (try_to_freeze()) 539 goto restart; 540 541 if (down_interruptible(&fepriv->sem)) 542 break; 543 544 if (fepriv->reinitialise) { 545 dvb_frontend_init(fe); 546 if (fepriv->tone != -1) { 547 fe->ops.set_tone(fe, fepriv->tone); 548 } 549 if (fepriv->voltage != -1) { 550 fe->ops.set_voltage(fe, fepriv->voltage); 551 } 552 fepriv->reinitialise = 0; 553 } 554 555 /* do an iteration of the tuning loop */ 556 if (fe->ops.get_frontend_algo) { 557 if (fe->ops.get_frontend_algo(fe) == FE_ALGO_HW) { 558 /* have we been asked to retune? */ 559 params = NULL; 560 if (fepriv->state & FESTATE_RETUNE) { 561 params = &fepriv->parameters; 562 fepriv->state = FESTATE_TUNED; 563 } 564 565 fe->ops.tune(fe, params, fepriv->tune_mode_flags, &fepriv->delay, &s); 566 if (s != fepriv->status) { 567 dvb_frontend_add_event(fe, s); 568 fepriv->status = s; 569 } 570 } else 571 dvb_frontend_swzigzag(fe); 572 } else 573 dvb_frontend_swzigzag(fe); 574 } 575 576 if (dvb_shutdown_timeout) { 577 if (dvb_powerdown_on_sleep) 578 if (fe->ops.set_voltage) 579 fe->ops.set_voltage(fe, SEC_VOLTAGE_OFF); 580 if (fe->ops.tuner_ops.sleep) { 581 fe->ops.tuner_ops.sleep(fe); 582 if (fe->ops.i2c_gate_ctrl) 583 fe->ops.i2c_gate_ctrl(fe, 0); 584 } 585 if (fe->ops.sleep) 586 fe->ops.sleep(fe); 587 } 588 589 fepriv->thread = NULL; 590 mb(); 591 592 dvb_frontend_wakeup(fe); 593 return 0; 594} 595 596static void dvb_frontend_stop(struct dvb_frontend *fe) 597{ 598 struct dvb_frontend_private *fepriv = fe->frontend_priv; 599 600 dprintk ("%s\n", __FUNCTION__); 601 602 fepriv->exit = 1; 603 mb(); 604 605 if (!fepriv->thread) 606 return; 607 608 kthread_stop(fepriv->thread); 609 610 init_MUTEX (&fepriv->sem); 611 fepriv->state = FESTATE_IDLE; 612 613 /* paranoia check in case a signal arrived */ 614 if (fepriv->thread) 615 printk("dvb_frontend_stop: warning: thread %p won't exit\n", 616 fepriv->thread); 617} 618 619s32 timeval_usec_diff(struct timeval lasttime, struct timeval curtime) 620{ 621 return ((curtime.tv_usec < lasttime.tv_usec) ? 622 1000000 - lasttime.tv_usec + curtime.tv_usec : 623 curtime.tv_usec - lasttime.tv_usec); 624} 625EXPORT_SYMBOL(timeval_usec_diff); 626 627static inline void timeval_usec_add(struct timeval *curtime, u32 add_usec) 628{ 629 curtime->tv_usec += add_usec; 630 if (curtime->tv_usec >= 1000000) { 631 curtime->tv_usec -= 1000000; 632 curtime->tv_sec++; 633 } 634} 635 636/* 637 * Sleep until gettimeofday() > waketime + add_usec 638 * This needs to be as precise as possible, but as the delay is 639 * usually between 2ms and 32ms, it is done using a scheduled msleep 640 * followed by usleep (normally a busy-wait loop) for the remainder 641 */ 642void dvb_frontend_sleep_until(struct timeval *waketime, u32 add_usec) 643{ 644 struct timeval lasttime; 645 s32 delta, newdelta; 646 647 timeval_usec_add(waketime, add_usec); 648 649 do_gettimeofday(&lasttime); 650 delta = timeval_usec_diff(lasttime, *waketime); 651 if (delta > 2500) { 652 msleep((delta - 1500) / 1000); 653 do_gettimeofday(&lasttime); 654 newdelta = timeval_usec_diff(lasttime, *waketime); 655 delta = (newdelta > delta) ? 0 : newdelta; 656 } 657 if (delta > 0) 658 udelay(delta); 659} 660EXPORT_SYMBOL(dvb_frontend_sleep_until); 661 662static int dvb_frontend_start(struct dvb_frontend *fe) 663{ 664 int ret; 665 struct dvb_frontend_private *fepriv = fe->frontend_priv; 666 struct task_struct *fe_thread; 667 668 dprintk ("%s\n", __FUNCTION__); 669 670 if (fepriv->thread) { 671 if (!fepriv->exit) 672 return 0; 673 else 674 dvb_frontend_stop (fe); 675 } 676 677 if (signal_pending(current)) 678 return -EINTR; 679 if (down_interruptible (&fepriv->sem)) 680 return -EINTR; 681 682 fepriv->state = FESTATE_IDLE; 683 fepriv->exit = 0; 684 fepriv->thread = NULL; 685 mb(); 686 687 fe_thread = kthread_run(dvb_frontend_thread, fe, 688 "kdvb-fe-%i", fe->dvb->num); 689 if (IS_ERR(fe_thread)) { 690 ret = PTR_ERR(fe_thread); 691 printk("dvb_frontend_start: failed to start kthread (%d)\n", ret); 692 up(&fepriv->sem); 693 return ret; 694 } 695 fepriv->thread = fe_thread; 696 return 0; 697} 698 699static int dvb_frontend_ioctl(struct inode *inode, struct file *file, 700 unsigned int cmd, void *parg) 701{ 702 struct dvb_device *dvbdev = file->private_data; 703 struct dvb_frontend *fe = dvbdev->priv; 704 struct dvb_frontend_private *fepriv = fe->frontend_priv; 705 int err = -EOPNOTSUPP; 706 707 dprintk ("%s\n", __FUNCTION__); 708 709 if (!fe || fepriv->exit) 710 return -ENODEV; 711 712 if ((file->f_flags & O_ACCMODE) == O_RDONLY && 713 (_IOC_DIR(cmd) != _IOC_READ || cmd == FE_GET_EVENT || 714 cmd == FE_DISEQC_RECV_SLAVE_REPLY)) 715 return -EPERM; 716 717 if (down_interruptible (&fepriv->sem)) 718 return -ERESTARTSYS; 719 720 switch (cmd) { 721 case FE_GET_INFO: { 722 struct dvb_frontend_info* info = parg; 723 memcpy(info, &fe->ops.info, sizeof(struct dvb_frontend_info)); 724 725 /* Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't 726 * do it, it is done for it. */ 727 info->caps |= FE_CAN_INVERSION_AUTO; 728 err = 0; 729 break; 730 } 731 732 case FE_READ_STATUS: { 733 fe_status_t* status = parg; 734 735 /* if retune was requested but hasn't occured yet, prevent 736 * that user get signal state from previous tuning */ 737 if(fepriv->state == FESTATE_RETUNE) { 738 err=0; 739 *status = 0; 740 break; 741 } 742 743 if (fe->ops.read_status) 744 err = fe->ops.read_status(fe, status); 745 break; 746 } 747 case FE_READ_BER: 748 if (fe->ops.read_ber) 749 err = fe->ops.read_ber(fe, (__u32*) parg); 750 break; 751 752 case FE_READ_SIGNAL_STRENGTH: 753 if (fe->ops.read_signal_strength) 754 err = fe->ops.read_signal_strength(fe, (__u16*) parg); 755 break; 756 757 case FE_READ_SNR: 758 if (fe->ops.read_snr) 759 err = fe->ops.read_snr(fe, (__u16*) parg); 760 break; 761 762 case FE_READ_UNCORRECTED_BLOCKS: 763 if (fe->ops.read_ucblocks) 764 err = fe->ops.read_ucblocks(fe, (__u32*) parg); 765 break; 766 767 768 case FE_DISEQC_RESET_OVERLOAD: 769 if (fe->ops.diseqc_reset_overload) { 770 err = fe->ops.diseqc_reset_overload(fe); 771 fepriv->state = FESTATE_DISEQC; 772 fepriv->status = 0; 773 } 774 break; 775 776 case FE_DISEQC_SEND_MASTER_CMD: 777 if (fe->ops.diseqc_send_master_cmd) { 778 err = fe->ops.diseqc_send_master_cmd(fe, (struct dvb_diseqc_master_cmd*) parg); 779 fepriv->state = FESTATE_DISEQC; 780 fepriv->status = 0; 781 } 782 break; 783 784 case FE_DISEQC_SEND_BURST: 785 if (fe->ops.diseqc_send_burst) { 786 err = fe->ops.diseqc_send_burst(fe, (fe_sec_mini_cmd_t) parg); 787 fepriv->state = FESTATE_DISEQC; 788 fepriv->status = 0; 789 } 790 break; 791 792 case FE_SET_TONE: 793 if (fe->ops.set_tone) { 794 err = fe->ops.set_tone(fe, (fe_sec_tone_mode_t) parg); 795 fepriv->tone = (fe_sec_tone_mode_t) parg; 796 fepriv->state = FESTATE_DISEQC; 797 fepriv->status = 0; 798 } 799 break; 800 801 case FE_SET_VOLTAGE: 802 if (fe->ops.set_voltage) { 803 err = fe->ops.set_voltage(fe, (fe_sec_voltage_t) parg); 804 fepriv->voltage = (fe_sec_voltage_t) parg; 805 fepriv->state = FESTATE_DISEQC; 806 fepriv->status = 0; 807 } 808 break; 809 810 case FE_DISHNETWORK_SEND_LEGACY_CMD: 811 if (fe->ops.dishnetwork_send_legacy_command) { 812 err = fe->ops.dishnetwork_send_legacy_command(fe, (unsigned long) parg); 813 fepriv->state = FESTATE_DISEQC; 814 fepriv->status = 0; 815 } else if (fe->ops.set_voltage) { 816 /* 817 * NOTE: This is a fallback condition. Some frontends 818 * (stv0299 for instance) take longer than 8msec to 819 * respond to a set_voltage command. Those switches 820 * need custom routines to switch properly. For all 821 * other frontends, the following shoule work ok. 822 * Dish network legacy switches (as used by Dish500) 823 * are controlled by sending 9-bit command words 824 * spaced 8msec apart. 825 * the actual command word is switch/port dependant 826 * so it is up to the userspace application to send 827 * the right command. 828 * The command must always start with a '0' after 829 * initialization, so parg is 8 bits and does not 830 * include the initialization or start bit 831 */ 832 unsigned long cmd = ((unsigned long) parg) << 1; 833 struct timeval nexttime; 834 struct timeval tv[10]; 835 int i; 836 u8 last = 1; 837 if (dvb_frontend_debug) 838 printk("%s switch command: 0x%04lx\n", __FUNCTION__, cmd); 839 do_gettimeofday(&nexttime); 840 if (dvb_frontend_debug) 841 memcpy(&tv[0], &nexttime, sizeof(struct timeval)); 842 /* before sending a command, initialize by sending 843 * a 32ms 18V to the switch 844 */ 845 fe->ops.set_voltage(fe, SEC_VOLTAGE_18); 846 dvb_frontend_sleep_until(&nexttime, 32000); 847 848 for (i = 0; i < 9; i++) { 849 if (dvb_frontend_debug) 850 do_gettimeofday(&tv[i + 1]); 851 if ((cmd & 0x01) != last) { 852 /* set voltage to (last ? 13V : 18V) */ 853 fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18); 854 last = (last) ? 0 : 1; 855 } 856 cmd = cmd >> 1; 857 if (i != 8) 858 dvb_frontend_sleep_until(&nexttime, 8000); 859 } 860 if (dvb_frontend_debug) { 861 printk("%s(%d): switch delay (should be 32k followed by all 8k\n", 862 __FUNCTION__, fe->dvb->num); 863 for (i = 1; i < 10; i++) 864 printk("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i])); 865 } 866 err = 0; 867 fepriv->state = FESTATE_DISEQC; 868 fepriv->status = 0; 869 } 870 break; 871 872 case FE_DISEQC_RECV_SLAVE_REPLY: 873 if (fe->ops.diseqc_recv_slave_reply) 874 err = fe->ops.diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg); 875 break; 876 877 case FE_ENABLE_HIGH_LNB_VOLTAGE: 878 if (fe->ops.enable_high_lnb_voltage) 879 err = fe->ops.enable_high_lnb_voltage(fe, (long) parg); 880 break; 881 882 case FE_SET_FRONTEND: { 883 struct dvb_frontend_tune_settings fetunesettings; 884 885 memcpy (&fepriv->parameters, parg, 886 sizeof (struct dvb_frontend_parameters)); 887 888 memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings)); 889 memcpy(&fetunesettings.parameters, parg, 890 sizeof (struct dvb_frontend_parameters)); 891 892 /* force auto frequency inversion if requested */ 893 if (dvb_force_auto_inversion) { 894 fepriv->parameters.inversion = INVERSION_AUTO; 895 fetunesettings.parameters.inversion = INVERSION_AUTO; 896 } 897 if (fe->ops.info.type == FE_OFDM) { 898 /* without hierarchical coding code_rate_LP is irrelevant, 899 * so we tolerate the otherwise invalid FEC_NONE setting */ 900 if (fepriv->parameters.u.ofdm.hierarchy_information == HIERARCHY_NONE && 901 fepriv->parameters.u.ofdm.code_rate_LP == FEC_NONE) 902 fepriv->parameters.u.ofdm.code_rate_LP = FEC_AUTO; 903 } 904 905 /* get frontend-specific tuning settings */ 906 if (fe->ops.get_tune_settings && (fe->ops.get_tune_settings(fe, &fetunesettings) == 0)) { 907 fepriv->min_delay = (fetunesettings.min_delay_ms * HZ) / 1000; 908 fepriv->max_drift = fetunesettings.max_drift; 909 fepriv->step_size = fetunesettings.step_size; 910 } else { 911 /* default values */ 912 switch(fe->ops.info.type) { 913 case FE_QPSK: 914 fepriv->min_delay = HZ/20; 915 fepriv->step_size = fepriv->parameters.u.qpsk.symbol_rate / 16000; 916 fepriv->max_drift = fepriv->parameters.u.qpsk.symbol_rate / 2000; 917 break; 918 919 case FE_QAM: 920 fepriv->min_delay = HZ/20; 921 fepriv->step_size = 0; /* no zigzag */ 922 fepriv->max_drift = 0; 923 break; 924 925 case FE_OFDM: 926 fepriv->min_delay = HZ/20; 927 fepriv->step_size = fe->ops.info.frequency_stepsize * 2; 928 fepriv->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1; 929 break; 930 case FE_ATSC: 931 fepriv->min_delay = HZ/20; 932 fepriv->step_size = 0; 933 fepriv->max_drift = 0; 934 break; 935 } 936 } 937 if (dvb_override_tune_delay > 0) 938 fepriv->min_delay = (dvb_override_tune_delay * HZ) / 1000; 939 940 fepriv->state = FESTATE_RETUNE; 941 dvb_frontend_wakeup(fe); 942 dvb_frontend_add_event(fe, 0); 943 fepriv->status = 0; 944 err = 0; 945 break; 946 } 947 948 case FE_GET_EVENT: 949 err = dvb_frontend_get_event (fe, parg, file->f_flags); 950 break; 951 952 case FE_GET_FRONTEND: 953 if (fe->ops.get_frontend) { 954 memcpy (parg, &fepriv->parameters, sizeof (struct dvb_frontend_parameters)); 955 err = fe->ops.get_frontend(fe, (struct dvb_frontend_parameters*) parg); 956 } 957 break; 958 959 case FE_SET_FRONTEND_TUNE_MODE: 960 fepriv->tune_mode_flags = (unsigned long) parg; 961 err = 0; 962 break; 963 }; 964 965 up (&fepriv->sem); 966 return err; 967} 968 969static unsigned int dvb_frontend_poll(struct file *file, struct poll_table_struct *wait) 970{ 971 struct dvb_device *dvbdev = file->private_data; 972 struct dvb_frontend *fe = dvbdev->priv; 973 struct dvb_frontend_private *fepriv = fe->frontend_priv; 974 975 dprintk ("%s\n", __FUNCTION__); 976 977 poll_wait (file, &fepriv->events.wait_queue, wait); 978 979 if (fepriv->events.eventw != fepriv->events.eventr) 980 return (POLLIN | POLLRDNORM | POLLPRI); 981 982 return 0; 983} 984 985static int dvb_frontend_open(struct inode *inode, struct file *file) 986{ 987 struct dvb_device *dvbdev = file->private_data; 988 struct dvb_frontend *fe = dvbdev->priv; 989 struct dvb_frontend_private *fepriv = fe->frontend_priv; 990 int ret; 991 992 dprintk ("%s\n", __FUNCTION__); 993 994 if ((ret = dvb_generic_open (inode, file)) < 0) 995 return ret; 996 997 if (fe->ops.ts_bus_ctrl) { 998 if ((ret = fe->ops.ts_bus_ctrl (fe, 1)) < 0) { 999 dvb_generic_release (inode, file); 1000 return ret; 1001 } 1002 } 1003 1004 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 1005 1006 /* normal tune mode when opened R/W */ 1007 fepriv->tune_mode_flags &= ~FE_TUNE_MODE_ONESHOT; 1008 fepriv->tone = -1; 1009 fepriv->voltage = -1; 1010 1011 ret = dvb_frontend_start (fe); 1012 if (ret) 1013 dvb_generic_release (inode, file); 1014 1015 /* empty event queue */ 1016 fepriv->events.eventr = fepriv->events.eventw = 0; 1017 } 1018 1019 return ret; 1020} 1021 1022static int dvb_frontend_release(struct inode *inode, struct file *file) 1023{ 1024 struct dvb_device *dvbdev = file->private_data; 1025 struct dvb_frontend *fe = dvbdev->priv; 1026 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1027 int ret; 1028 1029 dprintk ("%s\n", __FUNCTION__); 1030 1031 if ((file->f_flags & O_ACCMODE) != O_RDONLY) 1032 fepriv->release_jiffies = jiffies; 1033 1034 if (fe->ops.ts_bus_ctrl) 1035 fe->ops.ts_bus_ctrl (fe, 0); 1036 1037 ret = dvb_generic_release (inode, file); 1038 1039 if (dvbdev->users==-1 && fepriv->exit==1) { 1040 fops_put(file->f_op); 1041 file->f_op = NULL; 1042 wake_up(&dvbdev->wait_queue); 1043 } 1044 return ret; 1045} 1046 1047static struct file_operations dvb_frontend_fops = { 1048 .owner = THIS_MODULE, 1049 .ioctl = dvb_generic_ioctl, 1050 .poll = dvb_frontend_poll, 1051 .open = dvb_frontend_open, 1052 .release = dvb_frontend_release 1053}; 1054 1055int dvb_register_frontend(struct dvb_adapter* dvb, 1056 struct dvb_frontend* fe) 1057{ 1058 struct dvb_frontend_private *fepriv; 1059 static const struct dvb_device dvbdev_template = { 1060 .users = ~0, 1061 .writers = 1, 1062 .readers = (~0)-1, 1063 .fops = &dvb_frontend_fops, 1064 .kernel_ioctl = dvb_frontend_ioctl 1065 }; 1066 1067 dprintk ("%s\n", __FUNCTION__); 1068 1069 if (mutex_lock_interruptible(&frontend_mutex)) 1070 return -ERESTARTSYS; 1071 1072 fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL); 1073 if (fe->frontend_priv == NULL) { 1074 mutex_unlock(&frontend_mutex); 1075 return -ENOMEM; 1076 } 1077 fepriv = fe->frontend_priv; 1078 1079 init_MUTEX (&fepriv->sem); 1080 init_waitqueue_head (&fepriv->wait_queue); 1081 init_waitqueue_head (&fepriv->events.wait_queue); 1082 init_MUTEX (&fepriv->events.sem); 1083 fe->dvb = dvb; 1084 fepriv->inversion = INVERSION_OFF; 1085 1086 printk ("DVB: registering frontend %i (%s)...\n", 1087 fe->dvb->num, 1088 fe->ops.info.name); 1089 1090 dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template, 1091 fe, DVB_DEVICE_FRONTEND); 1092 1093 mutex_unlock(&frontend_mutex); 1094 return 0; 1095} 1096EXPORT_SYMBOL(dvb_register_frontend); 1097 1098int dvb_unregister_frontend(struct dvb_frontend* fe) 1099{ 1100 struct dvb_frontend_private *fepriv = fe->frontend_priv; 1101 dprintk ("%s\n", __FUNCTION__); 1102 1103 mutex_lock(&frontend_mutex); 1104 dvb_frontend_stop (fe); 1105 mutex_unlock(&frontend_mutex); 1106 1107 if (fepriv->dvbdev->users < -1) 1108 wait_event(fepriv->dvbdev->wait_queue, 1109 fepriv->dvbdev->users==-1); 1110 1111 mutex_lock(&frontend_mutex); 1112 dvb_unregister_device (fepriv->dvbdev); 1113 1114 /* fe is invalid now */ 1115 kfree(fepriv); 1116 mutex_unlock(&frontend_mutex); 1117 return 0; 1118} 1119EXPORT_SYMBOL(dvb_unregister_frontend); 1120 1121#ifdef CONFIG_DVB_CORE_ATTACH 1122void dvb_frontend_detach(struct dvb_frontend* fe) 1123{ 1124 void *ptr; 1125 1126 if (fe->ops.release_sec) { 1127 fe->ops.release_sec(fe); 1128 symbol_put_addr(fe->ops.release_sec); 1129 } 1130 if (fe->ops.tuner_ops.release) { 1131 fe->ops.tuner_ops.release(fe); 1132 symbol_put_addr(fe->ops.tuner_ops.release); 1133 } 1134 ptr = (void*)fe->ops.release; 1135 if (ptr) { 1136 fe->ops.release(fe); 1137 symbol_put_addr(ptr); 1138 } 1139} 1140#else 1141void dvb_frontend_detach(struct dvb_frontend* fe) 1142{ 1143 if (fe->ops.release_sec) 1144 fe->ops.release_sec(fe); 1145 if (fe->ops.tuner_ops.release) 1146 fe->ops.tuner_ops.release(fe); 1147 if (fe->ops.release) 1148 fe->ops.release(fe); 1149} 1150#endif 1151EXPORT_SYMBOL(dvb_frontend_detach); 1152