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