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