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

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