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