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