projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] dvb-core: Don't pass DVBv3 parameters on tune() fops
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / dvb / dvb-core / dvb_frontend.c
CommitLineData
1da177e4
LT		 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>
4c4cb1b1 34#include <linux/semaphore.h>
1da177e4 35#include <linux/module.h>
1da177e4 36#include <linux/list.h>
7dfb7103 37#include <linux/freezer.h>
cc89c229 38#include <linux/jiffies.h>
8eec1429 39#include <linux/kthread.h>
1da177e4 40#include <asm/processor.h>
1da177e4
LT		 41
42#include "dvb_frontend.h"
43#include "dvbdev.h"
eacf8d8d 44#include <linux/dvb/version.h>
1da177e4
LT		 45
46static int dvb_frontend_debug;
849be2cd 47static int dvb_shutdown_timeout;
1da177e4
LT		 48static int dvb_force_auto_inversion;
49static int dvb_override_tune_delay;
50static int dvb_powerdown_on_sleep = 1;
59b1842d 51static int dvb_mfe_wait_time = 5;
1da177e4
LT		 52
53module_param_named(frontend_debug, dvb_frontend_debug, int, 0644);
f4f009a7 54MODULE_PARM_DESC(frontend_debug, "Turn on/off frontend core debugging (default:off).");
6baad3f0 55module_param(dvb_shutdown_timeout, int, 0644);
1da177e4 56MODULE_PARM_DESC(dvb_shutdown_timeout, "wait <shutdown_timeout> seconds after close() before suspending hardware");
6baad3f0 57module_param(dvb_force_auto_inversion, int, 0644);
1da177e4 58MODULE_PARM_DESC(dvb_force_auto_inversion, "0: normal (default), 1: INVERSION_AUTO forced always");
6baad3f0 59module_param(dvb_override_tune_delay, int, 0644);
1da177e4 60MODULE_PARM_DESC(dvb_override_tune_delay, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt");
6baad3f0 61module_param(dvb_powerdown_on_sleep, int, 0644);
a8558577 62MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB voltage off on sleep (default)");
59b1842d
DB		 63module_param(dvb_mfe_wait_time, int, 0644);
64MODULE_PARM_DESC(dvb_mfe_wait_time, "Wait up to <mfe_wait_time> seconds on open() for multi-frontend to become available (default:5 seconds)");
1da177e4
LT		 65
66#define dprintk if (dvb_frontend_debug) printk
67
68#define FESTATE_IDLE 1
69#define FESTATE_RETUNE 2
70#define FESTATE_TUNING_FAST 4
71#define FESTATE_TUNING_SLOW 8
72#define FESTATE_TUNED 16
73#define FESTATE_ZIGZAG_FAST 32
74#define FESTATE_ZIGZAG_SLOW 64
75#define FESTATE_DISEQC 128
01886255 76#define FESTATE_ERROR 256
1da177e4
LT		 77#define FESTATE_WAITFORLOCK (FESTATE_TUNING_FAST | FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW | FESTATE_DISEQC)
78#define FESTATE_SEARCHING_FAST (FESTATE_TUNING_FAST | FESTATE_ZIGZAG_FAST)
79#define FESTATE_SEARCHING_SLOW (FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_SLOW)
80#define FESTATE_LOSTLOCK (FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW)
0249ef16
MA		 81
82#define FE_ALGO_HW 1
1da177e4
LT		 83/*
84 * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling.
85 * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune.
86 * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress.
87 * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower.
88 * FESTATE_TUNED. The frontend has successfully locked on.
89 * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it.
90 * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower.
91 * FESTATE_DISEQC. A DISEQC command has just been issued.
92 * FESTATE_WAITFORLOCK. When we're waiting for a lock.
93 * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan.
94 * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan.
95 * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again.
96 */
97
e36309f5
MC		 98#define DVB_FE_NO_EXIT 0
99#define DVB_FE_NORMAL_EXIT 1
100#define DVB_FE_DEVICE_REMOVED 2
101
3593cab5 102static DEFINE_MUTEX(frontend_mutex);
1da177e4
LT		 103
104struct dvb_frontend_private {
105
36cb557a 106 /* thread/frontend values */
1da177e4 107 struct dvb_device *dvbdev;
61cb27af 108 struct dvb_frontend_parameters parameters_in;
a5959dbe 109 struct dvb_frontend_parameters parameters_out;
1da177e4
LT		 110 struct dvb_fe_events events;
111 struct semaphore sem;
112 struct list_head list_head;
113 wait_queue_head_t wait_queue;
8eec1429 114 struct task_struct *thread;
1da177e4 115 unsigned long release_jiffies;
36cb557a
AQ		 116 unsigned int exit;
117 unsigned int wakeup;
1da177e4 118 fe_status_t status;
400b7083 119 unsigned long tune_mode_flags;
36cb557a 120 unsigned int delay;
86f40cc3 121 unsigned int reinitialise;
64454016
AQ		 122 int tone;
123 int voltage;
36cb557a
AQ		 124
125 /* swzigzag values */
126 unsigned int state;
127 unsigned int bending;
128 int lnb_drift;
129 unsigned int inversion;
130 unsigned int auto_step;
131 unsigned int auto_sub_step;
132 unsigned int started_auto_step;
133 unsigned int min_delay;
134 unsigned int max_drift;
135 unsigned int step_size;
136 int quality;
137 unsigned int check_wrapped;
c59e7870 138 enum dvbfe_search algo_status;
1da177e4
LT		 139};
140
86f40cc3 141static void dvb_frontend_wakeup(struct dvb_frontend *fe);
a689e365
MCC		 142static int dtv_get_frontend(struct dvb_frontend *fe,
143 struct dtv_frontend_properties *c,
144 struct dvb_frontend_parameters *p_out);
145
146static bool has_get_frontend(struct dvb_frontend *fe)
147{
b1e9a650 148 return fe->ops.get_frontend;
a689e365 149}
1da177e4
LT		 150
151static void dvb_frontend_add_event(struct dvb_frontend *fe, fe_status_t status)
152{
0c53c70f 153 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4
LT		 154 struct dvb_fe_events *events = &fepriv->events;
155 struct dvb_frontend_event *e;
156 int wp;
157
46b4f7c1 158 dprintk ("%s\n", __func__);
1da177e4 159
a689e365
MCC		 160 if ((status & FE_HAS_LOCK) && has_get_frontend(fe))
161 dtv_get_frontend(fe, NULL, &fepriv->parameters_out);
1da177e4 162
77b1e2fb 163 mutex_lock(&events->mtx);
1da177e4 164
77b1e2fb 165 wp = (events->eventw + 1) % MAX_EVENT;
1da177e4
LT		 166 if (wp == events->eventr) {
167 events->overflow = 1;
168 events->eventr = (events->eventr + 1) % MAX_EVENT;
169 }
170
171 e = &events->events[events->eventw];
77b1e2fb 172 e->status = status;
a5959dbe 173 e->parameters = fepriv->parameters_out;
1da177e4
LT		 174
175 events->eventw = wp;
176
03b76123 177 mutex_unlock(&events->mtx);
1da177e4 178
1da177e4
LT		 179 wake_up_interruptible (&events->wait_queue);
180}
181
182static int dvb_frontend_get_event(struct dvb_frontend *fe,
183 struct dvb_frontend_event *event, int flags)
184{
0c53c70f 185 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4
LT		 186 struct dvb_fe_events *events = &fepriv->events;
187
46b4f7c1 188 dprintk ("%s\n", __func__);
1da177e4
LT		 189
190 if (events->overflow) {
191 events->overflow = 0;
192 return -EOVERFLOW;
193 }
194
195 if (events->eventw == events->eventr) {
196 int ret;
197
198 if (flags & O_NONBLOCK)
199 return -EWOULDBLOCK;
200
201 up(&fepriv->sem);
202
203 ret = wait_event_interruptible (events->wait_queue,
204 events->eventw != events->eventr);
205
206 if (down_interruptible (&fepriv->sem))
207 return -ERESTARTSYS;
208
209 if (ret < 0)
210 return ret;
211 }
212
77b1e2fb
AO		 213 mutex_lock(&events->mtx);
214 *event = events->events[events->eventr];
1da177e4 215 events->eventr = (events->eventr + 1) % MAX_EVENT;
03b76123 216 mutex_unlock(&events->mtx);
1da177e4
LT		 217
218 return 0;
219}
220
20640bea
AO		 221static void dvb_frontend_clear_events(struct dvb_frontend *fe)
222{
223 struct dvb_frontend_private *fepriv = fe->frontend_priv;
224 struct dvb_fe_events *events = &fepriv->events;
225
226 mutex_lock(&events->mtx);
227 events->eventr = events->eventw;
228 mutex_unlock(&events->mtx);
229}
230
1da177e4
LT		 231static void dvb_frontend_init(struct dvb_frontend *fe)
232{
363c35fc 233 dprintk ("DVB: initialising adapter %i frontend %i (%s)...\n",
1da177e4 234 fe->dvb->num,
363c35fc 235 fe->id,
dea74869
PB		 236 fe->ops.info.name);
237
238 if (fe->ops.init)
239 fe->ops.init(fe);
240 if (fe->ops.tuner_ops.init) {
3b37a15c
MA		 241 if (fe->ops.i2c_gate_ctrl)
242 fe->ops.i2c_gate_ctrl(fe, 1);
dea74869
PB		 243 fe->ops.tuner_ops.init(fe);
244 if (fe->ops.i2c_gate_ctrl)
245 fe->ops.i2c_gate_ctrl(fe, 0);
7eef5dd6 246 }
1da177e4
LT		 247}
248
86f40cc3
AQ		 249void dvb_frontend_reinitialise(struct dvb_frontend *fe)
250{
251 struct dvb_frontend_private *fepriv = fe->frontend_priv;
252
253 fepriv->reinitialise = 1;
254 dvb_frontend_wakeup(fe);
255}
256EXPORT_SYMBOL(dvb_frontend_reinitialise);
257
36cb557a 258static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private *fepriv, int locked)
1da177e4 259{
36cb557a 260 int q2;
1da177e4 261
46b4f7c1 262 dprintk ("%s\n", __func__);
1da177e4 263
36cb557a
AQ		 264 if (locked)
265 (fepriv->quality) = (fepriv->quality * 220 + 36*256) / 256;
266 else
267 (fepriv->quality) = (fepriv->quality * 220 + 0) / 256;
1da177e4 268
36cb557a
AQ		 269 q2 = fepriv->quality - 128;
270 q2 *= q2;
1da177e4 271
36cb557a 272 fepriv->delay = fepriv->min_delay + q2 * HZ / (128*128);
1da177e4
LT		 273}
274
275/**
276 * Performs automatic twiddling of frontend parameters.
277 *
278 * @param fe The frontend concerned.
279 * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT
280 * @returns Number of complete iterations that have been performed.
281 */
36cb557a 282static int dvb_frontend_swzigzag_autotune(struct dvb_frontend *fe, int check_wrapped)
1da177e4
LT		 283{
284 int autoinversion;
285 int ready = 0;
01886255 286 int fe_set_err = 0;
0c53c70f 287 struct dvb_frontend_private *fepriv = fe->frontend_priv;
61cb27af
AO		 288 int original_inversion = fepriv->parameters_in.inversion;
289 u32 original_frequency = fepriv->parameters_in.frequency;
1da177e4
LT		 290
291 /* are we using autoinversion? */
dea74869 292 autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) &&
61cb27af 293 (fepriv->parameters_in.inversion == INVERSION_AUTO));
1da177e4
LT		 294
295 /* setup parameters correctly */
296 while(!ready) {
297 /* calculate the lnb_drift */
298 fepriv->lnb_drift = fepriv->auto_step * fepriv->step_size;
299
300 /* wrap the auto_step if we've exceeded the maximum drift */
301 if (fepriv->lnb_drift > fepriv->max_drift) {
302 fepriv->auto_step = 0;
303 fepriv->auto_sub_step = 0;
304 fepriv->lnb_drift = 0;
305 }
306
307 /* perform inversion and +/- zigzag */
308 switch(fepriv->auto_sub_step) {
309 case 0:
310 /* try with the current inversion and current drift setting */
311 ready = 1;
312 break;
313
314 case 1:
315 if (!autoinversion) break;
316
317 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF;
318 ready = 1;
319 break;
320
321 case 2:
322 if (fepriv->lnb_drift == 0) break;
323
324 fepriv->lnb_drift = -fepriv->lnb_drift;
325 ready = 1;
326 break;
327
328 case 3:
329 if (fepriv->lnb_drift == 0) break;
330 if (!autoinversion) break;
331
332 fepriv->inversion = (fepriv->inversion == INVERSION_OFF) ? INVERSION_ON : INVERSION_OFF;
333 fepriv->lnb_drift = -fepriv->lnb_drift;
334 ready = 1;
335 break;
336
337 default:
338 fepriv->auto_step++;
339 fepriv->auto_sub_step = -1; /* it'll be incremented to 0 in a moment */
340 break;
341 }
342
343 if (!ready) fepriv->auto_sub_step++;
344 }
345
346 /* if this attempt would hit where we started, indicate a complete
347 * iteration has occurred */
348 if ((fepriv->auto_step == fepriv->started_auto_step) &&
349 (fepriv->auto_sub_step == 0) && check_wrapped) {
350 return 1;
351 }
352
353 dprintk("%s: drift:%i inversion:%i auto_step:%i "
354 "auto_sub_step:%i started_auto_step:%i\n",
46b4f7c1 355 __func__, fepriv->lnb_drift, fepriv->inversion,
1da177e4
LT		 356 fepriv->auto_step, fepriv->auto_sub_step, fepriv->started_auto_step);
357
358 /* set the frontend itself */
61cb27af 359 fepriv->parameters_in.frequency += fepriv->lnb_drift;
1da177e4 360 if (autoinversion)
61cb27af 361 fepriv->parameters_in.inversion = fepriv->inversion;
dea74869 362 if (fe->ops.set_frontend)
bc9cd273 363 fe_set_err = fe->ops.set_frontend(fe);
a5959dbe 364 fepriv->parameters_out = fepriv->parameters_in;
01886255
JG		 365 if (fe_set_err < 0) {
366 fepriv->state = FESTATE_ERROR;
367 return fe_set_err;
368 }
1da177e4 369
61cb27af
AO		 370 fepriv->parameters_in.frequency = original_frequency;
371 fepriv->parameters_in.inversion = original_inversion;
1da177e4
LT		 372
373 fepriv->auto_sub_step++;
374 return 0;
375}
376
36cb557a
AQ		 377static void dvb_frontend_swzigzag(struct dvb_frontend *fe)
378{
30d9464c 379 fe_status_t s = 0;
01886255 380 int retval = 0;
36cb557a
AQ		 381 struct dvb_frontend_private *fepriv = fe->frontend_priv;
382
383 /* if we've got no parameters, just keep idling */
384 if (fepriv->state & FESTATE_IDLE) {
385 fepriv->delay = 3*HZ;
386 fepriv->quality = 0;
387 return;
388 }
389
390 /* in SCAN mode, we just set the frontend when asked and leave it alone */
391 if (fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT) {
392 if (fepriv->state & FESTATE_RETUNE) {
dea74869 393 if (fe->ops.set_frontend)
bc9cd273 394 retval = fe->ops.set_frontend(fe);
a5959dbe 395 fepriv->parameters_out = fepriv->parameters_in;
01886255
JG		 396 if (retval < 0)
397 fepriv->state = FESTATE_ERROR;
398 else
399 fepriv->state = FESTATE_TUNED;
36cb557a
AQ		 400 }
401 fepriv->delay = 3*HZ;
402 fepriv->quality = 0;
403 return;
404 }
405
406 /* get the frontend status */
407 if (fepriv->state & FESTATE_RETUNE) {
408 s = 0;
409 } else {
dea74869
PB		 410 if (fe->ops.read_status)
411 fe->ops.read_status(fe, &s);
36cb557a
AQ		 412 if (s != fepriv->status) {
413 dvb_frontend_add_event(fe, s);
414 fepriv->status = s;
415 }
416 }
417
418 /* if we're not tuned, and we have a lock, move to the TUNED state */
419 if ((fepriv->state & FESTATE_WAITFORLOCK) && (s & FE_HAS_LOCK)) {
420 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
421 fepriv->state = FESTATE_TUNED;
422
423 /* if we're tuned, then we have determined the correct inversion */
dea74869 424 if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) &&
61cb27af
AO		 425 (fepriv->parameters_in.inversion == INVERSION_AUTO)) {
426 fepriv->parameters_in.inversion = fepriv->inversion;
36cb557a
AQ		 427 }
428 return;
429 }
430
431 /* if we are tuned already, check we're still locked */
432 if (fepriv->state & FESTATE_TUNED) {
433 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
434
435 /* we're tuned, and the lock is still good... */
436 if (s & FE_HAS_LOCK) {
437 return;
438 } else { /* if we _WERE_ tuned, but now don't have a lock */
439 fepriv->state = FESTATE_ZIGZAG_FAST;
440 fepriv->started_auto_step = fepriv->auto_step;
441 fepriv->check_wrapped = 0;
442 }
443 }
444
445 /* don't actually do anything if we're in the LOSTLOCK state,
446 * the frontend is set to FE_CAN_RECOVER, and the max_drift is 0 */
447 if ((fepriv->state & FESTATE_LOSTLOCK) &&
dea74869 448 (fe->ops.info.caps & FE_CAN_RECOVER) && (fepriv->max_drift == 0)) {
36cb557a
AQ		 449 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
450 return;
451 }
452
453 /* don't do anything if we're in the DISEQC state, since this
454 * might be someone with a motorized dish controlled by DISEQC.
455 * If its actually a re-tune, there will be a SET_FRONTEND soon enough. */
456 if (fepriv->state & FESTATE_DISEQC) {
457 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
458 return;
459 }
460
461 /* if we're in the RETUNE state, set everything up for a brand
462 * new scan, keeping the current inversion setting, as the next
463 * tune is _very_ likely to require the same */
464 if (fepriv->state & FESTATE_RETUNE) {
465 fepriv->lnb_drift = 0;
466 fepriv->auto_step = 0;
467 fepriv->auto_sub_step = 0;
468 fepriv->started_auto_step = 0;
469 fepriv->check_wrapped = 0;
470 }
471
472 /* fast zigzag. */
473 if ((fepriv->state & FESTATE_SEARCHING_FAST) || (fepriv->state & FESTATE_RETUNE)) {
474 fepriv->delay = fepriv->min_delay;
475
2030c032 476 /* perform a tune */
01886255
JG		 477 retval = dvb_frontend_swzigzag_autotune(fe,
478 fepriv->check_wrapped);
479 if (retval < 0) {
480 return;
481 } else if (retval) {
36cb557a
AQ		 482 /* OK, if we've run out of trials at the fast speed.
483 * Drop back to slow for the _next_ attempt */
484 fepriv->state = FESTATE_SEARCHING_SLOW;
485 fepriv->started_auto_step = fepriv->auto_step;
486 return;
487 }
488 fepriv->check_wrapped = 1;
489
490 /* if we've just retuned, enter the ZIGZAG_FAST state.
491 * This ensures we cannot return from an
492 * FE_SET_FRONTEND ioctl before the first frontend tune
493 * occurs */
494 if (fepriv->state & FESTATE_RETUNE) {
495 fepriv->state = FESTATE_TUNING_FAST;
496 }
497 }
498
499 /* slow zigzag */
500 if (fepriv->state & FESTATE_SEARCHING_SLOW) {
501 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
502
503 /* Note: don't bother checking for wrapping; we stay in this
504 * state until we get a lock */
505 dvb_frontend_swzigzag_autotune(fe, 0);
506 }
507}
508
1da177e4
LT		 509static int dvb_frontend_is_exiting(struct dvb_frontend *fe)
510{
0c53c70f 511 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4 512
e36309f5 513 if (fepriv->exit != DVB_FE_NO_EXIT)
1da177e4
LT		 514 return 1;
515
516 if (fepriv->dvbdev->writers == 1)
b9d5efcc 517 if (time_after_eq(jiffies, fepriv->release_jiffies +
36cb557a 518 dvb_shutdown_timeout * HZ))
1da177e4
LT		 519 return 1;
520
521 return 0;
522}
523
524static int dvb_frontend_should_wakeup(struct dvb_frontend *fe)
525{
0c53c70f 526 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4
LT		 527
528 if (fepriv->wakeup) {
529 fepriv->wakeup = 0;
530 return 1;
531 }
532 return dvb_frontend_is_exiting(fe);
533}
534
535static void dvb_frontend_wakeup(struct dvb_frontend *fe)
536{
0c53c70f 537 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4
LT		 538
539 fepriv->wakeup = 1;
540 wake_up_interruptible(&fepriv->wait_queue);
541}
542
1da177e4
LT		 543static int dvb_frontend_thread(void *data)
544{
0c53c70f
JS		 545 struct dvb_frontend *fe = data;
546 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4 547 fe_status_t s;
c59e7870
MA		 548 enum dvbfe_algo algo;
549
7e072221 550 bool re_tune = false;
1da177e4 551
46b4f7c1 552 dprintk("%s\n", __func__);
1da177e4 553
36cb557a
AQ		 554 fepriv->check_wrapped = 0;
555 fepriv->quality = 0;
556 fepriv->delay = 3*HZ;
1da177e4 557 fepriv->status = 0;
1da177e4 558 fepriv->wakeup = 0;
04c56d0e
AQ		 559 fepriv->reinitialise = 0;
560
561 dvb_frontend_init(fe);
1da177e4 562
83144186 563 set_freezable();
1da177e4
LT		 564 while (1) {
565 up(&fepriv->sem); /* is locked when we enter the thread... */
6591691b 566restart:
94238e9b 567 wait_event_interruptible_timeout(fepriv->wait_queue,
e42837bc
RW		 568 dvb_frontend_should_wakeup(fe) || kthread_should_stop()
569 || freezing(current),
8eec1429
HP		 570 fepriv->delay);
571
572 if (kthread_should_stop() || dvb_frontend_is_exiting(fe)) {
1da177e4 573 /* got signal or quitting */
e36309f5 574 fepriv->exit = DVB_FE_NORMAL_EXIT;
1da177e4
LT		 575 break;
576 }
577
8eec1429 578 if (try_to_freeze())
6591691b 579 goto restart;
1da177e4
LT		 580
581 if (down_interruptible(&fepriv->sem))
582 break;
583
86f40cc3
AQ		 584 if (fepriv->reinitialise) {
585 dvb_frontend_init(fe);
42f4e774 586 if (fe->ops.set_tone && fepriv->tone != -1)
dea74869 587 fe->ops.set_tone(fe, fepriv->tone);
42f4e774 588 if (fe->ops.set_voltage && fepriv->voltage != -1)
dea74869 589 fe->ops.set_voltage(fe, fepriv->voltage);
86f40cc3
AQ		 590 fepriv->reinitialise = 0;
591 }
592
36cb557a 593 /* do an iteration of the tuning loop */
d772bd03 594 if (fe->ops.get_frontend_algo) {
c59e7870
MA		 595 algo = fe->ops.get_frontend_algo(fe);
596 switch (algo) {
597 case DVBFE_ALGO_HW:
598 dprintk("%s: Frontend ALGO = DVBFE_ALGO_HW\n", __func__);
c59e7870 599
d772bd03 600 if (fepriv->state & FESTATE_RETUNE) {
c59e7870 601 dprintk("%s: Retune requested, FESTATE_RETUNE\n", __func__);
7e072221 602 re_tune = true;
d772bd03
MA		 603 fepriv->state = FESTATE_TUNED;
604 }
605
c59e7870 606 if (fe->ops.tune)
7e072221 607 fe->ops.tune(fe, re_tune, fepriv->tune_mode_flags, &fepriv->delay, &s);
c59e7870 608
2fac9a0f 609 if (s != fepriv->status && !(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT)) {
c59e7870 610 dprintk("%s: state changed, adding current state\n", __func__);
d772bd03
MA		 611 dvb_frontend_add_event(fe, s);
612 fepriv->status = s;
613 }
c59e7870
MA		 614 break;
615 case DVBFE_ALGO_SW:
616 dprintk("%s: Frontend ALGO = DVBFE_ALGO_SW\n", __func__);
70d90635 617 dvb_frontend_swzigzag(fe);
c59e7870
MA		 618 break;
619 case DVBFE_ALGO_CUSTOM:
c59e7870
MA		 620 dprintk("%s: Frontend ALGO = DVBFE_ALGO_CUSTOM, state=%d\n", __func__, fepriv->state);
621 if (fepriv->state & FESTATE_RETUNE) {
622 dprintk("%s: Retune requested, FESTAT_RETUNE\n", __func__);
623 fepriv->state = FESTATE_TUNED;
624 }
625 /* Case where we are going to search for a carrier
626 * User asked us to retune again for some reason, possibly
627 * requesting a search with a new set of parameters
628 */
629 if (fepriv->algo_status & DVBFE_ALGO_SEARCH_AGAIN) {
7bcbdf38 630 if (fe->ops.search) {
61cb27af 631 fepriv->algo_status = fe->ops.search(fe, &fepriv->parameters_in);
c59e7870
MA		 632 /* We did do a search as was requested, the flags are
633 * now unset as well and has the flags wrt to search.
634 */
7bcbdf38
AJ		 635 } else {
636 fepriv->algo_status &= ~DVBFE_ALGO_SEARCH_AGAIN;
637 }
c59e7870
MA		 638 }
639 /* Track the carrier if the search was successful */
640 if (fepriv->algo_status == DVBFE_ALGO_SEARCH_SUCCESS) {
c59e7870 641 if (fe->ops.track)
61cb27af 642 fe->ops.track(fe, &fepriv->parameters_in);
7bcbdf38
AJ		 643 } else {
644 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN;
645 fepriv->delay = HZ / 2;
646 }
a5959dbe 647 fepriv->parameters_out = fepriv->parameters_in;
7bcbdf38
AJ		 648 fe->ops.read_status(fe, &s);
649 if (s != fepriv->status) {
650 dvb_frontend_add_event(fe, s); /* update event list */
651 fepriv->status = s;
652 if (!(s & FE_HAS_LOCK)) {
653 fepriv->delay = HZ / 10;
654 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN;
655 } else {
656 fepriv->delay = 60 * HZ;
657 }
c59e7870
MA		 658 }
659 break;
660 default:
661 dprintk("%s: UNDEFINED ALGO !\n", __func__);
662 break;
663 }
664 } else {
4a4edcca 665 dvb_frontend_swzigzag(fe);
c59e7870 666 }
1da177e4
LT		 667 }
668
608f62d6
OE		 669 if (dvb_powerdown_on_sleep) {
670 if (fe->ops.set_voltage)
671 fe->ops.set_voltage(fe, SEC_VOLTAGE_OFF);
dea74869 672 if (fe->ops.tuner_ops.sleep) {
41286d97
DH		 673 if (fe->ops.i2c_gate_ctrl)
674 fe->ops.i2c_gate_ctrl(fe, 1);
dea74869
PB		 675 fe->ops.tuner_ops.sleep(fe);
676 if (fe->ops.i2c_gate_ctrl)
677 fe->ops.i2c_gate_ctrl(fe, 0);
7eef5dd6 678 }
dea74869
PB		 679 if (fe->ops.sleep)
680 fe->ops.sleep(fe);
1da177e4
LT		 681 }
682
8eec1429 683 fepriv->thread = NULL;
e36309f5
MC		 684 if (kthread_should_stop())
685 fepriv->exit = DVB_FE_DEVICE_REMOVED;
686 else
687 fepriv->exit = DVB_FE_NO_EXIT;
1da177e4
LT		 688 mb();
689
690 dvb_frontend_wakeup(fe);
691 return 0;
692}
693
694static void dvb_frontend_stop(struct dvb_frontend *fe)
695{
0c53c70f 696 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4 697
46b4f7c1 698 dprintk ("%s\n", __func__);
1da177e4 699
e36309f5 700 fepriv->exit = DVB_FE_NORMAL_EXIT;
1da177e4
LT		 701 mb();
702
8eec1429 703 if (!fepriv->thread)
1da177e4
LT		 704 return;
705
8eec1429 706 kthread_stop(fepriv->thread);
ca5be9cd 707
a0a4714c 708 sema_init(&fepriv->sem, 1);
1da177e4
LT		 709 fepriv->state = FESTATE_IDLE;
710
711 /* paranoia check in case a signal arrived */
8eec1429
HP		 712 if (fepriv->thread)
713 printk("dvb_frontend_stop: warning: thread %p won't exit\n",
714 fepriv->thread);
1da177e4
LT		 715}
716
83b75b04
N		 717s32 timeval_usec_diff(struct timeval lasttime, struct timeval curtime)
718{
719 return ((curtime.tv_usec < lasttime.tv_usec) ?
720 1000000 - lasttime.tv_usec + curtime.tv_usec :
721 curtime.tv_usec - lasttime.tv_usec);
722}
723EXPORT_SYMBOL(timeval_usec_diff);
724
725static inline void timeval_usec_add(struct timeval *curtime, u32 add_usec)
726{
727 curtime->tv_usec += add_usec;
728 if (curtime->tv_usec >= 1000000) {
729 curtime->tv_usec -= 1000000;
730 curtime->tv_sec++;
731 }
732}
733
734/*
735 * Sleep until gettimeofday() > waketime + add_usec
736 * This needs to be as precise as possible, but as the delay is
737 * usually between 2ms and 32ms, it is done using a scheduled msleep
738 * followed by usleep (normally a busy-wait loop) for the remainder
739 */
740void dvb_frontend_sleep_until(struct timeval *waketime, u32 add_usec)
741{
742 struct timeval lasttime;
743 s32 delta, newdelta;
744
745 timeval_usec_add(waketime, add_usec);
746
747 do_gettimeofday(&lasttime);
748 delta = timeval_usec_diff(lasttime, *waketime);
749 if (delta > 2500) {
750 msleep((delta - 1500) / 1000);
751 do_gettimeofday(&lasttime);
752 newdelta = timeval_usec_diff(lasttime, *waketime);
753 delta = (newdelta > delta) ? 0 : newdelta;
754 }
755 if (delta > 0)
756 udelay(delta);
757}
758EXPORT_SYMBOL(dvb_frontend_sleep_until);
759
1da177e4
LT		 760static int dvb_frontend_start(struct dvb_frontend *fe)
761{
762 int ret;
0c53c70f 763 struct dvb_frontend_private *fepriv = fe->frontend_priv;
8eec1429 764 struct task_struct *fe_thread;
1da177e4 765
46b4f7c1 766 dprintk ("%s\n", __func__);
1da177e4 767
8eec1429 768 if (fepriv->thread) {
e36309f5 769 if (fepriv->exit == DVB_FE_NO_EXIT)
1da177e4
LT		 770 return 0;
771 else
772 dvb_frontend_stop (fe);
773 }
774
775 if (signal_pending(current))
776 return -EINTR;
777 if (down_interruptible (&fepriv->sem))
778 return -EINTR;
779
780 fepriv->state = FESTATE_IDLE;
e36309f5 781 fepriv->exit = DVB_FE_NO_EXIT;
8eec1429 782 fepriv->thread = NULL;
1da177e4
LT		 783 mb();
784
8eec1429 785 fe_thread = kthread_run(dvb_frontend_thread, fe,
363c35fc 786 "kdvb-ad-%i-fe-%i", fe->dvb->num,fe->id);
8eec1429
HP		 787 if (IS_ERR(fe_thread)) {
788 ret = PTR_ERR(fe_thread);
789 printk("dvb_frontend_start: failed to start kthread (%d)\n", ret);
1da177e4
LT		 790 up(&fepriv->sem);
791 return ret;
792 }
8eec1429 793 fepriv->thread = fe_thread;
1da177e4
LT		 794 return 0;
795}
796
2030c032 797static void dvb_frontend_get_frequency_limits(struct dvb_frontend *fe,
c471b331
OE		 798 u32 *freq_min, u32 *freq_max)
799{
800 *freq_min = max(fe->ops.info.frequency_min, fe->ops.tuner_ops.info.frequency_min);
801
802 if (fe->ops.info.frequency_max == 0)
803 *freq_max = fe->ops.tuner_ops.info.frequency_max;
804 else if (fe->ops.tuner_ops.info.frequency_max == 0)
805 *freq_max = fe->ops.info.frequency_max;
806 else
807 *freq_max = min(fe->ops.info.frequency_max, fe->ops.tuner_ops.info.frequency_max);
808
809 if (*freq_min == 0 || *freq_max == 0)
363c35fc
ST		 810 printk(KERN_WARNING "DVB: adapter %i frontend %u frequency limits undefined - fix the driver\n",
811 fe->dvb->num,fe->id);
c471b331
OE		 812}
813
1fab46f0
OE		 814static int dvb_frontend_check_parameters(struct dvb_frontend *fe,
815 struct dvb_frontend_parameters *parms)
816{
c471b331
OE		 817 u32 freq_min;
818 u32 freq_max;
819
1fab46f0 820 /* range check: frequency */
2030c032 821 dvb_frontend_get_frequency_limits(fe, &freq_min, &freq_max);
c471b331
OE		 822 if ((freq_min && parms->frequency < freq_min) ||
823 (freq_max && parms->frequency > freq_max)) {
363c35fc
ST		 824 printk(KERN_WARNING "DVB: adapter %i frontend %i frequency %u out of range (%u..%u)\n",
825 fe->dvb->num, fe->id, parms->frequency, freq_min, freq_max);
1fab46f0
OE		 826 return -EINVAL;
827 }
828
829 /* range check: symbol rate */
830 if (fe->ops.info.type == FE_QPSK) {
831 if ((fe->ops.info.symbol_rate_min &&
832 parms->u.qpsk.symbol_rate < fe->ops.info.symbol_rate_min) ||
833 (fe->ops.info.symbol_rate_max &&
834 parms->u.qpsk.symbol_rate > fe->ops.info.symbol_rate_max)) {
363c35fc
ST		 835 printk(KERN_WARNING "DVB: adapter %i frontend %i symbol rate %u out of range (%u..%u)\n",
836 fe->dvb->num, fe->id, parms->u.qpsk.symbol_rate,
1fab46f0
OE		 837 fe->ops.info.symbol_rate_min, fe->ops.info.symbol_rate_max);
838 return -EINVAL;
839 }
840
841 } else if (fe->ops.info.type == FE_QAM) {
842 if ((fe->ops.info.symbol_rate_min &&
843 parms->u.qam.symbol_rate < fe->ops.info.symbol_rate_min) ||
844 (fe->ops.info.symbol_rate_max &&
845 parms->u.qam.symbol_rate > fe->ops.info.symbol_rate_max)) {
363c35fc
ST		 846 printk(KERN_WARNING "DVB: adapter %i frontend %i symbol rate %u out of range (%u..%u)\n",
847 fe->dvb->num, fe->id, parms->u.qam.symbol_rate,
1fab46f0
OE		 848 fe->ops.info.symbol_rate_min, fe->ops.info.symbol_rate_max);
849 return -EINVAL;
850 }
851 }
852
f51fad85
JG		 853 /* check for supported modulation */
854 if (fe->ops.info.type == FE_QAM &&
855 (parms->u.qam.modulation > QAM_AUTO ||
856 !((1 << (parms->u.qam.modulation + 10)) & fe->ops.info.caps))) {
857 printk(KERN_WARNING "DVB: adapter %i frontend %i modulation %u not supported\n",
858 fe->dvb->num, fe->id, parms->u.qam.modulation);
859 return -EINVAL;
860 }
861
1fab46f0
OE		 862 return 0;
863}
864
b6e760f3
PB		 865static int dvb_frontend_clear_cache(struct dvb_frontend *fe)
866{
50727719 867 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
b6e760f3
PB		 868 int i;
869
50727719
AO		 870 memset(c, 0, sizeof(struct dtv_frontend_properties));
871
872 c->state = DTV_CLEAR;
873 c->delivery_system = SYS_UNDEFINED;
874 c->inversion = INVERSION_AUTO;
875 c->fec_inner = FEC_AUTO;
876 c->transmission_mode = TRANSMISSION_MODE_AUTO;
877 c->bandwidth_hz = BANDWIDTH_AUTO;
878 c->guard_interval = GUARD_INTERVAL_AUTO;
879 c->hierarchy = HIERARCHY_AUTO;
880 c->symbol_rate = QAM_AUTO;
881 c->code_rate_HP = FEC_AUTO;
882 c->code_rate_LP = FEC_AUTO;
39ce61a8 883 c->rolloff = ROLLOFF_AUTO;
50727719
AO		 884
885 c->isdbt_partial_reception = -1;
886 c->isdbt_sb_mode = -1;
887 c->isdbt_sb_subchannel = -1;
888 c->isdbt_sb_segment_idx = -1;
889 c->isdbt_sb_segment_count = -1;
890 c->isdbt_layer_enabled = 0x7;
b6e760f3 891 for (i = 0; i < 3; i++) {
50727719
AO		 892 c->layer[i].fec = FEC_AUTO;
893 c->layer[i].modulation = QAM_AUTO;
894 c->layer[i].interleaving = -1;
895 c->layer[i].segment_count = -1;
b6e760f3
PB		 896 }
897
898 return 0;
899}
900
901#define _DTV_CMD(n, s, b) \
902[n] = { \
903 .name = #n, \
904 .cmd = n, \
905 .set = s,\
906 .buffer = b \
907}
908
ec05a642 909static struct dtv_cmds_h dtv_cmds[DTV_MAX_COMMAND + 1] = {
06d3a396
MCC		 910 _DTV_CMD(DTV_TUNE, 1, 0),
911 _DTV_CMD(DTV_CLEAR, 1, 0),
6b73eeaf
ST		 912
913 /* Set */
06d3a396
MCC		 914 _DTV_CMD(DTV_FREQUENCY, 1, 0),
915 _DTV_CMD(DTV_BANDWIDTH_HZ, 1, 0),
916 _DTV_CMD(DTV_MODULATION, 1, 0),
917 _DTV_CMD(DTV_INVERSION, 1, 0),
918 _DTV_CMD(DTV_DISEQC_MASTER, 1, 1),
919 _DTV_CMD(DTV_SYMBOL_RATE, 1, 0),
920 _DTV_CMD(DTV_INNER_FEC, 1, 0),
921 _DTV_CMD(DTV_VOLTAGE, 1, 0),
922 _DTV_CMD(DTV_TONE, 1, 0),
923 _DTV_CMD(DTV_PILOT, 1, 0),
924 _DTV_CMD(DTV_ROLLOFF, 1, 0),
925 _DTV_CMD(DTV_DELIVERY_SYSTEM, 1, 0),
926 _DTV_CMD(DTV_HIERARCHY, 1, 0),
927 _DTV_CMD(DTV_CODE_RATE_HP, 1, 0),
928 _DTV_CMD(DTV_CODE_RATE_LP, 1, 0),
929 _DTV_CMD(DTV_GUARD_INTERVAL, 1, 0),
930 _DTV_CMD(DTV_TRANSMISSION_MODE, 1, 0),
b6e760f3
PB		 931
932 _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 1, 0),
933 _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 1, 0),
934 _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 1, 0),
935 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 1, 0),
936 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 1, 0),
e7b7949a 937 _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 1, 0),
b6e760f3
PB		 938 _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 1, 0),
939 _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 1, 0),
940 _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 1, 0),
941 _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 1, 0),
942 _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 1, 0),
943 _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 1, 0),
944 _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 1, 0),
945 _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 1, 0),
946 _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 1, 0),
947 _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 1, 0),
948 _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 1, 0),
949 _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 1, 0),
950
951 _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 0, 0),
952 _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 0, 0),
953 _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 0, 0),
954 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 0, 0),
955 _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 0, 0),
e7b7949a 956 _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 0, 0),
b6e760f3
PB		 957 _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 0, 0),
958 _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 0, 0),
959 _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 0, 0),
960 _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 0, 0),
961 _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 0, 0),
962 _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 0, 0),
963 _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 0, 0),
964 _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 0, 0),
965 _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 0, 0),
966 _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 0, 0),
967 _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 0, 0),
968 _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 0, 0),
969
98293ef3 970 _DTV_CMD(DTV_ISDBS_TS_ID, 1, 0),
ec05a642 971 _DTV_CMD(DTV_DVBT2_PLP_ID, 1, 0),
98293ef3 972
6b73eeaf 973 /* Get */
06d3a396
MCC		 974 _DTV_CMD(DTV_DISEQC_SLAVE_REPLY, 0, 1),
975 _DTV_CMD(DTV_API_VERSION, 0, 0),
976 _DTV_CMD(DTV_CODE_RATE_HP, 0, 0),
977 _DTV_CMD(DTV_CODE_RATE_LP, 0, 0),
978 _DTV_CMD(DTV_GUARD_INTERVAL, 0, 0),
979 _DTV_CMD(DTV_TRANSMISSION_MODE, 0, 0),
980 _DTV_CMD(DTV_HIERARCHY, 0, 0),
ba2780c7
MA		 981
982 _DTV_CMD(DTV_ENUM_DELSYS, 0, 0),
6b73eeaf
ST		 983};
984
072ce0c5 985static void dtv_property_dump(struct dtv_property *tvp)
6b73eeaf
ST		 986{
987 int i;
988
106ff9e0 989 if (tvp->cmd <= 0 || tvp->cmd > DTV_MAX_COMMAND) {
a1bc84c0 990 printk(KERN_WARNING "%s: tvp.cmd = 0x%08x undefined\n",
4aae8efb
DB		 991 __func__, tvp->cmd);
992 return;
993 }
994
a1bc84c0
ST		 995 dprintk("%s() tvp.cmd = 0x%08x (%s)\n"
996 ,__func__
6b73eeaf 997 ,tvp->cmd
56f0680a 998 ,dtv_cmds[ tvp->cmd ].name);
6b73eeaf 999
56f0680a 1000 if(dtv_cmds[ tvp->cmd ].buffer) {
6b73eeaf 1001
a1bc84c0
ST		 1002 dprintk("%s() tvp.u.buffer.len = 0x%02x\n"
1003 ,__func__
6b73eeaf
ST		 1004 ,tvp->u.buffer.len);
1005
1006 for(i = 0; i < tvp->u.buffer.len; i++)
a1bc84c0
ST		 1007 dprintk("%s() tvp.u.buffer.data[0x%02x] = 0x%02x\n"
1008 ,__func__
6b73eeaf
ST		 1009 ,i
1010 ,tvp->u.buffer.data[i]);
1011
1012 } else
a1bc84c0 1013 dprintk("%s() tvp.u.data = 0x%08x\n", __func__, tvp->u.data);
6b73eeaf
ST		 1014}
1015
072ce0c5 1016static int is_legacy_delivery_system(fe_delivery_system_t s)
6b73eeaf 1017{
fd66c45d 1018 if((s == SYS_UNDEFINED) || (s == SYS_DVBC_ANNEX_A) ||
3fa37deb
DH		 1019 (s == SYS_DVBC_ANNEX_B) || (s == SYS_DVBT) || (s == SYS_DVBS) ||
1020 (s == SYS_ATSC))
6b73eeaf
ST		 1021 return 1;
1022
1023 return 0;
1024}
1025
674ce343
AO		 1026/* Initialize the cache with some default values derived from the
1027 * legacy frontend_info structure.
1028 */
1029static void dtv_property_cache_init(struct dvb_frontend *fe,
1030 struct dtv_frontend_properties *c)
1031{
1032 switch (fe->ops.info.type) {
1033 case FE_QPSK:
1034 c->modulation = QPSK; /* implied for DVB-S in legacy API */
1035 c->rolloff = ROLLOFF_35;/* implied for DVB-S */
1036 c->delivery_system = SYS_DVBS;
1037 break;
1038 case FE_QAM:
fd66c45d 1039 c->delivery_system = SYS_DVBC_ANNEX_A;
674ce343
AO		 1040 break;
1041 case FE_OFDM:
1042 c->delivery_system = SYS_DVBT;
1043 break;
1044 case FE_ATSC:
1045 break;
1046 }
1047}
1048
ee33c525
ST		 1049/* Synchronise the legacy tuning parameters into the cache, so that demodulator
1050 * drivers can use a single set_frontend tuning function, regardless of whether
1051 * it's being used for the legacy or new API, reducing code and complexity.
1052 */
072ce0c5 1053static void dtv_property_cache_sync(struct dvb_frontend *fe,
bbe880b4
AO		 1054 struct dtv_frontend_properties *c,
1055 const struct dvb_frontend_parameters *p)
ee33c525 1056{
ee33c525
ST		 1057 c->frequency = p->frequency;
1058 c->inversion = p->inversion;
1059
1060 switch (fe->ops.info.type) {
1061 case FE_QPSK:
1062 c->symbol_rate = p->u.qpsk.symbol_rate;
1063 c->fec_inner = p->u.qpsk.fec_inner;
1064 break;
1065 case FE_QAM:
1066 c->symbol_rate = p->u.qam.symbol_rate;
1067 c->fec_inner = p->u.qam.fec_inner;
1068 c->modulation = p->u.qam.modulation;
1069 break;
1070 case FE_OFDM:
75b7f943
ST		 1071 if (p->u.ofdm.bandwidth == BANDWIDTH_6_MHZ)
1072 c->bandwidth_hz = 6000000;
1073 else if (p->u.ofdm.bandwidth == BANDWIDTH_7_MHZ)
1074 c->bandwidth_hz = 7000000;
1075 else if (p->u.ofdm.bandwidth == BANDWIDTH_8_MHZ)
1076 c->bandwidth_hz = 8000000;
1077 else
1078 /* Including BANDWIDTH_AUTO */
1079 c->bandwidth_hz = 0;
ee33c525
ST		 1080 c->code_rate_HP = p->u.ofdm.code_rate_HP;
1081 c->code_rate_LP = p->u.ofdm.code_rate_LP;
1082 c->modulation = p->u.ofdm.constellation;
1083 c->transmission_mode = p->u.ofdm.transmission_mode;
1084 c->guard_interval = p->u.ofdm.guard_interval;
1085 c->hierarchy = p->u.ofdm.hierarchy_information;
1086 break;
1087 case FE_ATSC:
1088 c->modulation = p->u.vsb.modulation;
80a773c9
ST		 1089 if ((c->modulation == VSB_8) || (c->modulation == VSB_16))
1090 c->delivery_system = SYS_ATSC;
1091 else
1092 c->delivery_system = SYS_DVBC_ANNEX_B;
ee33c525
ST		 1093 break;
1094 }
1095}
1096
d5748f10
ST		 1097/* Ensure the cached values are set correctly in the frontend
1098 * legacy tuning structures, for the advanced tuning API.
1099 */
a689e365
MCC		 1100static void dtv_property_legacy_params_sync(struct dvb_frontend *fe,
1101 struct dvb_frontend_parameters *p)
6b73eeaf 1102{
15cc2bb3 1103 const struct dtv_frontend_properties *c = &fe->dtv_property_cache;
6b73eeaf 1104
d5748f10
ST		 1105 p->frequency = c->frequency;
1106 p->inversion = c->inversion;
6b73eeaf 1107
d5748f10
ST		 1108 switch (fe->ops.info.type) {
1109 case FE_QPSK:
a1bc84c0 1110 dprintk("%s() Preparing QPSK req\n", __func__);
d5748f10
ST		 1111 p->u.qpsk.symbol_rate = c->symbol_rate;
1112 p->u.qpsk.fec_inner = c->fec_inner;
1113 break;
1114 case FE_QAM:
a1bc84c0 1115 dprintk("%s() Preparing QAM req\n", __func__);
d5748f10
ST		 1116 p->u.qam.symbol_rate = c->symbol_rate;
1117 p->u.qam.fec_inner = c->fec_inner;
1118 p->u.qam.modulation = c->modulation;
1119 break;
1120 case FE_OFDM:
a1bc84c0 1121 dprintk("%s() Preparing OFDM req\n", __func__);
75b7f943
ST		 1122 if (c->bandwidth_hz == 6000000)
1123 p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
1124 else if (c->bandwidth_hz == 7000000)
1125 p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
1126 else if (c->bandwidth_hz == 8000000)
1127 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
1128 else
1129 p->u.ofdm.bandwidth = BANDWIDTH_AUTO;
d5748f10
ST		 1130 p->u.ofdm.code_rate_HP = c->code_rate_HP;
1131 p->u.ofdm.code_rate_LP = c->code_rate_LP;
1132 p->u.ofdm.constellation = c->modulation;
1133 p->u.ofdm.transmission_mode = c->transmission_mode;
1134 p->u.ofdm.guard_interval = c->guard_interval;
1135 p->u.ofdm.hierarchy_information = c->hierarchy;
1136 break;
1137 case FE_ATSC:
a1bc84c0 1138 dprintk("%s() Preparing VSB req\n", __func__);
d5748f10
ST		 1139 p->u.vsb.modulation = c->modulation;
1140 break;
1141 }
1142}
1143
1144/* Ensure the cached values are set correctly in the frontend
1145 * legacy tuning structures, for the legacy tuning API.
1146 */
072ce0c5 1147static void dtv_property_adv_params_sync(struct dvb_frontend *fe)
d5748f10 1148{
fd66c45d 1149 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
6b73eeaf 1150 struct dvb_frontend_private *fepriv = fe->frontend_priv;
61cb27af 1151 struct dvb_frontend_parameters *p = &fepriv->parameters_in;
fd66c45d 1152 u32 rolloff = 0;
6b73eeaf 1153
d5748f10
ST		 1154 p->frequency = c->frequency;
1155 p->inversion = c->inversion;
1156
14f55794
AO		 1157 if (c->delivery_system == SYS_DSS ||
1158 c->delivery_system == SYS_DVBS ||
1159 c->delivery_system == SYS_DVBS2 ||
1160 c->delivery_system == SYS_ISDBS ||
1161 c->delivery_system == SYS_TURBO) {
d5748f10
ST		 1162 p->u.qpsk.symbol_rate = c->symbol_rate;
1163 p->u.qpsk.fec_inner = c->fec_inner;
d5748f10
ST		 1164 }
1165
94d56ffa
AO		 1166 /* Fake out a generic DVB-T request so we pass validation in the ioctl */
1167 if ((c->delivery_system == SYS_ISDBT) ||
1168 (c->delivery_system == SYS_DVBT2)) {
d5748f10
ST		 1169 p->u.ofdm.constellation = QAM_AUTO;
1170 p->u.ofdm.code_rate_HP = FEC_AUTO;
1171 p->u.ofdm.code_rate_LP = FEC_AUTO;
d5748f10
ST		 1172 p->u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
1173 p->u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
1174 p->u.ofdm.hierarchy_information = HIERARCHY_AUTO;
b6e760f3
PB		 1175 if (c->bandwidth_hz == 8000000)
1176 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
1177 else if (c->bandwidth_hz == 7000000)
1178 p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
1179 else if (c->bandwidth_hz == 6000000)
1180 p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
1181 else
1182 p->u.ofdm.bandwidth = BANDWIDTH_AUTO;
d5748f10 1183 }
fd66c45d
MCC		 1184
1185 /*
0607d077
MCC		 1186 * Be sure that the bandwidth will be filled for all
1187 * non-satellite systems, as tuners need to know what
1188 * low pass/Nyquist half filter should be applied, in
1189 * order to avoid inter-channel noise.
1190 *
1191 * ISDB-T and DVB-T/T2 already sets bandwidth.
1192 * ATSC and DVB-C don't set, so, the core should fill it.
1193 *
1194 * On DVB-C Annex A and C, the bandwidth is a function of
1195 * the roll-off and symbol rate. Annex B defines different
1196 * roll-off factors depending on the modulation. Fortunately,
1197 * Annex B is only used with 6MHz, so there's no need to
1198 * calculate it.
1199 *
fd66c45d
MCC		 1200 * While not officially supported, a side effect of handling it at
1201 * the cache level is that a program could retrieve the bandwidth
0607d077 1202 * via DTV_BANDWIDTH_HZ, which may be useful for test programs.
fd66c45d 1203 */
0607d077
MCC		 1204 switch (c->delivery_system) {
1205 case SYS_ATSC:
1206 case SYS_DVBC_ANNEX_B:
1207 c->bandwidth_hz = 6000000;
1208 break;
1209 case SYS_DVBC_ANNEX_A:
fd66c45d 1210 rolloff = 115;
0607d077
MCC		 1211 break;
1212 case SYS_DVBC_ANNEX_C:
fd66c45d 1213 rolloff = 113;
0607d077
MCC		 1214 break;
1215 default:
1216 break;
1217 }
fd66c45d
MCC		 1218 if (rolloff)
1219 c->bandwidth_hz = (c->symbol_rate * rolloff) / 100;
d5748f10
ST		 1220}
1221
072ce0c5 1222static void dtv_property_cache_submit(struct dvb_frontend *fe)
d5748f10 1223{
15cc2bb3 1224 const struct dtv_frontend_properties *c = &fe->dtv_property_cache;
a689e365 1225 struct dvb_frontend_private *fepriv = fe->frontend_priv;
d5748f10 1226
d5748f10
ST		 1227 /* For legacy delivery systems we don't need the delivery_system to
1228 * be specified, but we populate the older structures from the cache
1229 * so we can call set_frontend on older drivers.
1230 */
6b73eeaf 1231 if(is_legacy_delivery_system(c->delivery_system)) {
6b73eeaf 1232
a1bc84c0 1233 dprintk("%s() legacy, modulation = %d\n", __func__, c->modulation);
a689e365 1234 dtv_property_legacy_params_sync(fe, &fepriv->parameters_in);
6b73eeaf 1235
6b73eeaf 1236 } else {
a1bc84c0 1237 dprintk("%s() adv, modulation = %d\n", __func__, c->modulation);
d5748f10 1238
6b73eeaf
ST		 1239 /* For advanced delivery systems / modulation types ...
1240 * we seed the lecacy dvb_frontend_parameters structure
1241 * so that the sanity checking code later in the IOCTL processing
1242 * can validate our basic frequency ranges, symbolrates, modulation
1243 * etc.
1244 */
d5748f10 1245 dtv_property_adv_params_sync(fe);
6b73eeaf 1246 }
6b73eeaf
ST		 1247}
1248
a689e365
MCC		 1249/**
1250 * dtv_get_frontend - calls a callback for retrieving DTV parameters
1251 * @fe: struct dvb_frontend pointer
1252 * @c: struct dtv_frontend_properties pointer (DVBv5 cache)
1253 * @p_out struct dvb_frontend_parameters pointer (DVBv3 FE struct)
1254 *
1255 * This routine calls either the DVBv3 or DVBv5 get_frontend call.
1256 * If c is not null, it will update the DVBv5 cache struct pointed by it.
1257 * If p_out is not null, it will update the DVBv3 params pointed by it.
1258 */
1259static int dtv_get_frontend(struct dvb_frontend *fe,
1260 struct dtv_frontend_properties *c,
1261 struct dvb_frontend_parameters *p_out)
1262{
1263 const struct dtv_frontend_properties *cache = &fe->dtv_property_cache;
1264 struct dtv_frontend_properties tmp_cache;
1265 struct dvb_frontend_parameters tmp_out;
a689e365
MCC		 1266 bool fill_params = (p_out != NULL);
1267 int r;
1268
1269 if (!p_out)
1270 p_out = &tmp_out;
1271
1272 if (!c)
1273 c = &tmp_cache;
1274 else
1275 memcpy(c, cache, sizeof(*c));
1276
a689e365
MCC		 1277 if (fe->ops.get_frontend) {
1278 r = fe->ops.get_frontend(fe, c);
1279 if (unlikely(r < 0))
1280 return r;
1281 if (fill_params)
1282 dtv_property_legacy_params_sync(fe, p_out);
1283 return 0;
1284 }
1285
b1e9a650
MCC		 1286 /* As everything is in cache, this is always supported */
1287 return 0;
a689e365
MCC		 1288}
1289
16ef8def 1290static int dvb_frontend_ioctl_legacy(struct file *file,
13c97bf5 1291 unsigned int cmd, void *parg);
16ef8def 1292static int dvb_frontend_ioctl_properties(struct file *file,
13c97bf5
ST		 1293 unsigned int cmd, void *parg);
1294
ba2780c7
MA		 1295static void dtv_set_default_delivery_caps(const struct dvb_frontend *fe, struct dtv_property *p)
1296{
1297 const struct dvb_frontend_info *info = &fe->ops.info;
1298 u32 ncaps = 0;
1299
eeacf147
MCC		 1300 /*
1301 * If the frontend explicitly sets a list, use it, instead of
1302 * filling based on the info->type
1303 */
1304 if (fe->ops.delsys[ncaps]) {
1305 while (fe->ops.delsys[ncaps] && ncaps < MAX_DELSYS) {
1306 p->u.buffer.data[ncaps] = fe->ops.delsys[ncaps];
1307 ncaps++;
1308 }
1309 p->u.buffer.len = ncaps;
1310 return;
1311 }
1312
ba2780c7
MA		 1313 switch (info->type) {
1314 case FE_QPSK:
1315 p->u.buffer.data[ncaps++] = SYS_DVBS;
1316 if (info->caps & FE_CAN_2G_MODULATION)
1317 p->u.buffer.data[ncaps++] = SYS_DVBS2;
1318 if (info->caps & FE_CAN_TURBO_FEC)
1319 p->u.buffer.data[ncaps++] = SYS_TURBO;
1320 break;
1321 case FE_QAM:
0349471b 1322 p->u.buffer.data[ncaps++] = SYS_DVBC_ANNEX_A;
ba2780c7
MA		 1323 break;
1324 case FE_OFDM:
1325 p->u.buffer.data[ncaps++] = SYS_DVBT;
1326 if (info->caps & FE_CAN_2G_MODULATION)
1327 p->u.buffer.data[ncaps++] = SYS_DVBT2;
1328 break;
1329 case FE_ATSC:
1330 if (info->caps & (FE_CAN_8VSB | FE_CAN_16VSB))
1331 p->u.buffer.data[ncaps++] = SYS_ATSC;
1332 if (info->caps & (FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_128 | FE_CAN_QAM_256))
1333 p->u.buffer.data[ncaps++] = SYS_DVBC_ANNEX_B;
1334 break;
1335 }
1336 p->u.buffer.len = ncaps;
1337}
1338
072ce0c5 1339static int dtv_property_process_get(struct dvb_frontend *fe,
a689e365 1340 const struct dtv_frontend_properties *c,
072ce0c5 1341 struct dtv_property *tvp,
16ef8def 1342 struct file *file)
363429a0 1343{
e23d9ae3 1344 int r;
bfbf2dae 1345
363429a0 1346 switch(tvp->cmd) {
ba2780c7
MA		 1347 case DTV_ENUM_DELSYS:
1348 dtv_set_default_delivery_caps(fe, tvp);
1349 break;
363429a0 1350 case DTV_FREQUENCY:
50727719 1351 tvp->u.data = c->frequency;
363429a0
ST		 1352 break;
1353 case DTV_MODULATION:
50727719 1354 tvp->u.data = c->modulation;
363429a0 1355 break;
75b7f943 1356 case DTV_BANDWIDTH_HZ:
50727719 1357 tvp->u.data = c->bandwidth_hz;
363429a0
ST		 1358 break;
1359 case DTV_INVERSION:
50727719 1360 tvp->u.data = c->inversion;
363429a0
ST		 1361 break;
1362 case DTV_SYMBOL_RATE:
50727719 1363 tvp->u.data = c->symbol_rate;
363429a0
ST		 1364 break;
1365 case DTV_INNER_FEC:
50727719 1366 tvp->u.data = c->fec_inner;
363429a0
ST		 1367 break;
1368 case DTV_PILOT:
50727719 1369 tvp->u.data = c->pilot;
363429a0
ST		 1370 break;
1371 case DTV_ROLLOFF:
50727719 1372 tvp->u.data = c->rolloff;
363429a0
ST		 1373 break;
1374 case DTV_DELIVERY_SYSTEM:
50727719 1375 tvp->u.data = c->delivery_system;
363429a0 1376 break;
363429a0 1377 case DTV_VOLTAGE:
50727719 1378 tvp->u.data = c->voltage;
363429a0
ST		 1379 break;
1380 case DTV_TONE:
50727719 1381 tvp->u.data = c->sectone;
363429a0 1382 break;
eacf8d8d
ST		 1383 case DTV_API_VERSION:
1384 tvp->u.data = (DVB_API_VERSION << 8) | DVB_API_VERSION_MINOR;
1385 break;
a4de91be 1386 case DTV_CODE_RATE_HP:
50727719 1387 tvp->u.data = c->code_rate_HP;
a4de91be
ST		 1388 break;
1389 case DTV_CODE_RATE_LP:
50727719 1390 tvp->u.data = c->code_rate_LP;
a4de91be 1391 break;
b87625f0 1392 case DTV_GUARD_INTERVAL:
50727719 1393 tvp->u.data = c->guard_interval;
b87625f0
ST		 1394 break;
1395 case DTV_TRANSMISSION_MODE:
50727719 1396 tvp->u.data = c->transmission_mode;
b87625f0 1397 break;
ef526f42 1398 case DTV_HIERARCHY:
50727719 1399 tvp->u.data = c->hierarchy;
ef526f42 1400 break;
b6e760f3
PB		 1401
1402 /* ISDB-T Support here */
1403 case DTV_ISDBT_PARTIAL_RECEPTION:
50727719 1404 tvp->u.data = c->isdbt_partial_reception;
b6e760f3
PB		 1405 break;
1406 case DTV_ISDBT_SOUND_BROADCASTING:
50727719 1407 tvp->u.data = c->isdbt_sb_mode;
b6e760f3
PB		 1408 break;
1409 case DTV_ISDBT_SB_SUBCHANNEL_ID:
50727719 1410 tvp->u.data = c->isdbt_sb_subchannel;
b6e760f3
PB		 1411 break;
1412 case DTV_ISDBT_SB_SEGMENT_IDX:
50727719 1413 tvp->u.data = c->isdbt_sb_segment_idx;
b6e760f3
PB		 1414 break;
1415 case DTV_ISDBT_SB_SEGMENT_COUNT:
50727719 1416 tvp->u.data = c->isdbt_sb_segment_count;
b6e760f3 1417 break;
e7b7949a 1418 case DTV_ISDBT_LAYER_ENABLED:
50727719 1419 tvp->u.data = c->isdbt_layer_enabled;
e7b7949a 1420 break;
b6e760f3 1421 case DTV_ISDBT_LAYERA_FEC:
50727719 1422 tvp->u.data = c->layer[0].fec;
b6e760f3
PB		 1423 break;
1424 case DTV_ISDBT_LAYERA_MODULATION:
50727719 1425 tvp->u.data = c->layer[0].modulation;
b6e760f3
PB		 1426 break;
1427 case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
50727719 1428 tvp->u.data = c->layer[0].segment_count;
b6e760f3
PB		 1429 break;
1430 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
50727719 1431 tvp->u.data = c->layer[0].interleaving;
b6e760f3
PB		 1432 break;
1433 case DTV_ISDBT_LAYERB_FEC:
50727719 1434 tvp->u.data = c->layer[1].fec;
b6e760f3
PB		 1435 break;
1436 case DTV_ISDBT_LAYERB_MODULATION:
50727719 1437 tvp->u.data = c->layer[1].modulation;
b6e760f3
PB		 1438 break;
1439 case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
50727719 1440 tvp->u.data = c->layer[1].segment_count;
b6e760f3
PB		 1441 break;
1442 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
50727719 1443 tvp->u.data = c->layer[1].interleaving;
b6e760f3
PB		 1444 break;
1445 case DTV_ISDBT_LAYERC_FEC:
50727719 1446 tvp->u.data = c->layer[2].fec;
b6e760f3
PB		 1447 break;
1448 case DTV_ISDBT_LAYERC_MODULATION:
50727719 1449 tvp->u.data = c->layer[2].modulation;
b6e760f3
PB		 1450 break;
1451 case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
50727719 1452 tvp->u.data = c->layer[2].segment_count;
b6e760f3
PB		 1453 break;
1454 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
50727719 1455 tvp->u.data = c->layer[2].interleaving;
b6e760f3 1456 break;
98293ef3 1457 case DTV_ISDBS_TS_ID:
50727719 1458 tvp->u.data = c->isdbs_ts_id;
98293ef3 1459 break;
94d56ffa 1460 case DTV_DVBT2_PLP_ID:
50727719 1461 tvp->u.data = c->dvbt2_plp_id;
94d56ffa 1462 break;
363429a0 1463 default:
aff8ab5c 1464 return -EINVAL;
363429a0
ST		 1465 }
1466
e23d9ae3
AO		 1467 /* Allow the frontend to override outgoing properties */
1468 if (fe->ops.get_property) {
1469 r = fe->ops.get_property(fe, tvp);
1470 if (r < 0)
1471 return r;
1472 }
1473
639544d7
MCC		 1474 dtv_property_dump(tvp);
1475
aff8ab5c 1476 return 0;
363429a0
ST		 1477}
1478
072ce0c5
MCC		 1479static int dtv_property_process_set(struct dvb_frontend *fe,
1480 struct dtv_property *tvp,
072ce0c5 1481 struct file *file)
6b73eeaf
ST		 1482{
1483 int r = 0;
50727719 1484 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
13c97bf5 1485 struct dvb_frontend_private *fepriv = fe->frontend_priv;
56f0680a 1486 dtv_property_dump(tvp);
6b73eeaf 1487
bfbf2dae 1488 /* Allow the frontend to validate incoming properties */
aff8ab5c 1489 if (fe->ops.set_property) {
bfbf2dae 1490 r = fe->ops.set_property(fe, tvp);
aff8ab5c
AO		 1491 if (r < 0)
1492 return r;
1493 }
bfbf2dae 1494
6b73eeaf 1495 switch(tvp->cmd) {
e7fee0f3 1496 case DTV_CLEAR:
6b73eeaf
ST		 1497 /* Reset a cache of data specific to the frontend here. This does
1498 * not effect hardware.
1499 */
b6e760f3 1500 dvb_frontend_clear_cache(fe);
a1bc84c0 1501 dprintk("%s() Flushing property cache\n", __func__);
6b73eeaf 1502 break;
e7fee0f3 1503 case DTV_TUNE:
6b73eeaf 1504 /* interpret the cache of data, build either a traditional frontend
d5748f10
ST		 1505 * tunerequest so we can pass validation in the FE_SET_FRONTEND
1506 * ioctl.
6b73eeaf 1507 */
50727719 1508 c->state = tvp->cmd;
a1bc84c0 1509 dprintk("%s() Finalised property cache\n", __func__);
d5748f10
ST		 1510 dtv_property_cache_submit(fe);
1511
aff8ab5c 1512 r = dvb_frontend_ioctl_legacy(file, FE_SET_FRONTEND,
61cb27af 1513 &fepriv->parameters_in);
6b73eeaf 1514 break;
363429a0 1515 case DTV_FREQUENCY:
50727719 1516 c->frequency = tvp->u.data;
6b73eeaf 1517 break;
363429a0 1518 case DTV_MODULATION:
50727719 1519 c->modulation = tvp->u.data;
6b73eeaf 1520 break;
75b7f943 1521 case DTV_BANDWIDTH_HZ:
50727719 1522 c->bandwidth_hz = tvp->u.data;
6b73eeaf 1523 break;
363429a0 1524 case DTV_INVERSION:
50727719 1525 c->inversion = tvp->u.data;
6b73eeaf 1526 break;
363429a0 1527 case DTV_SYMBOL_RATE:
50727719 1528 c->symbol_rate = tvp->u.data;
6b73eeaf 1529 break;
363429a0 1530 case DTV_INNER_FEC:
50727719 1531 c->fec_inner = tvp->u.data;
6b73eeaf 1532 break;
363429a0 1533 case DTV_PILOT:
50727719 1534 c->pilot = tvp->u.data;
6b73eeaf 1535 break;
363429a0 1536 case DTV_ROLLOFF:
50727719 1537 c->rolloff = tvp->u.data;
6b73eeaf 1538 break;
363429a0 1539 case DTV_DELIVERY_SYSTEM:
50727719 1540 c->delivery_system = tvp->u.data;
6b73eeaf 1541 break;
363429a0 1542 case DTV_VOLTAGE:
50727719 1543 c->voltage = tvp->u.data;
16ef8def 1544 r = dvb_frontend_ioctl_legacy(file, FE_SET_VOLTAGE,
50727719 1545 (void *)c->voltage);
13c97bf5 1546 break;
363429a0 1547 case DTV_TONE:
50727719 1548 c->sectone = tvp->u.data;
16ef8def 1549 r = dvb_frontend_ioctl_legacy(file, FE_SET_TONE,
50727719 1550 (void *)c->sectone);
13c97bf5 1551 break;
a4de91be 1552 case DTV_CODE_RATE_HP:
50727719 1553 c->code_rate_HP = tvp->u.data;
a4de91be
ST		 1554 break;
1555 case DTV_CODE_RATE_LP:
50727719 1556 c->code_rate_LP = tvp->u.data;
a4de91be 1557 break;
b87625f0 1558 case DTV_GUARD_INTERVAL:
50727719 1559 c->guard_interval = tvp->u.data;
b87625f0
ST		 1560 break;
1561 case DTV_TRANSMISSION_MODE:
50727719 1562 c->transmission_mode = tvp->u.data;
b87625f0 1563 break;
ef526f42 1564 case DTV_HIERARCHY:
50727719 1565 c->hierarchy = tvp->u.data;
ef526f42 1566 break;
b6e760f3
PB		 1567
1568 /* ISDB-T Support here */
1569 case DTV_ISDBT_PARTIAL_RECEPTION:
50727719 1570 c->isdbt_partial_reception = tvp->u.data;
b6e760f3
PB		 1571 break;
1572 case DTV_ISDBT_SOUND_BROADCASTING:
50727719 1573 c->isdbt_sb_mode = tvp->u.data;
b6e760f3
PB		 1574 break;
1575 case DTV_ISDBT_SB_SUBCHANNEL_ID:
50727719 1576 c->isdbt_sb_subchannel = tvp->u.data;
b6e760f3
PB		 1577 break;
1578 case DTV_ISDBT_SB_SEGMENT_IDX:
50727719 1579 c->isdbt_sb_segment_idx = tvp->u.data;
b6e760f3
PB		 1580 break;
1581 case DTV_ISDBT_SB_SEGMENT_COUNT:
50727719 1582 c->isdbt_sb_segment_count = tvp->u.data;
b6e760f3 1583 break;
e7b7949a 1584 case DTV_ISDBT_LAYER_ENABLED:
50727719 1585 c->isdbt_layer_enabled = tvp->u.data;
e7b7949a 1586 break;
b6e760f3 1587 case DTV_ISDBT_LAYERA_FEC:
50727719 1588 c->layer[0].fec = tvp->u.data;
b6e760f3
PB		 1589 break;
1590 case DTV_ISDBT_LAYERA_MODULATION:
50727719 1591 c->layer[0].modulation = tvp->u.data;
b6e760f3
PB		 1592 break;
1593 case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
50727719 1594 c->layer[0].segment_count = tvp->u.data;
b6e760f3
PB		 1595 break;
1596 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
50727719 1597 c->layer[0].interleaving = tvp->u.data;
b6e760f3
PB		 1598 break;
1599 case DTV_ISDBT_LAYERB_FEC:
50727719 1600 c->layer[1].fec = tvp->u.data;
b6e760f3
PB		 1601 break;
1602 case DTV_ISDBT_LAYERB_MODULATION:
50727719 1603 c->layer[1].modulation = tvp->u.data;
b6e760f3
PB		 1604 break;
1605 case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
50727719 1606 c->layer[1].segment_count = tvp->u.data;
b6e760f3
PB		 1607 break;
1608 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
50727719 1609 c->layer[1].interleaving = tvp->u.data;
b6e760f3
PB		 1610 break;
1611 case DTV_ISDBT_LAYERC_FEC:
50727719 1612 c->layer[2].fec = tvp->u.data;
b6e760f3
PB		 1613 break;
1614 case DTV_ISDBT_LAYERC_MODULATION:
50727719 1615 c->layer[2].modulation = tvp->u.data;
b6e760f3
PB		 1616 break;
1617 case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
50727719 1618 c->layer[2].segment_count = tvp->u.data;
b6e760f3
PB		 1619 break;
1620 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
50727719 1621 c->layer[2].interleaving = tvp->u.data;
b6e760f3 1622 break;
98293ef3 1623 case DTV_ISDBS_TS_ID:
50727719 1624 c->isdbs_ts_id = tvp->u.data;
94d56ffa
AO		 1625 break;
1626 case DTV_DVBT2_PLP_ID:
50727719 1627 c->dvbt2_plp_id = tvp->u.data;
98293ef3 1628 break;
363429a0 1629 default:
aff8ab5c 1630 return -EINVAL;
6b73eeaf
ST		 1631 }
1632
13c97bf5 1633 return r;
6b73eeaf
ST		 1634}
1635
16ef8def 1636static int dvb_frontend_ioctl(struct file *file,
1da177e4
LT		 1637 unsigned int cmd, void *parg)
1638{
1639 struct dvb_device *dvbdev = file->private_data;
1640 struct dvb_frontend *fe = dvbdev->priv;
50727719 1641 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0c53c70f 1642 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4
LT		 1643 int err = -EOPNOTSUPP;
1644
fb8253ba 1645 dprintk("%s (%d)\n", __func__, _IOC_NR(cmd));
1da177e4 1646
e36309f5 1647 if (fepriv->exit != DVB_FE_NO_EXIT)
1da177e4
LT		 1648 return -ENODEV;
1649
1650 if ((file->f_flags & O_ACCMODE) == O_RDONLY &&
1651 (_IOC_DIR(cmd) != _IOC_READ || cmd == FE_GET_EVENT ||
1652 cmd == FE_DISEQC_RECV_SLAVE_REPLY))
1653 return -EPERM;
1654
1655 if (down_interruptible (&fepriv->sem))
1656 return -ERESTARTSYS;
1657
13c97bf5 1658 if ((cmd == FE_SET_PROPERTY) || (cmd == FE_GET_PROPERTY))
16ef8def 1659 err = dvb_frontend_ioctl_properties(file, cmd, parg);
4dd88bec 1660 else {
50727719 1661 c->state = DTV_UNDEFINED;
16ef8def 1662 err = dvb_frontend_ioctl_legacy(file, cmd, parg);
4dd88bec 1663 }
13c97bf5
ST		 1664
1665 up(&fepriv->sem);
1666 return err;
1667}
1668
16ef8def 1669static int dvb_frontend_ioctl_properties(struct file *file,
13c97bf5
ST		 1670 unsigned int cmd, void *parg)
1671{
1672 struct dvb_device *dvbdev = file->private_data;
1673 struct dvb_frontend *fe = dvbdev->priv;
50727719 1674 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
e6f9ec86 1675 int err = 0;
e7fee0f3
ST		 1676
1677 struct dtv_properties *tvps = NULL;
1678 struct dtv_property *tvp = NULL;
1679 int i;
13c97bf5
ST		 1680
1681 dprintk("%s\n", __func__);
1682
6b73eeaf 1683 if(cmd == FE_SET_PROPERTY) {
e7fee0f3 1684 tvps = (struct dtv_properties __user *)parg;
6b73eeaf 1685
a1bc84c0
ST		 1686 dprintk("%s() properties.num = %d\n", __func__, tvps->num);
1687 dprintk("%s() properties.props = %p\n", __func__, tvps->props);
e7fee0f3
ST		 1688
1689 /* Put an arbitrary limit on the number of messages that can
1690 * be sent at once */
6068f506 1691 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS))
e7fee0f3
ST		 1692 return -EINVAL;
1693
6e3924aa 1694 tvp = kmalloc(tvps->num * sizeof(struct dtv_property), GFP_KERNEL);
e7fee0f3
ST		 1695 if (!tvp) {
1696 err = -ENOMEM;
1697 goto out;
6b73eeaf
ST		 1698 }
1699
e7fee0f3
ST		 1700 if (copy_from_user(tvp, tvps->props, tvps->num * sizeof(struct dtv_property))) {
1701 err = -EFAULT;
1702 goto out;
1703 }
1704
d48cb402 1705 for (i = 0; i < tvps->num; i++) {
aff8ab5c
AO		 1706 err = dtv_property_process_set(fe, tvp + i, file);
1707 if (err < 0)
1708 goto out;
1709 (tvp + i)->result = err;
d48cb402 1710 }
e7fee0f3 1711
50727719 1712 if (c->state == DTV_TUNE)
a1bc84c0 1713 dprintk("%s() Property cache is full, tuning\n", __func__);
bfbf2dae 1714
363429a0
ST		 1715 } else
1716 if(cmd == FE_GET_PROPERTY) {
a689e365 1717 struct dtv_frontend_properties cache_out;
363429a0
ST		 1718
1719 tvps = (struct dtv_properties __user *)parg;
1720
a1bc84c0
ST		 1721 dprintk("%s() properties.num = %d\n", __func__, tvps->num);
1722 dprintk("%s() properties.props = %p\n", __func__, tvps->props);
363429a0
ST		 1723
1724 /* Put an arbitrary limit on the number of messages that can
1725 * be sent at once */
6068f506 1726 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS))
363429a0
ST		 1727 return -EINVAL;
1728
6e3924aa 1729 tvp = kmalloc(tvps->num * sizeof(struct dtv_property), GFP_KERNEL);
363429a0
ST		 1730 if (!tvp) {
1731 err = -ENOMEM;
1732 goto out;
1733 }
1734
1735 if (copy_from_user(tvp, tvps->props, tvps->num * sizeof(struct dtv_property))) {
1736 err = -EFAULT;
1737 goto out;
1738 }
1739
a689e365
MCC		 1740 /*
1741 * Fills the cache out struct with the cache contents, plus
b1e9a650 1742 * the data retrieved from get_frontend.
a689e365
MCC		 1743 */
1744 dtv_get_frontend(fe, &cache_out, NULL);
d48cb402 1745 for (i = 0; i < tvps->num; i++) {
a689e365 1746 err = dtv_property_process_get(fe, &cache_out, tvp + i, file);
aff8ab5c
AO		 1747 if (err < 0)
1748 goto out;
1749 (tvp + i)->result = err;
d48cb402 1750 }
363429a0
ST		 1751
1752 if (copy_to_user(tvps->props, tvp, tvps->num * sizeof(struct dtv_property))) {
1753 err = -EFAULT;
1754 goto out;
1755 }
1756
363429a0
ST		 1757 } else
1758 err = -EOPNOTSUPP;
1759
e7fee0f3
ST		 1760out:
1761 kfree(tvp);
13c97bf5
ST		 1762 return err;
1763}
1764
16ef8def 1765static int dvb_frontend_ioctl_legacy(struct file *file,
13c97bf5
ST		 1766 unsigned int cmd, void *parg)
1767{
1768 struct dvb_device *dvbdev = file->private_data;
1769 struct dvb_frontend *fe = dvbdev->priv;
1770 struct dvb_frontend_private *fepriv = fe->frontend_priv;
9133aee0
MK		 1771 int cb_err, err = -EOPNOTSUPP;
1772
1773 if (fe->dvb->fe_ioctl_override) {
1774 cb_err = fe->dvb->fe_ioctl_override(fe, cmd, parg,
1775 DVB_FE_IOCTL_PRE);
1776 if (cb_err < 0)
1777 return cb_err;
1778 if (cb_err > 0)
1779 return 0;
1780 /* fe_ioctl_override returning 0 allows
1781 * dvb-core to continue handling the ioctl */
1782 }
13c97bf5 1783
1da177e4
LT		 1784 switch (cmd) {
1785 case FE_GET_INFO: {
0c53c70f 1786 struct dvb_frontend_info* info = parg;
dea74869 1787 memcpy(info, &fe->ops.info, sizeof(struct dvb_frontend_info));
2030c032 1788 dvb_frontend_get_frequency_limits(fe, &info->frequency_min, &info->frequency_max);
1da177e4
LT		 1789
1790 /* Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't
1791 * do it, it is done for it. */
1792 info->caps |= FE_CAN_INVERSION_AUTO;
1793 err = 0;
1794 break;
1795 }
1796
6757ccc5
PB		 1797 case FE_READ_STATUS: {
1798 fe_status_t* status = parg;
1799
25985edc 1800 /* if retune was requested but hasn't occurred yet, prevent
6757ccc5 1801 * that user get signal state from previous tuning */
01886255
JG		 1802 if (fepriv->state == FESTATE_RETUNE ||
1803 fepriv->state == FESTATE_ERROR) {
6757ccc5
PB		 1804 err=0;
1805 *status = 0;
1806 break;
1807 }
1808
dea74869
PB		 1809 if (fe->ops.read_status)
1810 err = fe->ops.read_status(fe, status);
1da177e4 1811 break;
6757ccc5 1812 }
1da177e4 1813 case FE_READ_BER:
dea74869
PB		 1814 if (fe->ops.read_ber)
1815 err = fe->ops.read_ber(fe, (__u32*) parg);
1da177e4
LT		 1816 break;
1817
1818 case FE_READ_SIGNAL_STRENGTH:
dea74869
PB		 1819 if (fe->ops.read_signal_strength)
1820 err = fe->ops.read_signal_strength(fe, (__u16*) parg);
1da177e4
LT		 1821 break;
1822
1823 case FE_READ_SNR:
dea74869
PB		 1824 if (fe->ops.read_snr)
1825 err = fe->ops.read_snr(fe, (__u16*) parg);
1da177e4
LT		 1826 break;
1827
1828 case FE_READ_UNCORRECTED_BLOCKS:
dea74869
PB		 1829 if (fe->ops.read_ucblocks)
1830 err = fe->ops.read_ucblocks(fe, (__u32*) parg);
1da177e4
LT		 1831 break;
1832
1833
1834 case FE_DISEQC_RESET_OVERLOAD:
dea74869
PB		 1835 if (fe->ops.diseqc_reset_overload) {
1836 err = fe->ops.diseqc_reset_overload(fe);
1da177e4
LT		 1837 fepriv->state = FESTATE_DISEQC;
1838 fepriv->status = 0;
1839 }
1840 break;
1841
1842 case FE_DISEQC_SEND_MASTER_CMD:
dea74869
PB		 1843 if (fe->ops.diseqc_send_master_cmd) {
1844 err = fe->ops.diseqc_send_master_cmd(fe, (struct dvb_diseqc_master_cmd*) parg);
1da177e4
LT		 1845 fepriv->state = FESTATE_DISEQC;
1846 fepriv->status = 0;
1847 }
1848 break;
1849
1850 case FE_DISEQC_SEND_BURST:
dea74869
PB		 1851 if (fe->ops.diseqc_send_burst) {
1852 err = fe->ops.diseqc_send_burst(fe, (fe_sec_mini_cmd_t) parg);
1da177e4
LT		 1853 fepriv->state = FESTATE_DISEQC;
1854 fepriv->status = 0;
1855 }
1856 break;
1857
1858 case FE_SET_TONE:
dea74869
PB		 1859 if (fe->ops.set_tone) {
1860 err = fe->ops.set_tone(fe, (fe_sec_tone_mode_t) parg);
64454016 1861 fepriv->tone = (fe_sec_tone_mode_t) parg;
1da177e4
LT		 1862 fepriv->state = FESTATE_DISEQC;
1863 fepriv->status = 0;
1864 }
1865 break;
1866
1867 case FE_SET_VOLTAGE:
dea74869
PB		 1868 if (fe->ops.set_voltage) {
1869 err = fe->ops.set_voltage(fe, (fe_sec_voltage_t) parg);
64454016 1870 fepriv->voltage = (fe_sec_voltage_t) parg;
1da177e4
LT		 1871 fepriv->state = FESTATE_DISEQC;
1872 fepriv->status = 0;
1873 }
1874 break;
1875
1876 case FE_DISHNETWORK_SEND_LEGACY_CMD:
dea74869
PB		 1877 if (fe->ops.dishnetwork_send_legacy_command) {
1878 err = fe->ops.dishnetwork_send_legacy_command(fe, (unsigned long) parg);
1da177e4
LT		 1879 fepriv->state = FESTATE_DISEQC;
1880 fepriv->status = 0;
dea74869 1881 } else if (fe->ops.set_voltage) {
83b75b04
N		 1882 /*
1883 * NOTE: This is a fallback condition. Some frontends
1884 * (stv0299 for instance) take longer than 8msec to
1885 * respond to a set_voltage command. Those switches
1886 * need custom routines to switch properly. For all
2030c032 1887 * other frontends, the following should work ok.
83b75b04
N		 1888 * Dish network legacy switches (as used by Dish500)
1889 * are controlled by sending 9-bit command words
1890 * spaced 8msec apart.
25985edc 1891 * the actual command word is switch/port dependent
83b75b04
N		 1892 * so it is up to the userspace application to send
1893 * the right command.
1894 * The command must always start with a '0' after
1895 * initialization, so parg is 8 bits and does not
1896 * include the initialization or start bit
1897 */
c6eb8eaf 1898 unsigned long swcmd = ((unsigned long) parg) << 1;
83b75b04
N		 1899 struct timeval nexttime;
1900 struct timeval tv[10];
1901 int i;
1902 u8 last = 1;
1903 if (dvb_frontend_debug)
c6eb8eaf 1904 printk("%s switch command: 0x%04lx\n", __func__, swcmd);
83b75b04
N		 1905 do_gettimeofday(&nexttime);
1906 if (dvb_frontend_debug)
1907 memcpy(&tv[0], &nexttime, sizeof(struct timeval));
1908 /* before sending a command, initialize by sending
1909 * a 32ms 18V to the switch
1910 */
dea74869 1911 fe->ops.set_voltage(fe, SEC_VOLTAGE_18);
83b75b04
N		 1912 dvb_frontend_sleep_until(&nexttime, 32000);
1913
1914 for (i = 0; i < 9; i++) {
1915 if (dvb_frontend_debug)
1916 do_gettimeofday(&tv[i + 1]);
c6eb8eaf 1917 if ((swcmd & 0x01) != last) {
83b75b04 1918 /* set voltage to (last ? 13V : 18V) */
dea74869 1919 fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18);
83b75b04
N		 1920 last = (last) ? 0 : 1;
1921 }
c6eb8eaf 1922 swcmd = swcmd >> 1;
83b75b04
N		 1923 if (i != 8)
1924 dvb_frontend_sleep_until(&nexttime, 8000);
1925 }
1926 if (dvb_frontend_debug) {
1927 printk("%s(%d): switch delay (should be 32k followed by all 8k\n",
46b4f7c1 1928 __func__, fe->dvb->num);
83b75b04
N		 1929 for (i = 1; i < 10; i++)
1930 printk("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i]));
1931 }
1932 err = 0;
1933 fepriv->state = FESTATE_DISEQC;
1934 fepriv->status = 0;
1da177e4
LT		 1935 }
1936 break;
1937
1938 case FE_DISEQC_RECV_SLAVE_REPLY:
dea74869
PB		 1939 if (fe->ops.diseqc_recv_slave_reply)
1940 err = fe->ops.diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg);
1da177e4
LT		 1941 break;
1942
1943 case FE_ENABLE_HIGH_LNB_VOLTAGE:
dea74869
PB		 1944 if (fe->ops.enable_high_lnb_voltage)
1945 err = fe->ops.enable_high_lnb_voltage(fe, (long) parg);
1da177e4
LT		 1946 break;
1947
1948 case FE_SET_FRONTEND: {
50727719 1949 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1da177e4
LT		 1950 struct dvb_frontend_tune_settings fetunesettings;
1951
50727719 1952 if (c->state == DTV_TUNE) {
61cb27af 1953 if (dvb_frontend_check_parameters(fe, &fepriv->parameters_in) < 0) {
6b73eeaf
ST		 1954 err = -EINVAL;
1955 break;
1956 }
1957 } else {
1958 if (dvb_frontend_check_parameters(fe, parg) < 0) {
1959 err = -EINVAL;
1960 break;
1961 }
1fab46f0 1962
61cb27af 1963 memcpy (&fepriv->parameters_in, parg,
6b73eeaf 1964 sizeof (struct dvb_frontend_parameters));
674ce343 1965 dtv_property_cache_init(fe, c);
bbe880b4 1966 dtv_property_cache_sync(fe, c, &fepriv->parameters_in);
6b73eeaf 1967 }
1da177e4 1968
56ce5ac4
AO		 1969 /*
1970 * Initialize output parameters to match the values given by
1971 * the user. FE_SET_FRONTEND triggers an initial frontend event
1972 * with status = 0, which copies output parameters to userspace.
1973 */
1974 fepriv->parameters_out = fepriv->parameters_in;
1975
1da177e4 1976 memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings));
1da177e4
LT		 1977
1978 /* force auto frequency inversion if requested */
1979 if (dvb_force_auto_inversion) {
61cb27af 1980 fepriv->parameters_in.inversion = INVERSION_AUTO;
1da177e4 1981 }
dea74869 1982 if (fe->ops.info.type == FE_OFDM) {
1b3c3714 1983 /* without hierarchical coding code_rate_LP is irrelevant,
1da177e4 1984 * so we tolerate the otherwise invalid FEC_NONE setting */
61cb27af
AO		 1985 if (fepriv->parameters_in.u.ofdm.hierarchy_information == HIERARCHY_NONE &&
1986 fepriv->parameters_in.u.ofdm.code_rate_LP == FEC_NONE)
1987 fepriv->parameters_in.u.ofdm.code_rate_LP = FEC_AUTO;
1da177e4
LT		 1988 }
1989
1990 /* get frontend-specific tuning settings */
dea74869 1991 if (fe->ops.get_tune_settings && (fe->ops.get_tune_settings(fe, &fetunesettings) == 0)) {
1da177e4
LT		 1992 fepriv->min_delay = (fetunesettings.min_delay_ms * HZ) / 1000;
1993 fepriv->max_drift = fetunesettings.max_drift;
1994 fepriv->step_size = fetunesettings.step_size;
1995 } else {
1996 /* default values */
dea74869 1997 switch(fe->ops.info.type) {
1da177e4
LT		 1998 case FE_QPSK:
1999 fepriv->min_delay = HZ/20;
61cb27af
AO		 2000 fepriv->step_size = fepriv->parameters_in.u.qpsk.symbol_rate / 16000;
2001 fepriv->max_drift = fepriv->parameters_in.u.qpsk.symbol_rate / 2000;
1da177e4
LT		 2002 break;
2003
2004 case FE_QAM:
2005 fepriv->min_delay = HZ/20;
2006 fepriv->step_size = 0; /* no zigzag */
2007 fepriv->max_drift = 0;
2008 break;
2009
2010 case FE_OFDM:
2011 fepriv->min_delay = HZ/20;
dea74869
PB		 2012 fepriv->step_size = fe->ops.info.frequency_stepsize * 2;
2013 fepriv->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1;
1da177e4
LT		 2014 break;
2015 case FE_ATSC:
4821fb1d
MA		 2016 fepriv->min_delay = HZ/20;
2017 fepriv->step_size = 0;
2018 fepriv->max_drift = 0;
1da177e4
LT		 2019 break;
2020 }
2021 }
2022 if (dvb_override_tune_delay > 0)
2023 fepriv->min_delay = (dvb_override_tune_delay * HZ) / 1000;
2024
2025 fepriv->state = FESTATE_RETUNE;
1d06059c
IL		 2026
2027 /* Request the search algorithm to search */
2028 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN;
2029
20640bea 2030 dvb_frontend_clear_events(fe);
1da177e4 2031 dvb_frontend_add_event(fe, 0);
5c9f480b 2032 dvb_frontend_wakeup(fe);
1da177e4
LT		 2033 fepriv->status = 0;
2034 err = 0;
2035 break;
2036 }
2037
2038 case FE_GET_EVENT:
2039 err = dvb_frontend_get_event (fe, parg, file->f_flags);
2040 break;
2041
2042 case FE_GET_FRONTEND:
a689e365
MCC		 2043 err = dtv_get_frontend(fe, NULL, &fepriv->parameters_out);
2044 if (err >= 0)
2045 memcpy(parg, &fepriv->parameters_out,
2046 sizeof(struct dvb_frontend_parameters));
1da177e4 2047 break;
36cb557a
AQ		 2048
2049 case FE_SET_FRONTEND_TUNE_MODE:
e18828e4 2050 fepriv->tune_mode_flags = (unsigned long) parg;
1b172e0c 2051 err = 0;
36cb557a 2052 break;
1da177e4
LT		 2053 };
2054
9133aee0
MK		 2055 if (fe->dvb->fe_ioctl_override) {
2056 cb_err = fe->dvb->fe_ioctl_override(fe, cmd, parg,
2057 DVB_FE_IOCTL_POST);
2058 if (cb_err < 0)
2059 return cb_err;
2060 }
2061
1da177e4
LT		 2062 return err;
2063}
2064
6b73eeaf 2065
1da177e4
LT		 2066static unsigned int dvb_frontend_poll(struct file *file, struct poll_table_struct *wait)
2067{
2068 struct dvb_device *dvbdev = file->private_data;
2069 struct dvb_frontend *fe = dvbdev->priv;
0c53c70f 2070 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1da177e4 2071
46b4f7c1 2072 dprintk ("%s\n", __func__);
1da177e4
LT		 2073
2074 poll_wait (file, &fepriv->events.wait_queue, wait);
2075
2076 if (fepriv->events.eventw != fepriv->events.eventr)
2077 return (POLLIN | POLLRDNORM | POLLPRI);
2078
2079 return 0;
2080}
2081
2082static int dvb_frontend_open(struct inode *inode, struct file *file)
2083{
2084 struct dvb_device *dvbdev = file->private_data;
2085 struct dvb_frontend *fe = dvbdev->priv;
0c53c70f 2086 struct dvb_frontend_private *fepriv = fe->frontend_priv;
59b1842d 2087 struct dvb_adapter *adapter = fe->dvb;
1da177e4
LT		 2088 int ret;
2089
46b4f7c1 2090 dprintk ("%s\n", __func__);
e36309f5
MC		 2091 if (fepriv->exit == DVB_FE_DEVICE_REMOVED)
2092 return -ENODEV;
1da177e4 2093
59b1842d
DB		 2094 if (adapter->mfe_shared) {
2095 mutex_lock (&adapter->mfe_lock);
6594690b
DB		 2096
2097 if (adapter->mfe_dvbdev == NULL)
2098 adapter->mfe_dvbdev = dvbdev;
2099
2100 else if (adapter->mfe_dvbdev != dvbdev) {
2101 struct dvb_device
2102 *mfedev = adapter->mfe_dvbdev;
2103 struct dvb_frontend
2104 *mfe = mfedev->priv;
2105 struct dvb_frontend_private
2106 *mfepriv = mfe->frontend_priv;
2107 int mferetry = (dvb_mfe_wait_time << 1);
2108
2109 mutex_unlock (&adapter->mfe_lock);
2110 while (mferetry-- && (mfedev->users != -1 ||
2111 mfepriv->thread != NULL)) {
2112 if(msleep_interruptible(500)) {
2113 if(signal_pending(current))
2114 return -EINTR;
59b1842d 2115 }
6594690b
DB		 2116 }
2117
2118 mutex_lock (&adapter->mfe_lock);
2119 if(adapter->mfe_dvbdev != dvbdev) {
59b1842d
DB		 2120 mfedev = adapter->mfe_dvbdev;
2121 mfe = mfedev->priv;
2122 mfepriv = mfe->frontend_priv;
6594690b
DB		 2123 if (mfedev->users != -1 ||
2124 mfepriv->thread != NULL) {
2125 mutex_unlock (&adapter->mfe_lock);
2126 return -EBUSY;
59b1842d 2127 }
6594690b 2128 adapter->mfe_dvbdev = dvbdev;
59b1842d 2129 }
59b1842d
DB		 2130 }
2131 }
2132
48136e1e
OE		 2133 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) {
2134 if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0)
59b1842d 2135 goto err0;
2d196931
DH		 2136
2137 /* If we took control of the bus, we need to force
2138 reinitialization. This is because many ts_bus_ctrl()
2139 functions strobe the RESET pin on the demod, and if the
2140 frontend thread already exists then the dvb_init() routine
2141 won't get called (which is what usually does initial
2142 register configuration). */
2143 fepriv->reinitialise = 1;
ba7e6f3e
ST		 2144 }
2145
48136e1e
OE		 2146 if ((ret = dvb_generic_open (inode, file)) < 0)
2147 goto err1;
04c56d0e 2148
48136e1e 2149 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
04c56d0e
AQ		 2150 /* normal tune mode when opened R/W */
2151 fepriv->tune_mode_flags &= ~FE_TUNE_MODE_ONESHOT;
2152 fepriv->tone = -1;
2153 fepriv->voltage = -1;
2154
1da177e4
LT		 2155 ret = dvb_frontend_start (fe);
2156 if (ret)
48136e1e 2157 goto err2;
1da177e4
LT		 2158
2159 /* empty event queue */
2160 fepriv->events.eventr = fepriv->events.eventw = 0;
2161 }
2162
59b1842d
DB		 2163 if (adapter->mfe_shared)
2164 mutex_unlock (&adapter->mfe_lock);
1da177e4 2165 return ret;
48136e1e
OE		 2166
2167err2:
2168 dvb_generic_release(inode, file);
2169err1:
2170 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl)
2171 fe->ops.ts_bus_ctrl(fe, 0);
59b1842d
DB		 2172err0:
2173 if (adapter->mfe_shared)
2174 mutex_unlock (&adapter->mfe_lock);
48136e1e 2175 return ret;
1da177e4
LT		 2176}
2177
2178static int dvb_frontend_release(struct inode *inode, struct file *file)
2179{
2180 struct dvb_device *dvbdev = file->private_data;
2181 struct dvb_frontend *fe = dvbdev->priv;
0c53c70f 2182 struct dvb_frontend_private *fepriv = fe->frontend_priv;
ca5be9cd 2183 int ret;
1da177e4 2184
46b4f7c1 2185 dprintk ("%s\n", __func__);
1da177e4 2186
b9d5efcc 2187 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1da177e4 2188 fepriv->release_jiffies = jiffies;
b9d5efcc
AO		 2189 mb();
2190 }
1da177e4 2191
ca5be9cd
MR		 2192 ret = dvb_generic_release (inode, file);
2193
48136e1e 2194 if (dvbdev->users == -1) {
b9d5efcc 2195 wake_up(&fepriv->wait_queue);
e36309f5 2196 if (fepriv->exit != DVB_FE_NO_EXIT) {
48136e1e
OE		 2197 fops_put(file->f_op);
2198 file->f_op = NULL;
2199 wake_up(&dvbdev->wait_queue);
2200 }
2201 if (fe->ops.ts_bus_ctrl)
2202 fe->ops.ts_bus_ctrl(fe, 0);
ca5be9cd 2203 }
48136e1e 2204
ca5be9cd 2205 return ret;
1da177e4
LT		 2206}
2207
784e29d2 2208static const struct file_operations dvb_frontend_fops = {
1da177e4 2209 .owner = THIS_MODULE,
16ef8def 2210 .unlocked_ioctl = dvb_generic_ioctl,
1da177e4
LT		 2211 .poll = dvb_frontend_poll,
2212 .open = dvb_frontend_open,
6038f373
AB		 2213 .release = dvb_frontend_release,
2214 .llseek = noop_llseek,
1da177e4
LT		 2215};
2216
2217int dvb_register_frontend(struct dvb_adapter* dvb,
2218 struct dvb_frontend* fe)
2219{
2220 struct dvb_frontend_private *fepriv;
2221 static const struct dvb_device dvbdev_template = {
2222 .users = ~0,
2223 .writers = 1,
2224 .readers = (~0)-1,
2225 .fops = &dvb_frontend_fops,
2226 .kernel_ioctl = dvb_frontend_ioctl
2227 };
2228
46b4f7c1 2229 dprintk ("%s\n", __func__);
1da177e4 2230
3593cab5 2231 if (mutex_lock_interruptible(&frontend_mutex))
1da177e4
LT		 2232 return -ERESTARTSYS;
2233
7408187d 2234 fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL);
1da177e4 2235 if (fe->frontend_priv == NULL) {
3593cab5 2236 mutex_unlock(&frontend_mutex);
1da177e4
LT		 2237 return -ENOMEM;
2238 }
0c53c70f 2239 fepriv = fe->frontend_priv;
1da177e4 2240
a0a4714c 2241 sema_init(&fepriv->sem, 1);
1da177e4
LT		 2242 init_waitqueue_head (&fepriv->wait_queue);
2243 init_waitqueue_head (&fepriv->events.wait_queue);
03b76123 2244 mutex_init(&fepriv->events.mtx);
1da177e4
LT		 2245 fe->dvb = dvb;
2246 fepriv->inversion = INVERSION_OFF;
2247
363c35fc 2248 printk ("DVB: registering adapter %i frontend %i (%s)...\n",
1da177e4 2249 fe->dvb->num,
363c35fc 2250 fe->id,
dea74869 2251 fe->ops.info.name);
1da177e4
LT		 2252
2253 dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template,
2254 fe, DVB_DEVICE_FRONTEND);
2255
3593cab5 2256 mutex_unlock(&frontend_mutex);
1da177e4
LT		 2257 return 0;
2258}
2259EXPORT_SYMBOL(dvb_register_frontend);
2260
2261int dvb_unregister_frontend(struct dvb_frontend* fe)
2262{
0c53c70f 2263 struct dvb_frontend_private *fepriv = fe->frontend_priv;
46b4f7c1 2264 dprintk ("%s\n", __func__);
1da177e4 2265
57861b43 2266 mutex_lock(&frontend_mutex);
ca5be9cd 2267 dvb_frontend_stop (fe);
57861b43
MR		 2268 mutex_unlock(&frontend_mutex);
2269
2270 if (fepriv->dvbdev->users < -1)
2271 wait_event(fepriv->dvbdev->wait_queue,
2272 fepriv->dvbdev->users==-1);
2273
3593cab5 2274 mutex_lock(&frontend_mutex);
1da177e4 2275 dvb_unregister_device (fepriv->dvbdev);
d9955060 2276
1da177e4
LT		 2277 /* fe is invalid now */
2278 kfree(fepriv);
3593cab5 2279 mutex_unlock(&frontend_mutex);
1da177e4
LT		 2280 return 0;
2281}
2282EXPORT_SYMBOL(dvb_unregister_frontend);
f52a838b 2283
149ef72d 2284#ifdef CONFIG_MEDIA_ATTACH
f52a838b
AQ		 2285void dvb_frontend_detach(struct dvb_frontend* fe)
2286{
2287 void *ptr;
2288
2289 if (fe->ops.release_sec) {
2290 fe->ops.release_sec(fe);
2291 symbol_put_addr(fe->ops.release_sec);
2292 }
2293 if (fe->ops.tuner_ops.release) {
2294 fe->ops.tuner_ops.release(fe);
2295 symbol_put_addr(fe->ops.tuner_ops.release);
2296 }
2426a27e
MK		 2297 if (fe->ops.analog_ops.release) {
2298 fe->ops.analog_ops.release(fe);
2299 symbol_put_addr(fe->ops.analog_ops.release);
2300 }
f52a838b
AQ		 2301 ptr = (void*)fe->ops.release;
2302 if (ptr) {
2303 fe->ops.release(fe);
2304 symbol_put_addr(ptr);
2305 }
2306}
2307#else
2308void dvb_frontend_detach(struct dvb_frontend* fe)
2309{
2310 if (fe->ops.release_sec)
2311 fe->ops.release_sec(fe);
2312 if (fe->ops.tuner_ops.release)
2313 fe->ops.tuner_ops.release(fe);
2426a27e
MK		 2314 if (fe->ops.analog_ops.release)
2315 fe->ops.analog_ops.release(fe);
f52a838b
AQ		 2316 if (fe->ops.release)
2317 fe->ops.release(fe);
2318}
2319#endif
2320EXPORT_SYMBOL(dvb_frontend_detach);
kernel source for telekom puls (alcatel/mediatek)