drivers/media/dvb/dvb-core/dvb_frontend.c

   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/suspend.h>
  38 #include <asm/processor.h>
  39 #include <asm/semaphore.h>
  40
  41 #include "dvb_frontend.h"
  42 #include "dvbdev.h"
  43
  44 static int dvb_frontend_debug;
  45 static int dvb_shutdown_timeout = 5;
  46 static int dvb_force_auto_inversion;
  47 static int dvb_override_tune_delay;
  48 static int dvb_powerdown_on_sleep = 1;
  49
  50 module_param_named(frontend_debug, dvb_frontend_debug, int, 0644);
  51 MODULE_PARM_DESC(dvb_frontend_debug, "Turn on/off frontend core debugging (default:off).");
  52 module_param(dvb_shutdown_timeout, int, 0444);
  53 MODULE_PARM_DESC(dvb_shutdown_timeout, "wait <shutdown_timeout> seconds after close() before suspending hardware");
  54 module_param(dvb_force_auto_inversion, int, 0444);
  55 MODULE_PARM_DESC(dvb_force_auto_inversion, "0: normal (default), 1: INVERSION_AUTO forced always");
  56 module_param(dvb_override_tune_delay, int, 0444);
  57 MODULE_PARM_DESC(dvb_override_tune_delay, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt");
  58 module_param(dvb_powerdown_on_sleep, int, 0444);
  59 MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB volatage 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  * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling.
  77  * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune.
  78  * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress.
  79  * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower.
  80  * FESTATE_TUNED. The frontend has successfully locked on.
  81  * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it.
  82  * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower.
  83  * FESTATE_DISEQC. A DISEQC command has just been issued.
  84  * FESTATE_WAITFORLOCK. When we're waiting for a lock.
  85  * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan.
  86  * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan.
  87  * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again.
  88  */
  89
  90 static DECLARE_MUTEX(frontend_mutex);
  91
  92 static void dvb_frontend_add_event(struct dvb_frontend *fe, fe_status_t status)
  93 {
  94         struct dvb_fe_events *events = &fe->events;
  95         struct dvb_frontend_event *e;
  96         int wp;
  97
  98         dprintk ("%s\n", __FUNCTION__);
  99
 100         if (down_interruptible (&events->sem))
 101                 return;
 102
 103         wp = (events->eventw + 1) % MAX_EVENT;
 104
 105         if (wp == events->eventr) {
 106                 events->overflow = 1;
 107                 events->eventr = (events->eventr + 1) % MAX_EVENT;
 108         }
 109
 110         e = &events->events[events->eventw];
 111
 112         memcpy (&e->parameters, &fe->parameters,
 113                 sizeof (struct dvb_frontend_parameters));
 114
 115         if (status & FE_HAS_LOCK)
 116                 if (fe->ops->get_frontend)
 117                         fe->ops->get_frontend(fe, &e->parameters);
 118
 119         events->eventw = wp;
 120
 121         up (&events->sem);
 122
 123         e->status = status;
 124
 125         wake_up_interruptible (&events->wait_queue);
 126 }
 127
 128 static int dvb_frontend_get_event(struct dvb_frontend *fe,
 129                             struct dvb_frontend_event *event, int flags)
 130 {
 131         struct dvb_fe_events *events = &fe->events;
 132
 133         dprintk ("%s\n", __FUNCTION__);
 134
 135         if (events->overflow) {
 136                 events->overflow = 0;
 137                 return -EOVERFLOW;
 138         }
 139
 140         if (events->eventw == events->eventr) {
 141                 int ret;
 142
 143                 if (flags & O_NONBLOCK)
 144                         return -EWOULDBLOCK;
 145
 146                 up(&fe->sem);
 147
 148                 ret = wait_event_interruptible (events->wait_queue,
 149                                                 events->eventw != events->eventr);
 150
 151                 if (down_interruptible (&fe->sem))
 152                         return -ERESTARTSYS;
 153
 154                 if (ret < 0)
 155                         return ret;
 156         }
 157
 158         if (down_interruptible (&events->sem))
 159                 return -ERESTARTSYS;
 160
 161         memcpy (event, &events->events[events->eventr],
 162                 sizeof(struct dvb_frontend_event));
 163
 164         events->eventr = (events->eventr + 1) % MAX_EVENT;
 165
 166         up (&events->sem);
 167
 168         return 0;
 169 }
 170
 171 static void dvb_frontend_init(struct dvb_frontend *fe)
 172 {
 173         dprintk ("DVB: initialising frontend %i (%s)...\n",
 174                  fe->dvb->num,
 175                  fe->ops->info.name);
 176
 177         if (fe->ops->init)
 178                 fe->ops->init(fe);
 179 }
 180
 181 static void update_delay (int *quality, int *delay, int min_delay, int locked)
 182 {
 183         int q2;
 184
 185         dprintk ("%s\n", __FUNCTION__);
 186
 187         if (locked)
 188                 (*quality) = (*quality * 220 + 36*256) / 256;
 189         else
 190                 (*quality) = (*quality * 220 + 0) / 256;
 191
 192         q2 = *quality - 128;
 193         q2 *= q2;
 194
 195             *delay = min_delay + q2 * HZ / (128*128);
 196 }
 197
 198 /**
 199  * Performs automatic twiddling of frontend parameters.
 200  *
 201  * @param fe The frontend concerned.
 202  * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT
 203  * @returns Number of complete iterations that have been performed.
 204  */
 205 static int dvb_frontend_autotune(struct dvb_frontend *fe, int check_wrapped)
 206 {
 207         int autoinversion;
 208         int ready = 0;
 209         int original_inversion = fe->parameters.inversion;
 210         u32 original_frequency = fe->parameters.frequency;
 211
 212         /* are we using autoinversion? */
 213         autoinversion = ((!(fe->ops->info.caps & FE_CAN_INVERSION_AUTO)) &&
 214                          (fe->parameters.inversion == INVERSION_AUTO));
 215
 216         /* setup parameters correctly */
 217         while(!ready) {
 218                 /* calculate the lnb_drift */
 219                 fe->lnb_drift = fe->auto_step * fe->step_size;
 220
 221                 /* wrap the auto_step if we've exceeded the maximum drift */
 222                 if (fe->lnb_drift > fe->max_drift) {
 223                         fe->auto_step = 0;
 224                         fe->auto_sub_step = 0;
 225                         fe->lnb_drift = 0;
 226                 }
 227
 228                 /* perform inversion and +/- zigzag */
 229                 switch(fe->auto_sub_step) {
 230                 case 0:
 231                         /* try with the current inversion and current drift setting */
 232                         ready = 1;
 233                         break;
 234
 235                 case 1:
 236                         if (!autoinversion) break;
 237
 238                         fe->inversion = (fe->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF;
 239                         ready = 1;
 240                         break;
 241
 242                 case 2:
 243                         if (fe->lnb_drift == 0) break;
 244
 245                         fe->lnb_drift = -fe->lnb_drift;
 246                         ready = 1;
 247                         break;
 248
 249                 case 3:
 250                         if (fe->lnb_drift == 0) break;
 251                         if (!autoinversion) break;
 252
 253                         fe->inversion = (fe->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF;
 254                         fe->lnb_drift = -fe->lnb_drift;
 255                         ready = 1;
 256                         break;
 257
 258                 default:
 259                         fe->auto_step++;
 260                         fe->auto_sub_step = -1; /* it'll be incremented to 0 in a moment */
 261                         break;
 262                 }
 263
 264                 if (!ready) fe->auto_sub_step++;
 265         }
 266
 267         /* if this attempt would hit where we started, indicate a complete
 268          * iteration has occurred */
 269         if ((fe->auto_step == fe->started_auto_step) &&
 270             (fe->auto_sub_step == 0) && check_wrapped) {
 271                 return 1;
 272                 }
 273
 274         dprintk("%s: drift:%i inversion:%i auto_step:%i "
 275                 "auto_sub_step:%i started_auto_step:%i\n",
 276                 __FUNCTION__, fe->lnb_drift, fe->inversion,
 277                 fe->auto_step, fe->auto_sub_step, fe->started_auto_step);
 278
 279         /* set the frontend itself */
 280         fe->parameters.frequency += fe->lnb_drift;
 281         if (autoinversion)
 282                 fe->parameters.inversion = fe->inversion;
 283         if (fe->ops->set_frontend)
 284                 fe->ops->set_frontend(fe, &fe->parameters);
 285
 286         fe->parameters.frequency = original_frequency;
 287         fe->parameters.inversion = original_inversion;
 288
 289         fe->auto_sub_step++;
 290         return 0;
 291 }
 292
 293 static int dvb_frontend_is_exiting(struct dvb_frontend *fe)
 294 {
 295         if (fe->exit)
 296                 return 1;
 297
 298         if (fe->dvbdev->writers == 1)
 299                 if (jiffies - fe->release_jiffies > dvb_shutdown_timeout * HZ)
 300                         return 1;
 301
 302         return 0;
 303 }
 304
 305 static int dvb_frontend_should_wakeup(struct dvb_frontend *fe)
 306 {
 307         if (fe->wakeup) {
 308                 fe->wakeup = 0;
 309                 return 1;
 310         }
 311         return dvb_frontend_is_exiting(fe);
 312 }
 313
 314 static void dvb_frontend_wakeup(struct dvb_frontend *fe)
 315 {
 316         fe->wakeup = 1;
 317         wake_up_interruptible(&fe->wait_queue);
 318 }
 319
 320 /*
 321  * FIXME: use linux/kthread.h
 322  */
 323 static int dvb_frontend_thread (void *data)
 324 {
 325         struct dvb_frontend *fe = (struct dvb_frontend *) data;
 326         unsigned long timeout;
 327         char name [15];
 328         int quality = 0, delay = 3*HZ;
 329         fe_status_t s;
 330         int check_wrapped = 0;
 331
 332         dprintk ("%s\n", __FUNCTION__);
 333
 334         snprintf (name, sizeof(name), "kdvb-fe-%i", fe->dvb->num);
 335
 336         lock_kernel ();
 337         daemonize (name);
 338         sigfillset (&current->blocked);
 339         unlock_kernel ();
 340
 341         fe->status = 0;
 342         dvb_frontend_init (fe);
 343         fe->wakeup = 0;
 344
 345         while (1) {
 346                 up (&fe->sem);      /* is locked when we enter the thread... */
 347
 348                 timeout = wait_event_interruptible_timeout(fe->wait_queue,
 349                                                            dvb_frontend_should_wakeup(fe),
 350                                                            delay);
 351                 if (0 != dvb_frontend_is_exiting (fe)) {
 352                         /* got signal or quitting */
 353                         break;
 354                 }
 355
 356                 if (current->flags & PF_FREEZE)
 357                         refrigerator(PF_FREEZE);
 358
 359                 if (down_interruptible (&fe->sem))
 360                         break;
 361
 362                 /* if we've got no parameters, just keep idling */
 363                 if (fe->state & FESTATE_IDLE) {
 364                         delay = 3*HZ;
 365                         quality = 0;
 366                         continue;
 367                 }
 368
 369 retune:
 370                 /* get the frontend status */
 371                 if (fe->state & FESTATE_RETUNE) {
 372                         s = 0;
 373                 } else {
 374                         if (fe->ops->read_status)
 375                                 fe->ops->read_status(fe, &s);
 376                         if (s != fe->status) {
 377                         dvb_frontend_add_event (fe, s);
 378                                 fe->status = s;
 379                         }
 380                 }
 381                 /* if we're not tuned, and we have a lock, move to the TUNED state */
 382                 if ((fe->state & FESTATE_WAITFORLOCK) && (s & FE_HAS_LOCK)) {
 383                         update_delay(&quality, &delay, fe->min_delay, s & FE_HAS_LOCK);
 384                         fe->state = FESTATE_TUNED;
 385
 386                         /* if we're tuned, then we have determined the correct inversion */
 387                         if ((!(fe->ops->info.caps & FE_CAN_INVERSION_AUTO)) &&
 388                             (fe->parameters.inversion == INVERSION_AUTO)) {
 389                                 fe->parameters.inversion = fe->inversion;
 390                         }
 391                         continue;
 392                 }
 393
 394                 /* if we are tuned already, check we're still locked */
 395                 if (fe->state & FESTATE_TUNED) {
 396                         update_delay(&quality, &delay, fe->min_delay, s & FE_HAS_LOCK);
 397
 398                         /* we're tuned, and the lock is still good... */
 399                         if (s & FE_HAS_LOCK)
 400                                 continue;
 401                         else {
 402                                 /* if we _WERE_ tuned, but now don't have a lock,
 403                                  * need to zigzag */
 404                                 fe->state = FESTATE_ZIGZAG_FAST;
 405                                 fe->started_auto_step = fe->auto_step;
 406                                 check_wrapped = 0;
 407                         }
 408                 }
 409
 410                 /* don't actually do anything if we're in the LOSTLOCK state,
 411                  * the frontend is set to FE_CAN_RECOVER, and the max_drift is 0 */
 412                 if ((fe->state & FESTATE_LOSTLOCK) &&
 413                     (fe->ops->info.caps & FE_CAN_RECOVER) && (fe->max_drift == 0)) {
 414                         update_delay(&quality, &delay, fe->min_delay, s & FE_HAS_LOCK);
 415                                                 continue;
 416                                 }
 417
 418                 /* don't do anything if we're in the DISEQC state, since this
 419                  * might be someone with a motorized dish controlled by DISEQC.
 420                  * If its actually a re-tune, there will be a SET_FRONTEND soon enough. */
 421                 if (fe->state & FESTATE_DISEQC) {
 422                         update_delay(&quality, &delay, fe->min_delay, s & FE_HAS_LOCK);
 423                         continue;
 424                                 }
 425
 426                 /* if we're in the RETUNE state, set everything up for a brand
 427                  * new scan, keeping the current inversion setting, as the next
 428                  * tune is _very_ likely to require the same */
 429                 if (fe->state & FESTATE_RETUNE) {
 430                         fe->lnb_drift = 0;
 431                         fe->auto_step = 0;
 432                         fe->auto_sub_step = 0;
 433                         fe->started_auto_step = 0;
 434                         check_wrapped = 0;
 435                 }
 436
 437                 /* fast zigzag. */
 438                 if ((fe->state & FESTATE_SEARCHING_FAST) || (fe->state & FESTATE_RETUNE)) {
 439                         delay = fe->min_delay;
 440
 441                         /* peform a tune */
 442                         if (dvb_frontend_autotune(fe, check_wrapped)) {
 443                                 /* OK, if we've run out of trials at the fast speed.
 444                                  * Drop back to slow for the _next_ attempt */
 445                                 fe->state = FESTATE_SEARCHING_SLOW;
 446                                 fe->started_auto_step = fe->auto_step;
 447                                 continue;
 448                         }
 449                         check_wrapped = 1;
 450
 451                         /* if we've just retuned, enter the ZIGZAG_FAST state.
 452                          * This ensures we cannot return from an
 453                          * FE_SET_FRONTEND ioctl before the first frontend tune
 454                          * occurs */
 455                         if (fe->state & FESTATE_RETUNE) {
 456                                 fe->state = FESTATE_TUNING_FAST;
 457                                 goto retune;
 458                         }
 459                 }
 460
 461                 /* slow zigzag */
 462                 if (fe->state & FESTATE_SEARCHING_SLOW) {
 463                         update_delay(&quality, &delay, fe->min_delay, s & FE_HAS_LOCK);
 464
 465                         /* Note: don't bother checking for wrapping; we stay in this
 466                          * state until we get a lock */
 467                         dvb_frontend_autotune(fe, 0);
 468                 }
 469         }
 470
 471         if (dvb_shutdown_timeout) {
 472                 if (dvb_powerdown_on_sleep)
 473                         if (fe->ops->set_voltage)
 474                                 fe->ops->set_voltage(fe, SEC_VOLTAGE_OFF);
 475                 if (fe->ops->sleep)
 476                         fe->ops->sleep(fe);
 477         }
 478
 479         fe->thread_pid = 0;
 480         mb();
 481
 482         dvb_frontend_wakeup(fe);
 483         return 0;
 484 }
 485
 486 static void dvb_frontend_stop(struct dvb_frontend *fe)
 487 {
 488         unsigned long ret;
 489
 490         dprintk ("%s\n", __FUNCTION__);
 491
 492                 fe->exit = 1;
 493         mb();
 494
 495         if (!fe->thread_pid)
 496                 return;
 497
 498         /* check if the thread is really alive */
 499         if (kill_proc(fe->thread_pid, 0, 1) == -ESRCH) {
 500                 printk("dvb_frontend_stop: thread PID %d already died\n",
 501                                 fe->thread_pid);
 502                 /* make sure the mutex was not held by the thread */
 503                 init_MUTEX (&fe->sem);
 504                 return;
 505         }
 506
 507         /* wake up the frontend thread, so it notices that fe->exit == 1 */
 508         dvb_frontend_wakeup(fe);
 509
 510         /* wait until the frontend thread has exited */
 511         ret = wait_event_interruptible(fe->wait_queue,0 == fe->thread_pid);
 512         if (-ERESTARTSYS != ret) {
 513                 fe->state = FESTATE_IDLE;
 514                 return;
 515         }
 516         fe->state = FESTATE_IDLE;
 517
 518         /* paranoia check in case a signal arrived */
 519         if (fe->thread_pid)
 520                 printk("dvb_frontend_stop: warning: thread PID %d won't exit\n",
 521                                 fe->thread_pid);
 522 }
 523
 524 static int dvb_frontend_start(struct dvb_frontend *fe)
 525 {
 526         int ret;
 527
 528         dprintk ("%s\n", __FUNCTION__);
 529
 530         if (fe->thread_pid) {
 531                 if (!fe->exit)
 532                         return 0;
 533                 else
 534                 dvb_frontend_stop (fe);
 535         }
 536
 537         if (signal_pending(current))
 538                 return -EINTR;
 539         if (down_interruptible (&fe->sem))
 540                 return -EINTR;
 541
 542         fe->state = FESTATE_IDLE;
 543         fe->exit = 0;
 544         fe->thread_pid = 0;
 545         mb();
 546
 547         ret = kernel_thread (dvb_frontend_thread, fe, 0);
 548         if (ret < 0) {
 549                 printk("dvb_frontend_start: failed to start kernel_thread (%d)\n", ret);
 550                 up(&fe->sem);
 551                 return ret;
 552         }
 553         fe->thread_pid = ret;
 554
 555         return 0;
 556 }
 557
 558
 559 static int dvb_frontend_ioctl (struct inode *inode, struct file *file,
 560                         unsigned int cmd, void *parg)
 561 {
 562         struct dvb_device *dvbdev = file->private_data;
 563         struct dvb_frontend *fe = dvbdev->priv;
 564         int err = -EOPNOTSUPP;
 565
 566         dprintk ("%s\n", __FUNCTION__);
 567
 568         if (!fe || fe->exit)
 569                 return -ENODEV;
 570
 571         if ((file->f_flags & O_ACCMODE) == O_RDONLY &&
 572             (_IOC_DIR(cmd) != _IOC_READ || cmd == FE_GET_EVENT ||
 573              cmd == FE_DISEQC_RECV_SLAVE_REPLY))
 574                 return -EPERM;
 575
 576         if (down_interruptible (&fe->sem))
 577                 return -ERESTARTSYS;
 578
 579         switch (cmd) {
 580         case FE_GET_INFO: {
 581                 struct dvb_frontend_info* info = (struct dvb_frontend_info*) parg;
 582                 memcpy(info, &fe->ops->info, sizeof(struct dvb_frontend_info));
 583
 584                 /* Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't
 585                  * do it, it is done for it. */
 586                 info->caps |= FE_CAN_INVERSION_AUTO;
 587                 err = 0;
 588                 break;
 589         }
 590
 591         case FE_READ_STATUS:
 592                 if (fe->ops->read_status)
 593                         err = fe->ops->read_status(fe, (fe_status_t*) parg);
 594                 break;
 595
 596         case FE_READ_BER:
 597                 if (fe->ops->read_ber)
 598                         err = fe->ops->read_ber(fe, (__u32*) parg);
 599                 break;
 600
 601         case FE_READ_SIGNAL_STRENGTH:
 602                 if (fe->ops->read_signal_strength)
 603                         err = fe->ops->read_signal_strength(fe, (__u16*) parg);
 604                 break;
 605
 606         case FE_READ_SNR:
 607                 if (fe->ops->read_snr)
 608                         err = fe->ops->read_snr(fe, (__u16*) parg);
 609                 break;
 610
 611         case FE_READ_UNCORRECTED_BLOCKS:
 612                 if (fe->ops->read_ucblocks)
 613                         err = fe->ops->read_ucblocks(fe, (__u32*) parg);
 614                 break;
 615
 616
 617         case FE_DISEQC_RESET_OVERLOAD:
 618                 if (fe->ops->diseqc_reset_overload) {
 619                         err = fe->ops->diseqc_reset_overload(fe);
 620                         fe->state = FESTATE_DISEQC;
 621                         fe->status = 0;
 622                 }
 623                 break;
 624
 625         case FE_DISEQC_SEND_MASTER_CMD:
 626                 if (fe->ops->diseqc_send_master_cmd) {
 627                         err = fe->ops->diseqc_send_master_cmd(fe, (struct dvb_diseqc_master_cmd*) parg);
 628                         fe->state = FESTATE_DISEQC;
 629                         fe->status = 0;
 630                 }
 631                 break;
 632
 633         case FE_DISEQC_SEND_BURST:
 634                 if (fe->ops->diseqc_send_burst) {
 635                         err = fe->ops->diseqc_send_burst(fe, (fe_sec_mini_cmd_t) parg);
 636                         fe->state = FESTATE_DISEQC;
 637                         fe->status = 0;
 638                 }
 639                 break;
 640
 641         case FE_SET_TONE:
 642                 if (fe->ops->set_tone) {
 643                         err = fe->ops->set_tone(fe, (fe_sec_tone_mode_t) parg);
 644                         fe->state = FESTATE_DISEQC;
 645                         fe->status = 0;
 646                 }
 647                 break;
 648
 649         case FE_SET_VOLTAGE:
 650                 if (fe->ops->set_voltage) {
 651                         err = fe->ops->set_voltage(fe, (fe_sec_voltage_t) parg);
 652                 fe->state = FESTATE_DISEQC;
 653                         fe->status = 0;
 654                 }
 655                 break;
 656
 657         case FE_DISHNETWORK_SEND_LEGACY_CMD:
 658                 if (fe->ops->dishnetwork_send_legacy_command) {
 659                         err = fe->ops->dishnetwork_send_legacy_command(fe, (unsigned int) parg);
 660                         fe->state = FESTATE_DISEQC;
 661                         fe->status = 0;
 662                 }
 663                 break;
 664
 665         case FE_DISEQC_RECV_SLAVE_REPLY:
 666                 if (fe->ops->diseqc_recv_slave_reply)
 667                         err = fe->ops->diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg);
 668                 break;
 669
 670         case FE_ENABLE_HIGH_LNB_VOLTAGE:
 671                 if (fe->ops->enable_high_lnb_voltage);
 672                         err = fe->ops->enable_high_lnb_voltage(fe, (int) parg);
 673                 break;
 674
 675         case FE_SET_FRONTEND: {
 676                 struct dvb_frontend_tune_settings fetunesettings;
 677
 678                 memcpy (&fe->parameters, parg,
 679                         sizeof (struct dvb_frontend_parameters));
 680
 681                 memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings));
 682                 memcpy(&fetunesettings.parameters, parg,
 683                        sizeof (struct dvb_frontend_parameters));
 684
 685                 /* force auto frequency inversion if requested */
 686                 if (dvb_force_auto_inversion) {
 687                         fe->parameters.inversion = INVERSION_AUTO;
 688                         fetunesettings.parameters.inversion = INVERSION_AUTO;
 689                 }
 690                 if (fe->ops->info.type == FE_OFDM) {
 691                         /* without hierachical coding code_rate_LP is irrelevant,
 692                          * so we tolerate the otherwise invalid FEC_NONE setting */
 693                         if (fe->parameters.u.ofdm.hierarchy_information == HIERARCHY_NONE &&
 694                             fe->parameters.u.ofdm.code_rate_LP == FEC_NONE)
 695                                 fe->parameters.u.ofdm.code_rate_LP = FEC_AUTO;
 696                 }
 697
 698                 /* get frontend-specific tuning settings */
 699                 if (fe->ops->get_tune_settings && (fe->ops->get_tune_settings(fe, &fetunesettings) == 0)) {
 700                         fe->min_delay = (fetunesettings.min_delay_ms * HZ) / 1000;
 701                         fe->max_drift = fetunesettings.max_drift;
 702                         fe->step_size = fetunesettings.step_size;
 703                 } else {
 704                         /* default values */
 705                         switch(fe->ops->info.type) {
 706                         case FE_QPSK:
 707                                 fe->min_delay = HZ/20;
 708                                 fe->step_size = fe->parameters.u.qpsk.symbol_rate / 16000;
 709                                 fe->max_drift = fe->parameters.u.qpsk.symbol_rate / 2000;
 710                 break;
 711
 712                         case FE_QAM:
 713                                 fe->min_delay = HZ/20;
 714                                 fe->step_size = 0; /* no zigzag */
 715                                 fe->max_drift = 0;
 716                                 break;
 717
 718                         case FE_OFDM:
 719                                 fe->min_delay = HZ/20;
 720                                 fe->step_size = fe->ops->info.frequency_stepsize * 2;
 721                                 fe->max_drift = (fe->ops->info.frequency_stepsize * 2) + 1;
 722                                 break;
 723                         case FE_ATSC:
 724                                 printk("dvb-core: FE_ATSC not handled yet.\n");
 725                                 break;
 726                         }
 727                 }
 728                 if (dvb_override_tune_delay > 0)
 729                        fe->min_delay = (dvb_override_tune_delay * HZ) / 1000;
 730
 731                 fe->state = FESTATE_RETUNE;
 732                 dvb_frontend_wakeup(fe);
 733                 dvb_frontend_add_event (fe, 0);
 734                 fe->status = 0;
 735                 err = 0;
 736                 break;
 737         }
 738
 739         case FE_GET_EVENT:
 740                 err = dvb_frontend_get_event (fe, parg, file->f_flags);
 741                 break;
 742
 743         case FE_GET_FRONTEND:
 744                 if (fe->ops->get_frontend) {
 745                         memcpy (parg, &fe->parameters, sizeof (struct dvb_frontend_parameters));
 746                         err = fe->ops->get_frontend(fe, (struct dvb_frontend_parameters*) parg);
 747                 }
 748                 break;
 749         };
 750
 751         up (&fe->sem);
 752         return err;
 753 }
 754
 755
 756 static unsigned int dvb_frontend_poll (struct file *file, struct poll_table_struct *wait)
 757 {
 758         struct dvb_device *dvbdev = file->private_data;
 759         struct dvb_frontend *fe = dvbdev->priv;
 760
 761         dprintk ("%s\n", __FUNCTION__);
 762
 763         poll_wait (file, &fe->events.wait_queue, wait);
 764
 765         if (fe->events.eventw != fe->events.eventr)
 766                 return (POLLIN | POLLRDNORM | POLLPRI);
 767
 768         return 0;
 769 }
 770
 771
 772 static int dvb_frontend_open (struct inode *inode, struct file *file)
 773 {
 774         struct dvb_device *dvbdev = file->private_data;
 775         struct dvb_frontend *fe = dvbdev->priv;
 776         int ret;
 777
 778         dprintk ("%s\n", __FUNCTION__);
 779
 780         if ((ret = dvb_generic_open (inode, file)) < 0)
 781                 return ret;
 782
 783         if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
 784                 ret = dvb_frontend_start (fe);
 785                 if (ret)
 786                         dvb_generic_release (inode, file);
 787
 788                 /*  empty event queue */
 789                 fe->events.eventr = fe->events.eventw = 0;
 790         }
 791
 792         return ret;
 793 }
 794
 795
 796 static int dvb_frontend_release (struct inode *inode, struct file *file)
 797 {
 798         struct dvb_device *dvbdev = file->private_data;
 799         struct dvb_frontend *fe = dvbdev->priv;
 800
 801         dprintk ("%s\n", __FUNCTION__);
 802
 803         if ((file->f_flags & O_ACCMODE) != O_RDONLY)
 804                 fe->release_jiffies = jiffies;
 805
 806         return dvb_generic_release (inode, file);
 807 }
 808
 809
 810 static struct file_operations dvb_frontend_fops = {
 811         .owner          = THIS_MODULE,
 812         .ioctl          = dvb_generic_ioctl,
 813         .poll           = dvb_frontend_poll,
 814         .open           = dvb_frontend_open,
 815         .release        = dvb_frontend_release
 816 };
 817
 818 int dvb_register_frontend(struct dvb_adapter* dvb,
 819                           struct dvb_frontend* fe)
 820 {
 821         static const struct dvb_device dvbdev_template = {
 822                 .users = ~0,
 823                 .writers = 1,
 824                 .readers = (~0)-1,
 825                 .fops = &dvb_frontend_fops,
 826                 .kernel_ioctl = dvb_frontend_ioctl
 827         };
 828
 829         dprintk ("%s\n", __FUNCTION__);
 830
 831         if (down_interruptible (&frontend_mutex))
 832                 return -ERESTARTSYS;
 833
 834         init_MUTEX (&fe->sem);
 835         init_waitqueue_head (&fe->wait_queue);
 836         init_waitqueue_head (&fe->events.wait_queue);
 837         init_MUTEX (&fe->events.sem);
 838         fe->events.eventw = fe->events.eventr = 0;
 839         fe->events.overflow = 0;
 840         fe->dvb = dvb;
 841         fe->inversion = INVERSION_OFF;
 842
 843         printk ("DVB: registering frontend %i (%s)...\n",
 844                 fe->dvb->num,
 845                 fe->ops->info.name);
 846
 847         dvb_register_device (fe->dvb, &fe->dvbdev, &dvbdev_template,
 848                              fe, DVB_DEVICE_FRONTEND);
 849
 850         up (&frontend_mutex);
 851         return 0;
 852 }
 853 EXPORT_SYMBOL(dvb_register_frontend);
 854
 855 int dvb_unregister_frontend(struct dvb_frontend* fe)
 856 {
 857         dprintk ("%s\n", __FUNCTION__);
 858
 859         down (&frontend_mutex);
 860                         dvb_unregister_device (fe->dvbdev);
 861                         dvb_frontend_stop (fe);
 862         if (fe->ops->release)
 863                 fe->ops->release(fe);
 864         else
 865                 printk("dvb_frontend: Demodulator (%s) does not have a release callback!\n", fe->ops->info.name);
 866         up (&frontend_mutex);
 867         return 0;
 868 }
 869 EXPORT_SYMBOL(dvb_unregister_frontend);