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 <linux/ktime.h>
44#include <asm/processor.h>
45
46#include "dvb_frontend.h"
47#include "dvbdev.h"
48#include <linux/dvb/version.h>
49
50static int dvb_frontend_debug;
51static int dvb_shutdown_timeout;
52static int dvb_force_auto_inversion;
53static int dvb_override_tune_delay;
54static int dvb_powerdown_on_sleep = 1;
55static int dvb_mfe_wait_time = 5;
56
57module_param_named(frontend_debug, dvb_frontend_debug, int, 0644);
58MODULE_PARM_DESC(frontend_debug, "Turn on/off frontend core debugging (default:off).");
59module_param(dvb_shutdown_timeout, int, 0644);
60MODULE_PARM_DESC(dvb_shutdown_timeout, "wait <shutdown_timeout> seconds after close() before suspending hardware");
61module_param(dvb_force_auto_inversion, int, 0644);
62MODULE_PARM_DESC(dvb_force_auto_inversion, "0: normal (default), 1: INVERSION_AUTO forced always");
63module_param(dvb_override_tune_delay, int, 0644);
64MODULE_PARM_DESC(dvb_override_tune_delay, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt");
65module_param(dvb_powerdown_on_sleep, int, 0644);
66MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB voltage off on sleep (default)");
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)");
69
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
78#define FESTATE_ERROR 256
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)
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99static DEFINE_MUTEX(frontend_mutex);
100
101struct dvb_frontend_private {
102 struct kref refcount;
103
104
105 struct dvb_device *dvbdev;
106 struct dvb_frontend_parameters parameters_out;
107 struct dvb_fe_events events;
108 struct semaphore sem;
109 struct list_head list_head;
110 wait_queue_head_t wait_queue;
111 struct task_struct *thread;
112 unsigned long release_jiffies;
113 unsigned int wakeup;
114 enum fe_status status;
115 unsigned long tune_mode_flags;
116 unsigned int delay;
117 unsigned int reinitialise;
118 int tone;
119 int voltage;
120
121
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;
134 enum dvbfe_search algo_status;
135
136#if defined(CONFIG_MEDIA_CONTROLLER_DVB)
137 struct media_pipeline pipe;
138#endif
139};
140
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
158static void dvb_frontend_wakeup(struct dvb_frontend *fe);
159static int dtv_get_frontend(struct dvb_frontend *fe,
160 struct dtv_frontend_properties *c,
161 struct dvb_frontend_parameters *p_out);
162static int
163dtv_property_legacy_params_sync(struct dvb_frontend *fe,
164 const struct dtv_frontend_properties *c,
165 struct dvb_frontend_parameters *p);
166
167static bool has_get_frontend(struct dvb_frontend *fe)
168{
169 return fe->ops.get_frontend != NULL;
170}
171
172
173
174
175
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:
200 case SYS_DTMB:
201 return DVBV3_OFDM;
202 case SYS_ATSC:
203 case SYS_ATSCMH:
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:
210 default:
211
212
213
214
215
216
217 return DVBV3_UNKNOWN;
218 }
219}
220
221static void dvb_frontend_add_event(struct dvb_frontend *fe,
222 enum fe_status status)
223{
224 struct dvb_frontend_private *fepriv = fe->frontend_priv;
225 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
226 struct dvb_fe_events *events = &fepriv->events;
227 struct dvb_frontend_event *e;
228 int wp;
229
230 dev_dbg(fe->dvb->device, "%s:\n", __func__);
231
232 if ((status & FE_HAS_LOCK) && has_get_frontend(fe))
233 dtv_get_frontend(fe, c, &fepriv->parameters_out);
234
235 mutex_lock(&events->mtx);
236
237 wp = (events->eventw + 1) % MAX_EVENT;
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];
244 e->status = status;
245 e->parameters = fepriv->parameters_out;
246
247 events->eventw = wp;
248
249 mutex_unlock(&events->mtx);
250
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{
257 struct dvb_frontend_private *fepriv = fe->frontend_priv;
258 struct dvb_fe_events *events = &fepriv->events;
259
260 dev_dbg(fe->dvb->device, "%s:\n", __func__);
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
285 mutex_lock(&events->mtx);
286 *event = events->events[events->eventr];
287 events->eventr = (events->eventr + 1) % MAX_EVENT;
288 mutex_unlock(&events->mtx);
289
290 return 0;
291}
292
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
303static void dvb_frontend_init(struct dvb_frontend *fe)
304{
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);
308
309 if (fe->ops.init)
310 fe->ops.init(fe);
311 if (fe->ops.tuner_ops.init) {
312 if (fe->ops.i2c_gate_ctrl)
313 fe->ops.i2c_gate_ctrl(fe, 1);
314 fe->ops.tuner_ops.init(fe);
315 if (fe->ops.i2c_gate_ctrl)
316 fe->ops.i2c_gate_ctrl(fe, 0);
317 }
318}
319
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
329static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private *fepriv, int locked)
330{
331 int q2;
332 struct dvb_frontend *fe = fepriv->dvbdev->priv;
333
334 dev_dbg(fe->dvb->device, "%s:\n", __func__);
335
336 if (locked)
337 (fepriv->quality) = (fepriv->quality * 220 + 36*256) / 256;
338 else
339 (fepriv->quality) = (fepriv->quality * 220 + 0) / 256;
340
341 q2 = fepriv->quality - 128;
342 q2 *= q2;
343
344 fepriv->delay = fepriv->min_delay + q2 * HZ / (128*128);
345}
346
347
348
349
350
351
352
353
354static int dvb_frontend_swzigzag_autotune(struct dvb_frontend *fe, int check_wrapped)
355{
356 int autoinversion;
357 int ready = 0;
358 int fe_set_err = 0;
359 struct dvb_frontend_private *fepriv = fe->frontend_priv;
360 struct dtv_frontend_properties *c = &fe->dtv_property_cache, tmp;
361 int original_inversion = c->inversion;
362 u32 original_frequency = c->frequency;
363
364
365 autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) &&
366 (c->inversion == INVERSION_AUTO));
367
368
369 while(!ready) {
370
371 fepriv->lnb_drift = fepriv->auto_step * fepriv->step_size;
372
373
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
381 switch(fepriv->auto_sub_step) {
382 case 0:
383
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;
413 break;
414 }
415
416 if (!ready) fepriv->auto_sub_step++;
417 }
418
419
420
421 if ((fepriv->auto_step == fepriv->started_auto_step) &&
422 (fepriv->auto_sub_step == 0) && check_wrapped) {
423 return 1;
424 }
425
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);
431
432
433 c->frequency += fepriv->lnb_drift;
434 if (autoinversion)
435 c->inversion = fepriv->inversion;
436 tmp = *c;
437 if (fe->ops.set_frontend)
438 fe_set_err = fe->ops.set_frontend(fe);
439 *c = tmp;
440 if (fe_set_err < 0) {
441 fepriv->state = FESTATE_ERROR;
442 return fe_set_err;
443 }
444
445 c->frequency = original_frequency;
446 c->inversion = original_inversion;
447
448 fepriv->auto_sub_step++;
449 return 0;
450}
451
452static void dvb_frontend_swzigzag(struct dvb_frontend *fe)
453{
454 enum fe_status s = 0;
455 int retval = 0;
456 struct dvb_frontend_private *fepriv = fe->frontend_priv;
457 struct dtv_frontend_properties *c = &fe->dtv_property_cache, tmp;
458
459
460 if (fepriv->state & FESTATE_IDLE) {
461 fepriv->delay = 3*HZ;
462 fepriv->quality = 0;
463 return;
464 }
465
466
467 if (fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT) {
468 if (fepriv->state & FESTATE_RETUNE) {
469 tmp = *c;
470 if (fe->ops.set_frontend)
471 retval = fe->ops.set_frontend(fe);
472 *c = tmp;
473 if (retval < 0)
474 fepriv->state = FESTATE_ERROR;
475 else
476 fepriv->state = FESTATE_TUNED;
477 }
478 fepriv->delay = 3*HZ;
479 fepriv->quality = 0;
480 return;
481 }
482
483
484 if (fepriv->state & FESTATE_RETUNE) {
485 s = 0;
486 } else {
487 if (fe->ops.read_status)
488 fe->ops.read_status(fe, &s);
489 if (s != fepriv->status) {
490 dvb_frontend_add_event(fe, s);
491 fepriv->status = s;
492 }
493 }
494
495
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
501 if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) &&
502 (c->inversion == INVERSION_AUTO)) {
503 c->inversion = fepriv->inversion;
504 }
505 return;
506 }
507
508
509 if (fepriv->state & FESTATE_TUNED) {
510 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
511
512
513 if (s & FE_HAS_LOCK) {
514 return;
515 } else {
516 fepriv->state = FESTATE_ZIGZAG_FAST;
517 fepriv->started_auto_step = fepriv->auto_step;
518 fepriv->check_wrapped = 0;
519 }
520 }
521
522
523
524 if ((fepriv->state & FESTATE_LOSTLOCK) &&
525 (fe->ops.info.caps & FE_CAN_RECOVER) && (fepriv->max_drift == 0)) {
526 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
527 return;
528 }
529
530
531
532
533 if (fepriv->state & FESTATE_DISEQC) {
534 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
535 return;
536 }
537
538
539
540
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
550 if ((fepriv->state & FESTATE_SEARCHING_FAST) || (fepriv->state & FESTATE_RETUNE)) {
551 fepriv->delay = fepriv->min_delay;
552
553
554 retval = dvb_frontend_swzigzag_autotune(fe,
555 fepriv->check_wrapped);
556 if (retval < 0) {
557 return;
558 } else if (retval) {
559
560
561 fepriv->state = FESTATE_SEARCHING_SLOW;
562 fepriv->started_auto_step = fepriv->auto_step;
563 return;
564 }
565 fepriv->check_wrapped = 1;
566
567
568
569
570
571 if (fepriv->state & FESTATE_RETUNE) {
572 fepriv->state = FESTATE_TUNING_FAST;
573 }
574 }
575
576
577 if (fepriv->state & FESTATE_SEARCHING_SLOW) {
578 dvb_frontend_swzigzag_update_delay(fepriv, s & FE_HAS_LOCK);
579
580
581
582 dvb_frontend_swzigzag_autotune(fe, 0);
583 }
584}
585
586static int dvb_frontend_is_exiting(struct dvb_frontend *fe)
587{
588 struct dvb_frontend_private *fepriv = fe->frontend_priv;
589
590 if (fe->exit != DVB_FE_NO_EXIT)
591 return 1;
592
593 if (fepriv->dvbdev->writers == 1)
594 if (time_after_eq(jiffies, fepriv->release_jiffies +
595 dvb_shutdown_timeout * HZ))
596 return 1;
597
598 return 0;
599}
600
601static int dvb_frontend_should_wakeup(struct dvb_frontend *fe)
602{
603 struct dvb_frontend_private *fepriv = fe->frontend_priv;
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{
614 struct dvb_frontend_private *fepriv = fe->frontend_priv;
615
616 fepriv->wakeup = 1;
617 wake_up_interruptible(&fepriv->wait_queue);
618}
619
620static int dvb_frontend_thread(void *data)
621{
622 struct dvb_frontend *fe = data;
623 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
624 struct dvb_frontend_private *fepriv = fe->frontend_priv;
625 enum fe_status s;
626 enum dvbfe_algo algo;
627 bool re_tune = false;
628 bool semheld = false;
629
630 dev_dbg(fe->dvb->device, "%s:\n", __func__);
631
632 fepriv->check_wrapped = 0;
633 fepriv->quality = 0;
634 fepriv->delay = 3*HZ;
635 fepriv->status = 0;
636 fepriv->wakeup = 0;
637 fepriv->reinitialise = 0;
638
639 dvb_frontend_init(fe);
640
641 set_freezable();
642 while (1) {
643 up(&fepriv->sem);
644restart:
645 wait_event_interruptible_timeout(fepriv->wait_queue,
646 dvb_frontend_should_wakeup(fe) || kthread_should_stop()
647 || freezing(current),
648 fepriv->delay);
649
650 if (kthread_should_stop() || dvb_frontend_is_exiting(fe)) {
651
652 if (!down_interruptible(&fepriv->sem))
653 semheld = true;
654 fe->exit = DVB_FE_NORMAL_EXIT;
655 break;
656 }
657
658 if (try_to_freeze())
659 goto restart;
660
661 if (down_interruptible(&fepriv->sem))
662 break;
663
664 if (fepriv->reinitialise) {
665 dvb_frontend_init(fe);
666 if (fe->ops.set_tone && fepriv->tone != -1)
667 fe->ops.set_tone(fe, fepriv->tone);
668 if (fe->ops.set_voltage && fepriv->voltage != -1)
669 fe->ops.set_voltage(fe, fepriv->voltage);
670 fepriv->reinitialise = 0;
671 }
672
673
674 if (fe->ops.get_frontend_algo) {
675 algo = fe->ops.get_frontend_algo(fe);
676 switch (algo) {
677 case DVBFE_ALGO_HW:
678 dev_dbg(fe->dvb->device, "%s: Frontend ALGO = DVBFE_ALGO_HW\n", __func__);
679
680 if (fepriv->state & FESTATE_RETUNE) {
681 dev_dbg(fe->dvb->device, "%s: Retune requested, FESTATE_RETUNE\n", __func__);
682 re_tune = true;
683 fepriv->state = FESTATE_TUNED;
684 } else {
685 re_tune = false;
686 }
687
688 if (fe->ops.tune)
689 fe->ops.tune(fe, re_tune, fepriv->tune_mode_flags, &fepriv->delay, &s);
690
691 if (s != fepriv->status && !(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT)) {
692 dev_dbg(fe->dvb->device, "%s: state changed, adding current state\n", __func__);
693 dvb_frontend_add_event(fe, s);
694 fepriv->status = s;
695 }
696 break;
697 case DVBFE_ALGO_SW:
698 dev_dbg(fe->dvb->device, "%s: Frontend ALGO = DVBFE_ALGO_SW\n", __func__);
699 dvb_frontend_swzigzag(fe);
700 break;
701 case DVBFE_ALGO_CUSTOM:
702 dev_dbg(fe->dvb->device, "%s: Frontend ALGO = DVBFE_ALGO_CUSTOM, state=%d\n", __func__, fepriv->state);
703 if (fepriv->state & FESTATE_RETUNE) {
704 dev_dbg(fe->dvb->device, "%s: Retune requested, FESTAT_RETUNE\n", __func__);
705 fepriv->state = FESTATE_TUNED;
706 }
707
708
709
710
711 if (fepriv->algo_status & DVBFE_ALGO_SEARCH_AGAIN) {
712 if (fe->ops.search) {
713 fepriv->algo_status = fe->ops.search(fe);
714
715
716
717 } else {
718 fepriv->algo_status &= ~DVBFE_ALGO_SEARCH_AGAIN;
719 }
720 }
721
722 if (fepriv->algo_status != DVBFE_ALGO_SEARCH_SUCCESS) {
723 fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN;
724 fepriv->delay = HZ / 2;
725 }
726 dtv_property_legacy_params_sync(fe, c, &fepriv->parameters_out);
727 fe->ops.read_status(fe, &s);
728 if (s != fepriv->status) {
729 dvb_frontend_add_event(fe, s);
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 }
737 }
738 break;
739 default:
740 dev_dbg(fe->dvb->device, "%s: UNDEFINED ALGO !\n", __func__);
741 break;
742 }
743 } else {
744 dvb_frontend_swzigzag(fe);
745 }
746 }
747
748 if (dvb_powerdown_on_sleep) {
749 if (fe->ops.set_voltage)
750 fe->ops.set_voltage(fe, SEC_VOLTAGE_OFF);
751 if (fe->ops.tuner_ops.sleep) {
752 if (fe->ops.i2c_gate_ctrl)
753 fe->ops.i2c_gate_ctrl(fe, 1);
754 fe->ops.tuner_ops.sleep(fe);
755 if (fe->ops.i2c_gate_ctrl)
756 fe->ops.i2c_gate_ctrl(fe, 0);
757 }
758 if (fe->ops.sleep)
759 fe->ops.sleep(fe);
760 }
761
762 fepriv->thread = NULL;
763 if (kthread_should_stop())
764 fe->exit = DVB_FE_DEVICE_REMOVED;
765 else
766 fe->exit = DVB_FE_NO_EXIT;
767 mb();
768
769 if (semheld)
770 up(&fepriv->sem);
771 dvb_frontend_wakeup(fe);
772 return 0;
773}
774
775static void dvb_frontend_stop(struct dvb_frontend *fe)
776{
777 struct dvb_frontend_private *fepriv = fe->frontend_priv;
778
779 dev_dbg(fe->dvb->device, "%s:\n", __func__);
780
781 if (fe->exit != DVB_FE_DEVICE_REMOVED)
782 fe->exit = DVB_FE_NORMAL_EXIT;
783 mb();
784
785 if (!fepriv->thread)
786 return;
787
788 kthread_stop(fepriv->thread);
789
790 sema_init(&fepriv->sem, 1);
791 fepriv->state = FESTATE_IDLE;
792
793
794 if (fepriv->thread)
795 dev_warn(fe->dvb->device,
796 "dvb_frontend_stop: warning: thread %p won't exit\n",
797 fepriv->thread);
798}
799
800
801
802
803
804
805
806
807void dvb_frontend_sleep_until(ktime_t *waketime, u32 add_usec)
808{
809 s32 delta;
810
811 *waketime = ktime_add_us(*waketime, add_usec);
812 delta = ktime_us_delta(ktime_get_boottime(), *waketime);
813 if (delta > 2500) {
814 msleep((delta - 1500) / 1000);
815 delta = ktime_us_delta(ktime_get_boottime(), *waketime);
816 }
817 if (delta > 0)
818 udelay(delta);
819}
820EXPORT_SYMBOL(dvb_frontend_sleep_until);
821
822static int dvb_frontend_start(struct dvb_frontend *fe)
823{
824 int ret;
825 struct dvb_frontend_private *fepriv = fe->frontend_priv;
826 struct task_struct *fe_thread;
827
828 dev_dbg(fe->dvb->device, "%s:\n", __func__);
829
830 if (fepriv->thread) {
831 if (fe->exit == DVB_FE_NO_EXIT)
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;
843 fe->exit = DVB_FE_NO_EXIT;
844 fepriv->thread = NULL;
845 mb();
846
847 fe_thread = kthread_run(dvb_frontend_thread, fe,
848 "kdvb-ad-%i-fe-%i", fe->dvb->num,fe->id);
849 if (IS_ERR(fe_thread)) {
850 ret = PTR_ERR(fe_thread);
851 dev_warn(fe->dvb->device,
852 "dvb_frontend_start: failed to start kthread (%d)\n",
853 ret);
854 up(&fepriv->sem);
855 return ret;
856 }
857 fepriv->thread = fe_thread;
858 return 0;
859}
860
861static void dvb_frontend_get_frequency_limits(struct dvb_frontend *fe,
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)
874 dev_warn(fe->dvb->device, "DVB: adapter %i frontend %u frequency limits undefined - fix the driver\n",
875 fe->dvb->num, fe->id);
876}
877
878static int dvb_frontend_check_parameters(struct dvb_frontend *fe)
879{
880 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
881 u32 freq_min;
882 u32 freq_max;
883
884
885 dvb_frontend_get_frequency_limits(fe, &freq_min, &freq_max);
886 if ((freq_min && c->frequency < freq_min) ||
887 (freq_max && c->frequency > freq_max)) {
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);
891 return -EINVAL;
892 }
893
894
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:
901 if ((fe->ops.info.symbol_rate_min &&
902 c->symbol_rate < fe->ops.info.symbol_rate_min) ||
903 (fe->ops.info.symbol_rate_max &&
904 c->symbol_rate > fe->ops.info.symbol_rate_max)) {
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);
909 return -EINVAL;
910 }
911 default:
912 break;
913 }
914
915 return 0;
916}
917
918static int dvb_frontend_clear_cache(struct dvb_frontend *fe)
919{
920 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
921 int i;
922 u32 delsys;
923
924 delsys = c->delivery_system;
925 memset(c, 0, offsetof(struct dtv_frontend_properties, strength));
926 c->delivery_system = delsys;
927
928 c->state = DTV_CLEAR;
929
930 dev_dbg(fe->dvb->device, "%s: Clearing cache for delivery system %d\n",
931 __func__, c->delivery_system);
932
933 c->transmission_mode = TRANSMISSION_MODE_AUTO;
934 c->bandwidth_hz = 0;
935 c->guard_interval = GUARD_INTERVAL_AUTO;
936 c->hierarchy = HIERARCHY_AUTO;
937 c->symbol_rate = 0;
938 c->code_rate_HP = FEC_AUTO;
939 c->code_rate_LP = FEC_AUTO;
940 c->fec_inner = FEC_AUTO;
941 c->rolloff = ROLLOFF_AUTO;
942 c->voltage = SEC_VOLTAGE_OFF;
943 c->sectone = SEC_TONE_OFF;
944 c->pilot = PILOT_AUTO;
945
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;
952 for (i = 0; i < 3; i++) {
953 c->layer[i].fec = FEC_AUTO;
954 c->layer[i].modulation = QAM_AUTO;
955 c->layer[i].interleaving = 0;
956 c->layer[i].segment_count = 0;
957 }
958
959 c->stream_id = NO_STREAM_ID_FILTER;
960
961 switch (c->delivery_system) {
962 case SYS_DVBS:
963 case SYS_DVBS2:
964 case SYS_TURBO:
965 c->modulation = QPSK;
966 c->rolloff = ROLLOFF_35;
967 break;
968 case SYS_ATSC:
969 c->modulation = VSB_8;
970 break;
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;
976 default:
977 c->modulation = QAM_AUTO;
978 break;
979 }
980
981 c->lna = LNA_AUTO;
982
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
994static struct dtv_cmds_h dtv_cmds[DTV_MAX_COMMAND + 1] = {
995 _DTV_CMD(DTV_TUNE, 1, 0),
996 _DTV_CMD(DTV_CLEAR, 1, 0),
997
998
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),
1016 _DTV_CMD(DTV_INTERLEAVING, 1, 0),
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),
1023 _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 1, 0),
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
1037 _DTV_CMD(DTV_STREAM_ID, 1, 0),
1038 _DTV_CMD(DTV_DVBT2_PLP_ID_LEGACY, 1, 0),
1039 _DTV_CMD(DTV_LNA, 1, 0),
1040
1041
1042 _DTV_CMD(DTV_DISEQC_SLAVE_REPLY, 0, 1),
1043 _DTV_CMD(DTV_API_VERSION, 0, 0),
1044
1045 _DTV_CMD(DTV_ENUM_DELSYS, 0, 0),
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),
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),
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),
1063
1064
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),
1073};
1074
1075static void dtv_property_dump(struct dvb_frontend *fe,
1076 bool is_set,
1077 struct dtv_property *tvp)
1078{
1079 int i;
1080
1081 if (tvp->cmd <= 0 || tvp->cmd > DTV_MAX_COMMAND) {
1082 dev_warn(fe->dvb->device, "%s: %s tvp.cmd = 0x%08x undefined\n",
1083 __func__,
1084 is_set ? "SET" : "GET",
1085 tvp->cmd);
1086 return;
1087 }
1088
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);
1093
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);
1097
1098 for(i = 0; i < tvp->u.buffer.len; i++)
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 }
1106}
1107
1108
1109
1110
1111
1112static int dtv_property_cache_sync(struct dvb_frontend *fe,
1113 struct dtv_frontend_properties *c,
1114 const struct dvb_frontend_parameters *p)
1115{
1116 c->frequency = p->frequency;
1117 c->inversion = p->inversion;
1118
1119 switch (dvbv3_type(c->delivery_system)) {
1120 case DVBV3_QPSK:
1121 dev_dbg(fe->dvb->device, "%s: Preparing QPSK req\n", __func__);
1122 c->symbol_rate = p->u.qpsk.symbol_rate;
1123 c->fec_inner = p->u.qpsk.fec_inner;
1124 break;
1125 case DVBV3_QAM:
1126 dev_dbg(fe->dvb->device, "%s: Preparing QAM req\n", __func__);
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;
1131 case DVBV3_OFDM:
1132 dev_dbg(fe->dvb->device, "%s: Preparing OFDM req\n", __func__);
1133
1134 switch (p->u.ofdm.bandwidth) {
1135 case BANDWIDTH_10_MHZ:
1136 c->bandwidth_hz = 10000000;
1137 break;
1138 case BANDWIDTH_8_MHZ:
1139 c->bandwidth_hz = 8000000;
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:
1154 c->bandwidth_hz = 0;
1155 }
1156
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;
1164 case DVBV3_ATSC:
1165 dev_dbg(fe->dvb->device, "%s: Preparing ATSC req\n", __func__);
1166 c->modulation = p->u.vsb.modulation;
1167 if (c->delivery_system == SYS_ATSCMH)
1168 break;
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;
1173 break;
1174 case DVBV3_UNKNOWN:
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);
1178 return -EINVAL;
1179 }
1180
1181 return 0;
1182}
1183
1184
1185
1186
1187static int
1188dtv_property_legacy_params_sync(struct dvb_frontend *fe,
1189 const struct dtv_frontend_properties *c,
1190 struct dvb_frontend_parameters *p)
1191{
1192 p->frequency = c->frequency;
1193 p->inversion = c->inversion;
1194
1195 switch (dvbv3_type(c->delivery_system)) {
1196 case DVBV3_UNKNOWN:
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);
1200 return -EINVAL;
1201 case DVBV3_QPSK:
1202 dev_dbg(fe->dvb->device, "%s: Preparing QPSK req\n", __func__);
1203 p->u.qpsk.symbol_rate = c->symbol_rate;
1204 p->u.qpsk.fec_inner = c->fec_inner;
1205 break;
1206 case DVBV3_QAM:
1207 dev_dbg(fe->dvb->device, "%s: Preparing QAM req\n", __func__);
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;
1212 case DVBV3_OFDM:
1213 dev_dbg(fe->dvb->device, "%s: Preparing OFDM req\n", __func__);
1214 switch (c->bandwidth_hz) {
1215 case 10000000:
1216 p->u.ofdm.bandwidth = BANDWIDTH_10_MHZ;
1217 break;
1218 case 8000000:
1219 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
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:
1235 p->u.ofdm.bandwidth = BANDWIDTH_AUTO;
1236 }
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;
1244 case DVBV3_ATSC:
1245 dev_dbg(fe->dvb->device, "%s: Preparing VSB req\n", __func__);
1246 p->u.vsb.modulation = c->modulation;
1247 break;
1248 }
1249 return 0;
1250}
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262static int dtv_get_frontend(struct dvb_frontend *fe,
1263 struct dtv_frontend_properties *c,
1264 struct dvb_frontend_parameters *p_out)
1265{
1266 int r;
1267
1268 if (fe->ops.get_frontend) {
1269 r = fe->ops.get_frontend(fe, c);
1270 if (unlikely(r < 0))
1271 return r;
1272 if (p_out)
1273 dtv_property_legacy_params_sync(fe, c, p_out);
1274 return 0;
1275 }
1276
1277
1278 return 0;
1279}
1280
1281static int dvb_frontend_ioctl_legacy(struct file *file,
1282 unsigned int cmd, void *parg);
1283static int dvb_frontend_ioctl_properties(struct file *file,
1284 unsigned int cmd, void *parg);
1285
1286static int dtv_property_process_get(struct dvb_frontend *fe,
1287 const struct dtv_frontend_properties *c,
1288 struct dtv_property *tvp,
1289 struct file *file)
1290{
1291 int r, ncaps;
1292
1293 switch(tvp->cmd) {
1294 case DTV_ENUM_DELSYS:
1295 ncaps = 0;
1296 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) {
1297 tvp->u.buffer.data[ncaps] = fe->ops.delsys[ncaps];
1298 ncaps++;
1299 }
1300 tvp->u.buffer.len = ncaps;
1301 break;
1302 case DTV_FREQUENCY:
1303 tvp->u.data = c->frequency;
1304 break;
1305 case DTV_MODULATION:
1306 tvp->u.data = c->modulation;
1307 break;
1308 case DTV_BANDWIDTH_HZ:
1309 tvp->u.data = c->bandwidth_hz;
1310 break;
1311 case DTV_INVERSION:
1312 tvp->u.data = c->inversion;
1313 break;
1314 case DTV_SYMBOL_RATE:
1315 tvp->u.data = c->symbol_rate;
1316 break;
1317 case DTV_INNER_FEC:
1318 tvp->u.data = c->fec_inner;
1319 break;
1320 case DTV_PILOT:
1321 tvp->u.data = c->pilot;
1322 break;
1323 case DTV_ROLLOFF:
1324 tvp->u.data = c->rolloff;
1325 break;
1326 case DTV_DELIVERY_SYSTEM:
1327 tvp->u.data = c->delivery_system;
1328 break;
1329 case DTV_VOLTAGE:
1330 tvp->u.data = c->voltage;
1331 break;
1332 case DTV_TONE:
1333 tvp->u.data = c->sectone;
1334 break;
1335 case DTV_API_VERSION:
1336 tvp->u.data = (DVB_API_VERSION << 8) | DVB_API_VERSION_MINOR;
1337 break;
1338 case DTV_CODE_RATE_HP:
1339 tvp->u.data = c->code_rate_HP;
1340 break;
1341 case DTV_CODE_RATE_LP:
1342 tvp->u.data = c->code_rate_LP;
1343 break;
1344 case DTV_GUARD_INTERVAL:
1345 tvp->u.data = c->guard_interval;
1346 break;
1347 case DTV_TRANSMISSION_MODE:
1348 tvp->u.data = c->transmission_mode;
1349 break;
1350 case DTV_HIERARCHY:
1351 tvp->u.data = c->hierarchy;
1352 break;
1353 case DTV_INTERLEAVING:
1354 tvp->u.data = c->interleaving;
1355 break;
1356
1357
1358 case DTV_ISDBT_PARTIAL_RECEPTION:
1359 tvp->u.data = c->isdbt_partial_reception;
1360 break;
1361 case DTV_ISDBT_SOUND_BROADCASTING:
1362 tvp->u.data = c->isdbt_sb_mode;
1363 break;
1364 case DTV_ISDBT_SB_SUBCHANNEL_ID:
1365 tvp->u.data = c->isdbt_sb_subchannel;
1366 break;
1367 case DTV_ISDBT_SB_SEGMENT_IDX:
1368 tvp->u.data = c->isdbt_sb_segment_idx;
1369 break;
1370 case DTV_ISDBT_SB_SEGMENT_COUNT:
1371 tvp->u.data = c->isdbt_sb_segment_count;
1372 break;
1373 case DTV_ISDBT_LAYER_ENABLED:
1374 tvp->u.data = c->isdbt_layer_enabled;
1375 break;
1376 case DTV_ISDBT_LAYERA_FEC:
1377 tvp->u.data = c->layer[0].fec;
1378 break;
1379 case DTV_ISDBT_LAYERA_MODULATION:
1380 tvp->u.data = c->layer[0].modulation;
1381 break;
1382 case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
1383 tvp->u.data = c->layer[0].segment_count;
1384 break;
1385 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
1386 tvp->u.data = c->layer[0].interleaving;
1387 break;
1388 case DTV_ISDBT_LAYERB_FEC:
1389 tvp->u.data = c->layer[1].fec;
1390 break;
1391 case DTV_ISDBT_LAYERB_MODULATION:
1392 tvp->u.data = c->layer[1].modulation;
1393 break;
1394 case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
1395 tvp->u.data = c->layer[1].segment_count;
1396 break;
1397 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
1398 tvp->u.data = c->layer[1].interleaving;
1399 break;
1400 case DTV_ISDBT_LAYERC_FEC:
1401 tvp->u.data = c->layer[2].fec;
1402 break;
1403 case DTV_ISDBT_LAYERC_MODULATION:
1404 tvp->u.data = c->layer[2].modulation;
1405 break;
1406 case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
1407 tvp->u.data = c->layer[2].segment_count;
1408 break;
1409 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
1410 tvp->u.data = c->layer[2].interleaving;
1411 break;
1412
1413
1414 case DTV_STREAM_ID:
1415 case DTV_DVBT2_PLP_ID_LEGACY:
1416 tvp->u.data = c->stream_id;
1417 break;
1418
1419
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;
1465
1466 case DTV_LNA:
1467 tvp->u.data = c->lna;
1468 break;
1469
1470
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;
1495 default:
1496 dev_dbg(fe->dvb->device,
1497 "%s: FE property %d doesn't exist\n",
1498 __func__, tvp->cmd);
1499 return -EINVAL;
1500 }
1501
1502
1503 if (fe->ops.get_property) {
1504 r = fe->ops.get_property(fe, tvp);
1505 if (r < 0)
1506 return r;
1507 }
1508
1509 dtv_property_dump(fe, false, tvp);
1510
1511 return 0;
1512}
1513
1514static int dtv_set_frontend(struct dvb_frontend *fe);
1515
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
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536static int emulate_delivery_system(struct dvb_frontend *fe, u32 delsys)
1537{
1538 int i;
1539 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1540
1541 c->delivery_system = delsys;
1542
1543
1544
1545
1546 if (c->delivery_system == SYS_ISDBT) {
1547 dev_dbg(fe->dvb->device,
1548 "%s: Using defaults for SYS_ISDBT\n",
1549 __func__);
1550
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;
1565 }
1566 }
1567 dev_dbg(fe->dvb->device, "%s: change delivery system on cache to %d\n",
1568 __func__, c->delivery_system);
1569
1570 return 0;
1571}
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
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
1600
1601
1602
1603
1604 if (desired_system == SYS_UNDEFINED)
1605 desired_system = fe->ops.delsys[0];
1606
1607
1608
1609
1610
1611
1612 ncaps = 0;
1613 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) {
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
1625
1626
1627
1628
1629
1630
1631 if (!is_dvbv3_delsys(desired_system)) {
1632 dev_dbg(fe->dvb->device,
1633 "%s: Delivery system %d not supported.\n",
1634 __func__, desired_system);
1635 return -EINVAL;
1636 }
1637
1638 type = dvbv3_type(desired_system);
1639
1640
1641
1642
1643
1644 ncaps = 0;
1645 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) {
1646 if (dvbv3_type(fe->ops.delsys[ncaps]) == type)
1647 delsys = fe->ops.delsys[ncaps];
1648 ncaps++;
1649 }
1650
1651
1652 if (delsys == SYS_UNDEFINED) {
1653 dev_dbg(fe->dvb->device,
1654 "%s: Delivery system %d not supported on emulation mode.\n",
1655 __func__, desired_system);
1656 return -EINVAL;
1657 }
1658
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);
1664}
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694static int dvbv3_set_delivery_system(struct dvb_frontend *fe)
1695{
1696 int ncaps;
1697 u32 delsys = SYS_UNDEFINED;
1698 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1699
1700
1701 if (c->delivery_system == SYS_UNDEFINED)
1702 c->delivery_system = fe->ops.delsys[0];
1703
1704
1705
1706
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
1715
1716
1717
1718
1719 ncaps = 0;
1720 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) {
1721 if (dvbv3_type(fe->ops.delsys[ncaps]) != DVBV3_UNKNOWN) {
1722 delsys = fe->ops.delsys[ncaps];
1723 break;
1724 }
1725 ncaps++;
1726 }
1727 if (delsys == SYS_UNDEFINED) {
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;
1732 }
1733 return emulate_delivery_system(fe, delsys);
1734}
1735
1736static int dtv_property_process_set(struct dvb_frontend *fe,
1737 struct dtv_property *tvp,
1738 struct file *file)
1739{
1740 int r = 0;
1741 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1742
1743
1744 if (fe->ops.set_property) {
1745 r = fe->ops.set_property(fe, tvp);
1746 if (r < 0)
1747 return r;
1748 }
1749
1750 dtv_property_dump(fe, true, tvp);
1751
1752 switch(tvp->cmd) {
1753 case DTV_CLEAR:
1754
1755
1756
1757
1758 dvb_frontend_clear_cache(fe);
1759 break;
1760 case DTV_TUNE:
1761
1762
1763
1764
1765 c->state = tvp->cmd;
1766 dev_dbg(fe->dvb->device, "%s: Finalised property cache\n",
1767 __func__);
1768
1769 r = dtv_set_frontend(fe);
1770 break;
1771 case DTV_FREQUENCY:
1772 c->frequency = tvp->u.data;
1773 break;
1774 case DTV_MODULATION:
1775 c->modulation = tvp->u.data;
1776 break;
1777 case DTV_BANDWIDTH_HZ:
1778 c->bandwidth_hz = tvp->u.data;
1779 break;
1780 case DTV_INVERSION:
1781 c->inversion = tvp->u.data;
1782 break;
1783 case DTV_SYMBOL_RATE:
1784 c->symbol_rate = tvp->u.data;
1785 break;
1786 case DTV_INNER_FEC:
1787 c->fec_inner = tvp->u.data;
1788 break;
1789 case DTV_PILOT:
1790 c->pilot = tvp->u.data;
1791 break;
1792 case DTV_ROLLOFF:
1793 c->rolloff = tvp->u.data;
1794 break;
1795 case DTV_DELIVERY_SYSTEM:
1796 r = dvbv5_set_delivery_system(fe, tvp->u.data);
1797 break;
1798 case DTV_VOLTAGE:
1799 c->voltage = tvp->u.data;
1800 r = dvb_frontend_ioctl_legacy(file, FE_SET_VOLTAGE,
1801 (void *)c->voltage);
1802 break;
1803 case DTV_TONE:
1804 c->sectone = tvp->u.data;
1805 r = dvb_frontend_ioctl_legacy(file, FE_SET_TONE,
1806 (void *)c->sectone);
1807 break;
1808 case DTV_CODE_RATE_HP:
1809 c->code_rate_HP = tvp->u.data;
1810 break;
1811 case DTV_CODE_RATE_LP:
1812 c->code_rate_LP = tvp->u.data;
1813 break;
1814 case DTV_GUARD_INTERVAL:
1815 c->guard_interval = tvp->u.data;
1816 break;
1817 case DTV_TRANSMISSION_MODE:
1818 c->transmission_mode = tvp->u.data;
1819 break;
1820 case DTV_HIERARCHY:
1821 c->hierarchy = tvp->u.data;
1822 break;
1823 case DTV_INTERLEAVING:
1824 c->interleaving = tvp->u.data;
1825 break;
1826
1827
1828 case DTV_ISDBT_PARTIAL_RECEPTION:
1829 c->isdbt_partial_reception = tvp->u.data;
1830 break;
1831 case DTV_ISDBT_SOUND_BROADCASTING:
1832 c->isdbt_sb_mode = tvp->u.data;
1833 break;
1834 case DTV_ISDBT_SB_SUBCHANNEL_ID:
1835 c->isdbt_sb_subchannel = tvp->u.data;
1836 break;
1837 case DTV_ISDBT_SB_SEGMENT_IDX:
1838 c->isdbt_sb_segment_idx = tvp->u.data;
1839 break;
1840 case DTV_ISDBT_SB_SEGMENT_COUNT:
1841 c->isdbt_sb_segment_count = tvp->u.data;
1842 break;
1843 case DTV_ISDBT_LAYER_ENABLED:
1844 c->isdbt_layer_enabled = tvp->u.data;
1845 break;
1846 case DTV_ISDBT_LAYERA_FEC:
1847 c->layer[0].fec = tvp->u.data;
1848 break;
1849 case DTV_ISDBT_LAYERA_MODULATION:
1850 c->layer[0].modulation = tvp->u.data;
1851 break;
1852 case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
1853 c->layer[0].segment_count = tvp->u.data;
1854 break;
1855 case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
1856 c->layer[0].interleaving = tvp->u.data;
1857 break;
1858 case DTV_ISDBT_LAYERB_FEC:
1859 c->layer[1].fec = tvp->u.data;
1860 break;
1861 case DTV_ISDBT_LAYERB_MODULATION:
1862 c->layer[1].modulation = tvp->u.data;
1863 break;
1864 case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
1865 c->layer[1].segment_count = tvp->u.data;
1866 break;
1867 case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
1868 c->layer[1].interleaving = tvp->u.data;
1869 break;
1870 case DTV_ISDBT_LAYERC_FEC:
1871 c->layer[2].fec = tvp->u.data;
1872 break;
1873 case DTV_ISDBT_LAYERC_MODULATION:
1874 c->layer[2].modulation = tvp->u.data;
1875 break;
1876 case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
1877 c->layer[2].segment_count = tvp->u.data;
1878 break;
1879 case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
1880 c->layer[2].interleaving = tvp->u.data;
1881 break;
1882
1883
1884 case DTV_STREAM_ID:
1885 case DTV_DVBT2_PLP_ID_LEGACY:
1886 c->stream_id = tvp->u.data;
1887 break;
1888
1889
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
1897 case DTV_LNA:
1898 c->lna = tvp->u.data;
1899 if (fe->ops.set_lna)
1900 r = fe->ops.set_lna(fe);
1901 if (r < 0)
1902 c->lna = LNA_AUTO;
1903 break;
1904
1905 default:
1906 return -EINVAL;
1907 }
1908
1909 return r;
1910}
1911
1912static int dvb_frontend_ioctl(struct file *file,
1913 unsigned int cmd, void *parg)
1914{
1915 struct dvb_device *dvbdev = file->private_data;
1916 struct dvb_frontend *fe = dvbdev->priv;
1917 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1918 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1919 int err = -EOPNOTSUPP;
1920
1921 dev_dbg(fe->dvb->device, "%s: (%d)\n", __func__, _IOC_NR(cmd));
1922 if (down_interruptible(&fepriv->sem))
1923 return -ERESTARTSYS;
1924
1925 if (fe->exit != DVB_FE_NO_EXIT) {
1926 up(&fepriv->sem);
1927 return -ENODEV;
1928 }
1929
1930 if ((file->f_flags & O_ACCMODE) == O_RDONLY &&
1931 (_IOC_DIR(cmd) != _IOC_READ || cmd == FE_GET_EVENT ||
1932 cmd == FE_DISEQC_RECV_SLAVE_REPLY)) {
1933 up(&fepriv->sem);
1934 return -EPERM;
1935 }
1936
1937 if ((cmd == FE_SET_PROPERTY) || (cmd == FE_GET_PROPERTY))
1938 err = dvb_frontend_ioctl_properties(file, cmd, parg);
1939 else {
1940 c->state = DTV_UNDEFINED;
1941 err = dvb_frontend_ioctl_legacy(file, cmd, parg);
1942 }
1943
1944 up(&fepriv->sem);
1945 return err;
1946}
1947
1948static int dvb_frontend_ioctl_properties(struct file *file,
1949 unsigned int cmd, void *parg)
1950{
1951 struct dvb_device *dvbdev = file->private_data;
1952 struct dvb_frontend *fe = dvbdev->priv;
1953 struct dvb_frontend_private *fepriv = fe->frontend_priv;
1954 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1955 int err = 0;
1956
1957 struct dtv_properties *tvps = parg;
1958 struct dtv_property *tvp = NULL;
1959 int i;
1960
1961 dev_dbg(fe->dvb->device, "%s:\n", __func__);
1962
1963 if (cmd == FE_SET_PROPERTY) {
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);
1966
1967
1968
1969 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS))
1970 return -EINVAL;
1971
1972 tvp = memdup_user(tvps->props, tvps->num * sizeof(*tvp));
1973 if (IS_ERR(tvp))
1974 return PTR_ERR(tvp);
1975
1976 for (i = 0; i < tvps->num; i++) {
1977 err = dtv_property_process_set(fe, tvp + i, file);
1978 if (err < 0)
1979 goto out;
1980 (tvp + i)->result = err;
1981 }
1982
1983 if (c->state == DTV_TUNE)
1984 dev_dbg(fe->dvb->device, "%s: Property cache is full, tuning\n", __func__);
1985
1986 } else if (cmd == FE_GET_PROPERTY) {
1987 struct dtv_frontend_properties getp = fe->dtv_property_cache;
1988
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);
1991
1992
1993
1994 if ((tvps->num == 0) || (tvps->num > DTV_IOCTL_MAX_MSGS))
1995 return -EINVAL;
1996
1997 tvp = memdup_user(tvps->props, tvps->num * sizeof(*tvp));
1998 if (IS_ERR(tvp))
1999 return PTR_ERR(tvp);
2000
2001
2002
2003
2004
2005
2006
2007 if (fepriv->state != FESTATE_IDLE) {
2008 err = dtv_get_frontend(fe, &getp, NULL);
2009 if (err < 0)
2010 goto out;
2011 }
2012 for (i = 0; i < tvps->num; i++) {
2013 err = dtv_property_process_get(fe, &getp, tvp + i, file);
2014 if (err < 0)
2015 goto out;
2016 (tvp + i)->result = err;
2017 }
2018
2019 if (copy_to_user((void __user *)tvps->props, tvp,
2020 tvps->num * sizeof(struct dtv_property))) {
2021 err = -EFAULT;
2022 goto out;
2023 }
2024
2025 } else
2026 err = -EOPNOTSUPP;
2027
2028out:
2029 kfree(tvp);
2030 return err;
2031}
2032
2033static int dtv_set_frontend(struct dvb_frontend *fe)
2034{
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;
2038 u32 rolloff = 0;
2039
2040 if (dvb_frontend_check_parameters(fe) < 0)
2041 return -EINVAL;
2042
2043
2044
2045
2046
2047
2048 dtv_property_legacy_params_sync(fe, c, &fepriv->parameters_out);
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
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;
2080 case SYS_DVBS:
2081 case SYS_TURBO:
2082 case SYS_ISDBS:
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;
2098 default:
2099 break;
2100 }
2101 if (rolloff)
2102 c->bandwidth_hz = mult_frac(c->symbol_rate, rolloff, 100);
2103
2104
2105 if (dvb_force_auto_inversion)
2106 c->inversion = INVERSION_AUTO;
2107
2108
2109
2110
2111
2112 if (c->hierarchy == HIERARCHY_NONE && c->code_rate_LP == FEC_NONE)
2113 c->code_rate_LP = FEC_AUTO;
2114
2115
2116 memset(&fetunesettings, 0, sizeof(struct dvb_frontend_tune_settings));
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
2123 switch (c->delivery_system) {
2124 case SYS_DVBS:
2125 case SYS_DVBS2:
2126 case SYS_ISDBS:
2127 case SYS_TURBO:
2128 case SYS_DVBC_ANNEX_A:
2129 case SYS_DVBC_ANNEX_C:
2130 fepriv->min_delay = HZ / 20;
2131 fepriv->step_size = c->symbol_rate / 16000;
2132 fepriv->max_drift = c->symbol_rate / 2000;
2133 break;
2134 case SYS_DVBT:
2135 case SYS_DVBT2:
2136 case SYS_ISDBT:
2137 case SYS_DTMB:
2138 fepriv->min_delay = HZ / 20;
2139 fepriv->step_size = fe->ops.info.frequency_stepsize * 2;
2140 fepriv->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1;
2141 break;
2142 default:
2143
2144
2145
2146
2147 fepriv->min_delay = HZ / 20;
2148 fepriv->step_size = 0;
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
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
2170static int dvb_frontend_ioctl_legacy(struct file *file,
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;
2176 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
2177 int err = -EOPNOTSUPP;
2178
2179 switch (cmd) {
2180 case FE_GET_INFO: {
2181 struct dvb_frontend_info* info = parg;
2182
2183 memcpy(info, &fe->ops.info, sizeof(struct dvb_frontend_info));
2184 dvb_frontend_get_frequency_limits(fe, &info->frequency_min, &info->frequency_max);
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197 switch (dvbv3_type(c->delivery_system)) {
2198 case DVBV3_QPSK:
2199 info->type = FE_QPSK;
2200 break;
2201 case DVBV3_ATSC:
2202 info->type = FE_ATSC;
2203 break;
2204 case DVBV3_QAM:
2205 info->type = FE_QAM;
2206 break;
2207 case DVBV3_OFDM:
2208 info->type = FE_OFDM;
2209 break;
2210 default:
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);
2214 fe->ops.info.type = FE_OFDM;
2215 }
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);
2218
2219
2220 if (!(fepriv->tune_mode_flags & FE_TUNE_MODE_ONESHOT))
2221 info->caps |= FE_CAN_INVERSION_AUTO;
2222 err = 0;
2223 break;
2224 }
2225
2226 case FE_READ_STATUS: {
2227 enum fe_status *status = parg;
2228
2229
2230
2231 if (fepriv->state == FESTATE_RETUNE ||
2232 fepriv->state == FESTATE_ERROR) {
2233 err=0;
2234 *status = 0;
2235 break;
2236 }
2237
2238 if (fe->ops.read_status)
2239 err = fe->ops.read_status(fe, status);
2240 break;
2241 }
2242
2243 case FE_READ_BER:
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 }
2250 break;
2251
2252 case FE_READ_SIGNAL_STRENGTH:
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 }
2259 break;
2260
2261 case FE_READ_SNR:
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 }
2268 break;
2269
2270 case FE_READ_UNCORRECTED_BLOCKS:
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 }
2277 break;
2278
2279 case FE_DISEQC_RESET_OVERLOAD:
2280 if (fe->ops.diseqc_reset_overload) {
2281 err = fe->ops.diseqc_reset_overload(fe);
2282 fepriv->state = FESTATE_DISEQC;
2283 fepriv->status = 0;
2284 }
2285 break;
2286
2287 case FE_DISEQC_SEND_MASTER_CMD:
2288 if (fe->ops.diseqc_send_master_cmd) {
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);
2296 fepriv->state = FESTATE_DISEQC;
2297 fepriv->status = 0;
2298 }
2299 break;
2300
2301 case FE_DISEQC_SEND_BURST:
2302 if (fe->ops.diseqc_send_burst) {
2303 err = fe->ops.diseqc_send_burst(fe,
2304 (enum fe_sec_mini_cmd)parg);
2305 fepriv->state = FESTATE_DISEQC;
2306 fepriv->status = 0;
2307 }
2308 break;
2309
2310 case FE_SET_TONE:
2311 if (fe->ops.set_tone) {
2312 err = fe->ops.set_tone(fe,
2313 (enum fe_sec_tone_mode)parg);
2314 fepriv->tone = (enum fe_sec_tone_mode)parg;
2315 fepriv->state = FESTATE_DISEQC;
2316 fepriv->status = 0;
2317 }
2318 break;
2319
2320 case FE_SET_VOLTAGE:
2321 if (fe->ops.set_voltage) {
2322 err = fe->ops.set_voltage(fe,
2323 (enum fe_sec_voltage)parg);
2324 fepriv->voltage = (enum fe_sec_voltage)parg;
2325 fepriv->state = FESTATE_DISEQC;
2326 fepriv->status = 0;
2327 }
2328 break;
2329
2330 case FE_DISHNETWORK_SEND_LEGACY_CMD:
2331 if (fe->ops.dishnetwork_send_legacy_command) {
2332 err = fe->ops.dishnetwork_send_legacy_command(fe,
2333 (unsigned long)parg);
2334 fepriv->state = FESTATE_DISEQC;
2335 fepriv->status = 0;
2336 } else if (fe->ops.set_voltage) {
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353 unsigned long swcmd = ((unsigned long) parg) << 1;
2354 ktime_t nexttime;
2355 ktime_t tv[10];
2356 int i;
2357 u8 last = 1;
2358 if (dvb_frontend_debug)
2359 printk("%s switch command: 0x%04lx\n", __func__, swcmd);
2360 nexttime = ktime_get_boottime();
2361 if (dvb_frontend_debug)
2362 tv[0] = nexttime;
2363
2364
2365
2366 fe->ops.set_voltage(fe, SEC_VOLTAGE_18);
2367 dvb_frontend_sleep_until(&nexttime, 32000);
2368
2369 for (i = 0; i < 9; i++) {
2370 if (dvb_frontend_debug)
2371 tv[i+1] = ktime_get_boottime();
2372 if ((swcmd & 0x01) != last) {
2373
2374 fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18);
2375 last = (last) ? 0 : 1;
2376 }
2377 swcmd = swcmd >> 1;
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",
2383 __func__, fe->dvb->num);
2384 for (i = 1; i < 10; i++)
2385 printk("%d: %d\n", i,
2386 (int) ktime_us_delta(tv[i], tv[i-1]));
2387 }
2388 err = 0;
2389 fepriv->state = FESTATE_DISEQC;
2390 fepriv->status = 0;
2391 }
2392 break;
2393
2394 case FE_DISEQC_RECV_SLAVE_REPLY:
2395 if (fe->ops.diseqc_recv_slave_reply)
2396 err = fe->ops.diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg);
2397 break;
2398
2399 case FE_ENABLE_HIGH_LNB_VOLTAGE:
2400 if (fe->ops.enable_high_lnb_voltage)
2401 err = fe->ops.enable_high_lnb_voltage(fe, (long) parg);
2402 break;
2403
2404 case FE_SET_FRONTEND:
2405 err = dvbv3_set_delivery_system(fe);
2406 if (err)
2407 break;
2408
2409 err = dtv_property_cache_sync(fe, c, parg);
2410 if (err)
2411 break;
2412 err = dtv_set_frontend(fe);
2413 break;
2414 case FE_GET_EVENT:
2415 err = dvb_frontend_get_event (fe, parg, file->f_flags);
2416 break;
2417
2418 case FE_GET_FRONTEND: {
2419 struct dtv_frontend_properties getp = fe->dtv_property_cache;
2420
2421
2422
2423
2424
2425
2426
2427 err = dtv_get_frontend(fe, &getp, parg);
2428 break;
2429 }
2430 case FE_SET_FRONTEND_TUNE_MODE:
2431 fepriv->tune_mode_flags = (unsigned long) parg;
2432 err = 0;
2433 break;
2434 }
2435
2436 return err;
2437}
2438
2439
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;
2444 struct dvb_frontend_private *fepriv = fe->frontend_priv;
2445
2446 dev_dbg_ratelimited(fe->dvb->device, "%s:\n", __func__);
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;
2460 struct dvb_frontend_private *fepriv = fe->frontend_priv;
2461 struct dvb_adapter *adapter = fe->dvb;
2462 int ret;
2463
2464 dev_dbg(fe->dvb->device, "%s:\n", __func__);
2465 if (fe->exit == DVB_FE_DEVICE_REMOVED)
2466 return -ENODEV;
2467
2468 if (adapter->mfe_shared) {
2469 mutex_lock (&adapter->mfe_lock);
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;
2489 }
2490 }
2491
2492 mutex_lock (&adapter->mfe_lock);
2493 if(adapter->mfe_dvbdev != dvbdev) {
2494 mfedev = adapter->mfe_dvbdev;
2495 mfe = mfedev->priv;
2496 mfepriv = mfe->frontend_priv;
2497 if (mfedev->users != -1 ||
2498 mfepriv->thread != NULL) {
2499 mutex_unlock (&adapter->mfe_lock);
2500 return -EBUSY;
2501 }
2502 adapter->mfe_dvbdev = dvbdev;
2503 }
2504 }
2505 }
2506
2507 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) {
2508 if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0)
2509 goto err0;
2510
2511
2512
2513
2514
2515
2516
2517 fepriv->reinitialise = 1;
2518 }
2519
2520 if ((ret = dvb_generic_open (inode, file)) < 0)
2521 goto err1;
2522
2523 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
2524
2525 fepriv->tune_mode_flags &= ~FE_TUNE_MODE_ONESHOT;
2526 fepriv->tone = -1;
2527 fepriv->voltage = -1;
2528
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
2540 ret = dvb_frontend_start (fe);
2541 if (ret)
2542 goto err3;
2543
2544
2545 fepriv->events.eventr = fepriv->events.eventw = 0;
2546 }
2547
2548 dvb_frontend_private_get(fepriv);
2549
2550 if (adapter->mfe_shared)
2551 mutex_unlock (&adapter->mfe_lock);
2552 return ret;
2553
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);
2558err2:
2559#endif
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);
2564err0:
2565 if (adapter->mfe_shared)
2566 mutex_unlock (&adapter->mfe_lock);
2567 return ret;
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;
2574 struct dvb_frontend_private *fepriv = fe->frontend_priv;
2575 int ret;
2576
2577 dev_dbg(fe->dvb->device, "%s:\n", __func__);
2578
2579 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
2580 fepriv->release_jiffies = jiffies;
2581 mb();
2582 }
2583
2584 ret = dvb_generic_release (inode, file);
2585
2586 if (dvbdev->users == -1) {
2587 wake_up(&fepriv->wait_queue);
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
2592 if (fe->exit != DVB_FE_NO_EXIT)
2593 wake_up(&dvbdev->wait_queue);
2594 if (fe->ops.ts_bus_ctrl)
2595 fe->ops.ts_bus_ctrl(fe, 0);
2596 }
2597
2598 dvb_frontend_private_put(fepriv);
2599
2600 return ret;
2601}
2602
2603static const struct file_operations dvb_frontend_fops = {
2604 .owner = THIS_MODULE,
2605 .unlocked_ioctl = dvb_generic_ioctl,
2606 .poll = dvb_frontend_poll,
2607 .open = dvb_frontend_open,
2608 .release = dvb_frontend_release,
2609 .llseek = noop_llseek,
2610};
2611
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
2619 if (fe->ops.tuner_ops.suspend)
2620 ret = fe->ops.tuner_ops.suspend(fe);
2621 else if (fe->ops.tuner_ops.sleep)
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
2639 fe->exit = DVB_FE_DEVICE_RESUME;
2640 if (fe->ops.init)
2641 ret = fe->ops.init(fe);
2642
2643 if (fe->ops.tuner_ops.resume)
2644 ret = fe->ops.tuner_ops.resume(fe);
2645 else if (fe->ops.tuner_ops.init)
2646 ret = fe->ops.tuner_ops.init(fe);
2647
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
2653 fe->exit = DVB_FE_NO_EXIT;
2654 fepriv->state = FESTATE_RETUNE;
2655 dvb_frontend_wakeup(fe);
2656
2657 return ret;
2658}
2659EXPORT_SYMBOL(dvb_frontend_resume);
2660
2661int dvb_register_frontend(struct dvb_adapter* dvb,
2662 struct dvb_frontend* fe)
2663{
2664 struct dvb_frontend_private *fepriv;
2665 const struct dvb_device dvbdev_template = {
2666 .users = ~0,
2667 .writers = 1,
2668 .readers = (~0)-1,
2669 .fops = &dvb_frontend_fops,
2670#if defined(CONFIG_MEDIA_CONTROLLER_DVB)
2671 .name = fe->ops.info.name,
2672#endif
2673 .kernel_ioctl = dvb_frontend_ioctl
2674 };
2675
2676 dev_dbg(dvb->device, "%s:\n", __func__);
2677
2678 if (mutex_lock_interruptible(&frontend_mutex))
2679 return -ERESTARTSYS;
2680
2681 fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL);
2682 if (fe->frontend_priv == NULL) {
2683 mutex_unlock(&frontend_mutex);
2684 return -ENOMEM;
2685 }
2686 fepriv = fe->frontend_priv;
2687
2688 kref_init(&fepriv->refcount);
2689
2690 sema_init(&fepriv->sem, 1);
2691 init_waitqueue_head (&fepriv->wait_queue);
2692 init_waitqueue_head (&fepriv->events.wait_queue);
2693 mutex_init(&fepriv->events.mtx);
2694 fe->dvb = dvb;
2695 fepriv->inversion = INVERSION_OFF;
2696
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);
2700
2701 dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template,
2702 fe, DVB_DEVICE_FRONTEND, 0);
2703
2704
2705
2706
2707
2708
2709 fe->dtv_property_cache.delivery_system = fe->ops.delsys[0];
2710 dvb_frontend_clear_cache(fe);
2711
2712 mutex_unlock(&frontend_mutex);
2713 return 0;
2714}
2715EXPORT_SYMBOL(dvb_register_frontend);
2716
2717int dvb_unregister_frontend(struct dvb_frontend* fe)
2718{
2719 struct dvb_frontend_private *fepriv = fe->frontend_priv;
2720 dev_dbg(fe->dvb->device, "%s:\n", __func__);
2721
2722 mutex_lock(&frontend_mutex);
2723 dvb_frontend_stop (fe);
2724 dvb_unregister_device (fepriv->dvbdev);
2725
2726
2727 mutex_unlock(&frontend_mutex);
2728 dvb_frontend_private_put(fepriv);
2729 return 0;
2730}
2731EXPORT_SYMBOL(dvb_unregister_frontend);
2732
2733#ifdef CONFIG_MEDIA_ATTACH
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);
2740 dvb_detach(fe->ops.release_sec);
2741 }
2742 if (fe->ops.tuner_ops.release) {
2743 fe->ops.tuner_ops.release(fe);
2744 dvb_detach(fe->ops.tuner_ops.release);
2745 }
2746 if (fe->ops.analog_ops.release) {
2747 fe->ops.analog_ops.release(fe);
2748 dvb_detach(fe->ops.analog_ops.release);
2749 }
2750 ptr = (void*)fe->ops.release;
2751 if (ptr) {
2752 fe->ops.release(fe);
2753 dvb_detach(ptr);
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);
2763 if (fe->ops.analog_ops.release)
2764 fe->ops.analog_ops.release(fe);
2765 if (fe->ops.release)
2766 fe->ops.release(fe);
2767}
2768#endif
2769EXPORT_SYMBOL(dvb_frontend_detach);
2770