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