2 * dvb_frontend.c: DVB frontend tuning interface/thread
5 * Copyright (C) 1999-2001 Ralph Metzler
8 * for convergence integrated media GmbH
10 * Copyright (C) 2004 Andrew de Quincey (tuning thread cleanup)
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
28 #include <linux/string.h>
29 #include <linux/kernel.h>
30 #include <linux/sched.h>
31 #include <linux/wait.h>
32 #include <linux/slab.h>
33 #include <linux/poll.h>
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/list.h>
37 #include <linux/suspend.h>
38 #include <linux/jiffies.h>
39 #include <asm/processor.h>
41 #include "dvb_frontend.h"
44 static int dvb_frontend_debug
;
45 static int dvb_shutdown_timeout
= 5;
46 static int dvb_force_auto_inversion
;
47 static int dvb_override_tune_delay
;
48 static int dvb_powerdown_on_sleep
= 1;
50 module_param_named(frontend_debug
, dvb_frontend_debug
, int, 0644);
51 MODULE_PARM_DESC(frontend_debug
, "Turn on/off frontend core debugging (default:off).");
52 module_param(dvb_shutdown_timeout
, int, 0644);
53 MODULE_PARM_DESC(dvb_shutdown_timeout
, "wait <shutdown_timeout> seconds after close() before suspending hardware");
54 module_param(dvb_force_auto_inversion
, int, 0644);
55 MODULE_PARM_DESC(dvb_force_auto_inversion
, "0: normal (default), 1: INVERSION_AUTO forced always");
56 module_param(dvb_override_tune_delay
, int, 0644);
57 MODULE_PARM_DESC(dvb_override_tune_delay
, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt");
58 module_param(dvb_powerdown_on_sleep
, int, 0644);
59 MODULE_PARM_DESC(dvb_powerdown_on_sleep
, "0: do not power down, 1: turn LNB volatage off on sleep (default)");
61 #define dprintk if (dvb_frontend_debug) printk
63 #define FESTATE_IDLE 1
64 #define FESTATE_RETUNE 2
65 #define FESTATE_TUNING_FAST 4
66 #define FESTATE_TUNING_SLOW 8
67 #define FESTATE_TUNED 16
68 #define FESTATE_ZIGZAG_FAST 32
69 #define FESTATE_ZIGZAG_SLOW 64
70 #define FESTATE_DISEQC 128
71 #define FESTATE_WAITFORLOCK (FESTATE_TUNING_FAST | FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW | FESTATE_DISEQC)
72 #define FESTATE_SEARCHING_FAST (FESTATE_TUNING_FAST | FESTATE_ZIGZAG_FAST)
73 #define FESTATE_SEARCHING_SLOW (FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_SLOW)
74 #define FESTATE_LOSTLOCK (FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW)
76 * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling.
77 * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune.
78 * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress.
79 * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower.
80 * FESTATE_TUNED. The frontend has successfully locked on.
81 * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it.
82 * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower.
83 * FESTATE_DISEQC. A DISEQC command has just been issued.
84 * FESTATE_WAITFORLOCK. When we're waiting for a lock.
85 * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan.
86 * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan.
87 * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again.
90 static DEFINE_MUTEX(frontend_mutex
);
92 struct dvb_frontend_private
{
94 /* thread/frontend values */
95 struct dvb_device
*dvbdev
;
96 struct dvb_frontend_parameters parameters
;
97 struct dvb_fe_events events
;
99 struct list_head list_head
;
100 wait_queue_head_t wait_queue
;
102 unsigned long release_jiffies
;
106 unsigned long tune_mode_flags
;
108 unsigned int reinitialise
;
112 /* swzigzag values */
114 unsigned int bending
;
116 unsigned int inversion
;
117 unsigned int auto_step
;
118 unsigned int auto_sub_step
;
119 unsigned int started_auto_step
;
120 unsigned int min_delay
;
121 unsigned int max_drift
;
122 unsigned int step_size
;
124 unsigned int check_wrapped
;
127 static void dvb_frontend_wakeup(struct dvb_frontend
*fe
);
129 static void dvb_frontend_add_event(struct dvb_frontend
*fe
, fe_status_t status
)
131 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
132 struct dvb_fe_events
*events
= &fepriv
->events
;
133 struct dvb_frontend_event
*e
;
136 dprintk ("%s\n", __FUNCTION__
);
138 if (down_interruptible (&events
->sem
))
141 wp
= (events
->eventw
+ 1) % MAX_EVENT
;
143 if (wp
== events
->eventr
) {
144 events
->overflow
= 1;
145 events
->eventr
= (events
->eventr
+ 1) % MAX_EVENT
;
148 e
= &events
->events
[events
->eventw
];
150 memcpy (&e
->parameters
, &fepriv
->parameters
,
151 sizeof (struct dvb_frontend_parameters
));
153 if (status
& FE_HAS_LOCK
)
154 if (fe
->ops
->get_frontend
)
155 fe
->ops
->get_frontend(fe
, &e
->parameters
);
163 wake_up_interruptible (&events
->wait_queue
);
166 static int dvb_frontend_get_event(struct dvb_frontend
*fe
,
167 struct dvb_frontend_event
*event
, int flags
)
169 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
170 struct dvb_fe_events
*events
= &fepriv
->events
;
172 dprintk ("%s\n", __FUNCTION__
);
174 if (events
->overflow
) {
175 events
->overflow
= 0;
179 if (events
->eventw
== events
->eventr
) {
182 if (flags
& O_NONBLOCK
)
187 ret
= wait_event_interruptible (events
->wait_queue
,
188 events
->eventw
!= events
->eventr
);
190 if (down_interruptible (&fepriv
->sem
))
197 if (down_interruptible (&events
->sem
))
200 memcpy (event
, &events
->events
[events
->eventr
],
201 sizeof(struct dvb_frontend_event
));
203 events
->eventr
= (events
->eventr
+ 1) % MAX_EVENT
;
210 static void dvb_frontend_init(struct dvb_frontend
*fe
)
212 dprintk ("DVB: initialising frontend %i (%s)...\n",
220 void dvb_frontend_reinitialise(struct dvb_frontend
*fe
)
222 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
224 fepriv
->reinitialise
= 1;
225 dvb_frontend_wakeup(fe
);
227 EXPORT_SYMBOL(dvb_frontend_reinitialise
);
229 static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private
*fepriv
, int locked
)
233 dprintk ("%s\n", __FUNCTION__
);
236 (fepriv
->quality
) = (fepriv
->quality
* 220 + 36*256) / 256;
238 (fepriv
->quality
) = (fepriv
->quality
* 220 + 0) / 256;
240 q2
= fepriv
->quality
- 128;
243 fepriv
->delay
= fepriv
->min_delay
+ q2
* HZ
/ (128*128);
247 * Performs automatic twiddling of frontend parameters.
249 * @param fe The frontend concerned.
250 * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT
251 * @returns Number of complete iterations that have been performed.
253 static int dvb_frontend_swzigzag_autotune(struct dvb_frontend
*fe
, int check_wrapped
)
257 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
258 int original_inversion
= fepriv
->parameters
.inversion
;
259 u32 original_frequency
= fepriv
->parameters
.frequency
;
261 /* are we using autoinversion? */
262 autoinversion
= ((!(fe
->ops
->info
.caps
& FE_CAN_INVERSION_AUTO
)) &&
263 (fepriv
->parameters
.inversion
== INVERSION_AUTO
));
265 /* setup parameters correctly */
267 /* calculate the lnb_drift */
268 fepriv
->lnb_drift
= fepriv
->auto_step
* fepriv
->step_size
;
270 /* wrap the auto_step if we've exceeded the maximum drift */
271 if (fepriv
->lnb_drift
> fepriv
->max_drift
) {
272 fepriv
->auto_step
= 0;
273 fepriv
->auto_sub_step
= 0;
274 fepriv
->lnb_drift
= 0;
277 /* perform inversion and +/- zigzag */
278 switch(fepriv
->auto_sub_step
) {
280 /* try with the current inversion and current drift setting */
285 if (!autoinversion
) break;
287 fepriv
->inversion
= (fepriv
->inversion
== INVERSION_OFF
) ? INVERSION_ON
: INVERSION_OFF
;
292 if (fepriv
->lnb_drift
== 0) break;
294 fepriv
->lnb_drift
= -fepriv
->lnb_drift
;
299 if (fepriv
->lnb_drift
== 0) break;
300 if (!autoinversion
) break;
302 fepriv
->inversion
= (fepriv
->inversion
== INVERSION_OFF
) ? INVERSION_ON
: INVERSION_OFF
;
303 fepriv
->lnb_drift
= -fepriv
->lnb_drift
;
309 fepriv
->auto_sub_step
= -1; /* it'll be incremented to 0 in a moment */
313 if (!ready
) fepriv
->auto_sub_step
++;
316 /* if this attempt would hit where we started, indicate a complete
317 * iteration has occurred */
318 if ((fepriv
->auto_step
== fepriv
->started_auto_step
) &&
319 (fepriv
->auto_sub_step
== 0) && check_wrapped
) {
323 dprintk("%s: drift:%i inversion:%i auto_step:%i "
324 "auto_sub_step:%i started_auto_step:%i\n",
325 __FUNCTION__
, fepriv
->lnb_drift
, fepriv
->inversion
,
326 fepriv
->auto_step
, fepriv
->auto_sub_step
, fepriv
->started_auto_step
);
328 /* set the frontend itself */
329 fepriv
->parameters
.frequency
+= fepriv
->lnb_drift
;
331 fepriv
->parameters
.inversion
= fepriv
->inversion
;
332 if (fe
->ops
->set_frontend
)
333 fe
->ops
->set_frontend(fe
, &fepriv
->parameters
);
335 fepriv
->parameters
.frequency
= original_frequency
;
336 fepriv
->parameters
.inversion
= original_inversion
;
338 fepriv
->auto_sub_step
++;
342 static void dvb_frontend_swzigzag(struct dvb_frontend
*fe
)
345 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
347 /* if we've got no parameters, just keep idling */
348 if (fepriv
->state
& FESTATE_IDLE
) {
349 fepriv
->delay
= 3*HZ
;
354 /* in SCAN mode, we just set the frontend when asked and leave it alone */
355 if (fepriv
->tune_mode_flags
& FE_TUNE_MODE_ONESHOT
) {
356 if (fepriv
->state
& FESTATE_RETUNE
) {
357 if (fe
->ops
->set_frontend
)
358 fe
->ops
->set_frontend(fe
, &fepriv
->parameters
);
359 fepriv
->state
= FESTATE_TUNED
;
361 fepriv
->delay
= 3*HZ
;
366 /* get the frontend status */
367 if (fepriv
->state
& FESTATE_RETUNE
) {
370 if (fe
->ops
->read_status
)
371 fe
->ops
->read_status(fe
, &s
);
372 if (s
!= fepriv
->status
) {
373 dvb_frontend_add_event(fe
, s
);
378 /* if we're not tuned, and we have a lock, move to the TUNED state */
379 if ((fepriv
->state
& FESTATE_WAITFORLOCK
) && (s
& FE_HAS_LOCK
)) {
380 dvb_frontend_swzigzag_update_delay(fepriv
, s
& FE_HAS_LOCK
);
381 fepriv
->state
= FESTATE_TUNED
;
383 /* if we're tuned, then we have determined the correct inversion */
384 if ((!(fe
->ops
->info
.caps
& FE_CAN_INVERSION_AUTO
)) &&
385 (fepriv
->parameters
.inversion
== INVERSION_AUTO
)) {
386 fepriv
->parameters
.inversion
= fepriv
->inversion
;
391 /* if we are tuned already, check we're still locked */
392 if (fepriv
->state
& FESTATE_TUNED
) {
393 dvb_frontend_swzigzag_update_delay(fepriv
, s
& FE_HAS_LOCK
);
395 /* we're tuned, and the lock is still good... */
396 if (s
& FE_HAS_LOCK
) {
398 } else { /* if we _WERE_ tuned, but now don't have a lock */
399 fepriv
->state
= FESTATE_ZIGZAG_FAST
;
400 fepriv
->started_auto_step
= fepriv
->auto_step
;
401 fepriv
->check_wrapped
= 0;
405 /* don't actually do anything if we're in the LOSTLOCK state,
406 * the frontend is set to FE_CAN_RECOVER, and the max_drift is 0 */
407 if ((fepriv
->state
& FESTATE_LOSTLOCK
) &&
408 (fe
->ops
->info
.caps
& FE_CAN_RECOVER
) && (fepriv
->max_drift
== 0)) {
409 dvb_frontend_swzigzag_update_delay(fepriv
, s
& FE_HAS_LOCK
);
413 /* don't do anything if we're in the DISEQC state, since this
414 * might be someone with a motorized dish controlled by DISEQC.
415 * If its actually a re-tune, there will be a SET_FRONTEND soon enough. */
416 if (fepriv
->state
& FESTATE_DISEQC
) {
417 dvb_frontend_swzigzag_update_delay(fepriv
, s
& FE_HAS_LOCK
);
421 /* if we're in the RETUNE state, set everything up for a brand
422 * new scan, keeping the current inversion setting, as the next
423 * tune is _very_ likely to require the same */
424 if (fepriv
->state
& FESTATE_RETUNE
) {
425 fepriv
->lnb_drift
= 0;
426 fepriv
->auto_step
= 0;
427 fepriv
->auto_sub_step
= 0;
428 fepriv
->started_auto_step
= 0;
429 fepriv
->check_wrapped
= 0;
433 if ((fepriv
->state
& FESTATE_SEARCHING_FAST
) || (fepriv
->state
& FESTATE_RETUNE
)) {
434 fepriv
->delay
= fepriv
->min_delay
;
437 if (dvb_frontend_swzigzag_autotune(fe
, fepriv
->check_wrapped
)) {
438 /* OK, if we've run out of trials at the fast speed.
439 * Drop back to slow for the _next_ attempt */
440 fepriv
->state
= FESTATE_SEARCHING_SLOW
;
441 fepriv
->started_auto_step
= fepriv
->auto_step
;
444 fepriv
->check_wrapped
= 1;
446 /* if we've just retuned, enter the ZIGZAG_FAST state.
447 * This ensures we cannot return from an
448 * FE_SET_FRONTEND ioctl before the first frontend tune
450 if (fepriv
->state
& FESTATE_RETUNE
) {
451 fepriv
->state
= FESTATE_TUNING_FAST
;
456 if (fepriv
->state
& FESTATE_SEARCHING_SLOW
) {
457 dvb_frontend_swzigzag_update_delay(fepriv
, s
& FE_HAS_LOCK
);
459 /* Note: don't bother checking for wrapping; we stay in this
460 * state until we get a lock */
461 dvb_frontend_swzigzag_autotune(fe
, 0);
465 static int dvb_frontend_is_exiting(struct dvb_frontend
*fe
)
467 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
472 if (fepriv
->dvbdev
->writers
== 1)
473 if (time_after(jiffies
, fepriv
->release_jiffies
+
474 dvb_shutdown_timeout
* HZ
))
480 static int dvb_frontend_should_wakeup(struct dvb_frontend
*fe
)
482 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
484 if (fepriv
->wakeup
) {
488 return dvb_frontend_is_exiting(fe
);
491 static void dvb_frontend_wakeup(struct dvb_frontend
*fe
)
493 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
496 wake_up_interruptible(&fepriv
->wait_queue
);
499 static int dvb_frontend_thread(void *data
)
501 struct dvb_frontend
*fe
= data
;
502 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
503 unsigned long timeout
;
506 struct dvb_frontend_parameters
*params
;
508 dprintk("%s\n", __FUNCTION__
);
510 snprintf (name
, sizeof(name
), "kdvb-fe-%i", fe
->dvb
->num
);
514 sigfillset(¤t
->blocked
);
517 fepriv
->check_wrapped
= 0;
519 fepriv
->delay
= 3*HZ
;
522 fepriv
->reinitialise
= 1;
525 up(&fepriv
->sem
); /* is locked when we enter the thread... */
527 timeout
= wait_event_interruptible_timeout(fepriv
->wait_queue
,
528 dvb_frontend_should_wakeup(fe
),
530 if (0 != dvb_frontend_is_exiting(fe
)) {
531 /* got signal or quitting */
537 if (down_interruptible(&fepriv
->sem
))
540 if (fepriv
->reinitialise
) {
541 dvb_frontend_init(fe
);
542 if (fepriv
->tone
!= -1) {
543 fe
->ops
->set_tone(fe
, fepriv
->tone
);
545 if (fepriv
->voltage
!= -1) {
546 fe
->ops
->set_voltage(fe
, fepriv
->voltage
);
548 fepriv
->reinitialise
= 0;
551 /* do an iteration of the tuning loop */
553 /* have we been asked to retune? */
555 if (fepriv
->state
& FESTATE_RETUNE
) {
556 params
= &fepriv
->parameters
;
557 fepriv
->state
= FESTATE_TUNED
;
560 fe
->ops
->tune(fe
, params
, fepriv
->tune_mode_flags
, &fepriv
->delay
, &s
);
561 if (s
!= fepriv
->status
) {
562 dvb_frontend_add_event(fe
, s
);
566 dvb_frontend_swzigzag(fe
);
570 if (dvb_shutdown_timeout
) {
571 if (dvb_powerdown_on_sleep
)
572 if (fe
->ops
->set_voltage
)
573 fe
->ops
->set_voltage(fe
, SEC_VOLTAGE_OFF
);
578 fepriv
->thread_pid
= 0;
581 dvb_frontend_wakeup(fe
);
585 static void dvb_frontend_stop(struct dvb_frontend
*fe
)
588 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
590 dprintk ("%s\n", __FUNCTION__
);
595 if (!fepriv
->thread_pid
)
598 /* check if the thread is really alive */
599 if (kill_proc(fepriv
->thread_pid
, 0, 1) == -ESRCH
) {
600 printk("dvb_frontend_stop: thread PID %d already died\n",
602 /* make sure the mutex was not held by the thread */
603 init_MUTEX (&fepriv
->sem
);
607 /* wake up the frontend thread, so it notices that fe->exit == 1 */
608 dvb_frontend_wakeup(fe
);
610 /* wait until the frontend thread has exited */
611 ret
= wait_event_interruptible(fepriv
->wait_queue
,0 == fepriv
->thread_pid
);
612 if (-ERESTARTSYS
!= ret
) {
613 fepriv
->state
= FESTATE_IDLE
;
616 fepriv
->state
= FESTATE_IDLE
;
618 /* paranoia check in case a signal arrived */
619 if (fepriv
->thread_pid
)
620 printk("dvb_frontend_stop: warning: thread PID %d won't exit\n",
624 s32
timeval_usec_diff(struct timeval lasttime
, struct timeval curtime
)
626 return ((curtime
.tv_usec
< lasttime
.tv_usec
) ?
627 1000000 - lasttime
.tv_usec
+ curtime
.tv_usec
:
628 curtime
.tv_usec
- lasttime
.tv_usec
);
630 EXPORT_SYMBOL(timeval_usec_diff
);
632 static inline void timeval_usec_add(struct timeval
*curtime
, u32 add_usec
)
634 curtime
->tv_usec
+= add_usec
;
635 if (curtime
->tv_usec
>= 1000000) {
636 curtime
->tv_usec
-= 1000000;
642 * Sleep until gettimeofday() > waketime + add_usec
643 * This needs to be as precise as possible, but as the delay is
644 * usually between 2ms and 32ms, it is done using a scheduled msleep
645 * followed by usleep (normally a busy-wait loop) for the remainder
647 void dvb_frontend_sleep_until(struct timeval
*waketime
, u32 add_usec
)
649 struct timeval lasttime
;
652 timeval_usec_add(waketime
, add_usec
);
654 do_gettimeofday(&lasttime
);
655 delta
= timeval_usec_diff(lasttime
, *waketime
);
657 msleep((delta
- 1500) / 1000);
658 do_gettimeofday(&lasttime
);
659 newdelta
= timeval_usec_diff(lasttime
, *waketime
);
660 delta
= (newdelta
> delta
) ? 0 : newdelta
;
665 EXPORT_SYMBOL(dvb_frontend_sleep_until
);
667 static int dvb_frontend_start(struct dvb_frontend
*fe
)
670 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
672 dprintk ("%s\n", __FUNCTION__
);
674 if (fepriv
->thread_pid
) {
678 dvb_frontend_stop (fe
);
681 if (signal_pending(current
))
683 if (down_interruptible (&fepriv
->sem
))
686 fepriv
->state
= FESTATE_IDLE
;
688 fepriv
->thread_pid
= 0;
691 ret
= kernel_thread (dvb_frontend_thread
, fe
, 0);
694 printk("dvb_frontend_start: failed to start kernel_thread (%d)\n", ret
);
698 fepriv
->thread_pid
= ret
;
703 static int dvb_frontend_ioctl(struct inode
*inode
, struct file
*file
,
704 unsigned int cmd
, void *parg
)
706 struct dvb_device
*dvbdev
= file
->private_data
;
707 struct dvb_frontend
*fe
= dvbdev
->priv
;
708 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
709 int err
= -EOPNOTSUPP
;
711 dprintk ("%s\n", __FUNCTION__
);
713 if (!fe
|| fepriv
->exit
)
716 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
&&
717 (_IOC_DIR(cmd
) != _IOC_READ
|| cmd
== FE_GET_EVENT
||
718 cmd
== FE_DISEQC_RECV_SLAVE_REPLY
))
721 if (down_interruptible (&fepriv
->sem
))
726 struct dvb_frontend_info
* info
= parg
;
727 memcpy(info
, &fe
->ops
->info
, sizeof(struct dvb_frontend_info
));
729 /* Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't
730 * do it, it is done for it. */
731 info
->caps
|= FE_CAN_INVERSION_AUTO
;
736 case FE_READ_STATUS
: {
737 fe_status_t
* status
= parg
;
739 /* if retune was requested but hasn't occured yet, prevent
740 * that user get signal state from previous tuning */
741 if(fepriv
->state
== FESTATE_RETUNE
) {
747 if (fe
->ops
->read_status
)
748 err
= fe
->ops
->read_status(fe
, status
);
752 if (fe
->ops
->read_ber
)
753 err
= fe
->ops
->read_ber(fe
, (__u32
*) parg
);
756 case FE_READ_SIGNAL_STRENGTH
:
757 if (fe
->ops
->read_signal_strength
)
758 err
= fe
->ops
->read_signal_strength(fe
, (__u16
*) parg
);
762 if (fe
->ops
->read_snr
)
763 err
= fe
->ops
->read_snr(fe
, (__u16
*) parg
);
766 case FE_READ_UNCORRECTED_BLOCKS
:
767 if (fe
->ops
->read_ucblocks
)
768 err
= fe
->ops
->read_ucblocks(fe
, (__u32
*) parg
);
772 case FE_DISEQC_RESET_OVERLOAD
:
773 if (fe
->ops
->diseqc_reset_overload
) {
774 err
= fe
->ops
->diseqc_reset_overload(fe
);
775 fepriv
->state
= FESTATE_DISEQC
;
780 case FE_DISEQC_SEND_MASTER_CMD
:
781 if (fe
->ops
->diseqc_send_master_cmd
) {
782 err
= fe
->ops
->diseqc_send_master_cmd(fe
, (struct dvb_diseqc_master_cmd
*) parg
);
783 fepriv
->state
= FESTATE_DISEQC
;
788 case FE_DISEQC_SEND_BURST
:
789 if (fe
->ops
->diseqc_send_burst
) {
790 err
= fe
->ops
->diseqc_send_burst(fe
, (fe_sec_mini_cmd_t
) parg
);
791 fepriv
->state
= FESTATE_DISEQC
;
797 if (fe
->ops
->set_tone
) {
798 err
= fe
->ops
->set_tone(fe
, (fe_sec_tone_mode_t
) parg
);
799 fepriv
->tone
= (fe_sec_tone_mode_t
) parg
;
800 fepriv
->state
= FESTATE_DISEQC
;
806 if (fe
->ops
->set_voltage
) {
807 err
= fe
->ops
->set_voltage(fe
, (fe_sec_voltage_t
) parg
);
808 fepriv
->voltage
= (fe_sec_voltage_t
) parg
;
809 fepriv
->state
= FESTATE_DISEQC
;
814 case FE_DISHNETWORK_SEND_LEGACY_CMD
:
815 if (fe
->ops
->dishnetwork_send_legacy_command
) {
816 err
= fe
->ops
->dishnetwork_send_legacy_command(fe
, (unsigned long) parg
);
817 fepriv
->state
= FESTATE_DISEQC
;
819 } else if (fe
->ops
->set_voltage
) {
821 * NOTE: This is a fallback condition. Some frontends
822 * (stv0299 for instance) take longer than 8msec to
823 * respond to a set_voltage command. Those switches
824 * need custom routines to switch properly. For all
825 * other frontends, the following shoule work ok.
826 * Dish network legacy switches (as used by Dish500)
827 * are controlled by sending 9-bit command words
828 * spaced 8msec apart.
829 * the actual command word is switch/port dependant
830 * so it is up to the userspace application to send
832 * The command must always start with a '0' after
833 * initialization, so parg is 8 bits and does not
834 * include the initialization or start bit
836 unsigned long cmd
= ((unsigned long) parg
) << 1;
837 struct timeval nexttime
;
838 struct timeval tv
[10];
841 if (dvb_frontend_debug
)
842 printk("%s switch command: 0x%04lx\n", __FUNCTION__
, cmd
);
843 do_gettimeofday(&nexttime
);
844 if (dvb_frontend_debug
)
845 memcpy(&tv
[0], &nexttime
, sizeof(struct timeval
));
846 /* before sending a command, initialize by sending
847 * a 32ms 18V to the switch
849 fe
->ops
->set_voltage(fe
, SEC_VOLTAGE_18
);
850 dvb_frontend_sleep_until(&nexttime
, 32000);
852 for (i
= 0; i
< 9; i
++) {
853 if (dvb_frontend_debug
)
854 do_gettimeofday(&tv
[i
+ 1]);
855 if ((cmd
& 0x01) != last
) {
856 /* set voltage to (last ? 13V : 18V) */
857 fe
->ops
->set_voltage(fe
, (last
) ? SEC_VOLTAGE_13
: SEC_VOLTAGE_18
);
858 last
= (last
) ? 0 : 1;
862 dvb_frontend_sleep_until(&nexttime
, 8000);
864 if (dvb_frontend_debug
) {
865 printk("%s(%d): switch delay (should be 32k followed by all 8k\n",
866 __FUNCTION__
, fe
->dvb
->num
);
867 for (i
= 1; i
< 10; i
++)
868 printk("%d: %d\n", i
, timeval_usec_diff(tv
[i
-1] , tv
[i
]));
871 fepriv
->state
= FESTATE_DISEQC
;
876 case FE_DISEQC_RECV_SLAVE_REPLY
:
877 if (fe
->ops
->diseqc_recv_slave_reply
)
878 err
= fe
->ops
->diseqc_recv_slave_reply(fe
, (struct dvb_diseqc_slave_reply
*) parg
);
881 case FE_ENABLE_HIGH_LNB_VOLTAGE
:
882 if (fe
->ops
->enable_high_lnb_voltage
)
883 err
= fe
->ops
->enable_high_lnb_voltage(fe
, (long) parg
);
886 case FE_SET_FRONTEND
: {
887 struct dvb_frontend_tune_settings fetunesettings
;
889 memcpy (&fepriv
->parameters
, parg
,
890 sizeof (struct dvb_frontend_parameters
));
892 memset(&fetunesettings
, 0, sizeof(struct dvb_frontend_tune_settings
));
893 memcpy(&fetunesettings
.parameters
, parg
,
894 sizeof (struct dvb_frontend_parameters
));
896 /* force auto frequency inversion if requested */
897 if (dvb_force_auto_inversion
) {
898 fepriv
->parameters
.inversion
= INVERSION_AUTO
;
899 fetunesettings
.parameters
.inversion
= INVERSION_AUTO
;
901 if (fe
->ops
->info
.type
== FE_OFDM
) {
902 /* without hierachical coding code_rate_LP is irrelevant,
903 * so we tolerate the otherwise invalid FEC_NONE setting */
904 if (fepriv
->parameters
.u
.ofdm
.hierarchy_information
== HIERARCHY_NONE
&&
905 fepriv
->parameters
.u
.ofdm
.code_rate_LP
== FEC_NONE
)
906 fepriv
->parameters
.u
.ofdm
.code_rate_LP
= FEC_AUTO
;
909 /* get frontend-specific tuning settings */
910 if (fe
->ops
->get_tune_settings
&& (fe
->ops
->get_tune_settings(fe
, &fetunesettings
) == 0)) {
911 fepriv
->min_delay
= (fetunesettings
.min_delay_ms
* HZ
) / 1000;
912 fepriv
->max_drift
= fetunesettings
.max_drift
;
913 fepriv
->step_size
= fetunesettings
.step_size
;
916 switch(fe
->ops
->info
.type
) {
918 fepriv
->min_delay
= HZ
/20;
919 fepriv
->step_size
= fepriv
->parameters
.u
.qpsk
.symbol_rate
/ 16000;
920 fepriv
->max_drift
= fepriv
->parameters
.u
.qpsk
.symbol_rate
/ 2000;
924 fepriv
->min_delay
= HZ
/20;
925 fepriv
->step_size
= 0; /* no zigzag */
926 fepriv
->max_drift
= 0;
930 fepriv
->min_delay
= HZ
/20;
931 fepriv
->step_size
= fe
->ops
->info
.frequency_stepsize
* 2;
932 fepriv
->max_drift
= (fe
->ops
->info
.frequency_stepsize
* 2) + 1;
935 printk("dvb-core: FE_ATSC not handled yet.\n");
939 if (dvb_override_tune_delay
> 0)
940 fepriv
->min_delay
= (dvb_override_tune_delay
* HZ
) / 1000;
942 fepriv
->state
= FESTATE_RETUNE
;
943 dvb_frontend_wakeup(fe
);
944 dvb_frontend_add_event(fe
, 0);
951 err
= dvb_frontend_get_event (fe
, parg
, file
->f_flags
);
954 case FE_GET_FRONTEND
:
955 if (fe
->ops
->get_frontend
) {
956 memcpy (parg
, &fepriv
->parameters
, sizeof (struct dvb_frontend_parameters
));
957 err
= fe
->ops
->get_frontend(fe
, (struct dvb_frontend_parameters
*) parg
);
961 case FE_SET_FRONTEND_TUNE_MODE
:
962 fepriv
->tune_mode_flags
= (unsigned long) parg
;
970 static unsigned int dvb_frontend_poll(struct file
*file
, struct poll_table_struct
*wait
)
972 struct dvb_device
*dvbdev
= file
->private_data
;
973 struct dvb_frontend
*fe
= dvbdev
->priv
;
974 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
976 dprintk ("%s\n", __FUNCTION__
);
978 poll_wait (file
, &fepriv
->events
.wait_queue
, wait
);
980 if (fepriv
->events
.eventw
!= fepriv
->events
.eventr
)
981 return (POLLIN
| POLLRDNORM
| POLLPRI
);
986 static int dvb_frontend_open(struct inode
*inode
, struct file
*file
)
988 struct dvb_device
*dvbdev
= file
->private_data
;
989 struct dvb_frontend
*fe
= dvbdev
->priv
;
990 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
993 dprintk ("%s\n", __FUNCTION__
);
995 if ((ret
= dvb_generic_open (inode
, file
)) < 0)
998 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
999 ret
= dvb_frontend_start (fe
);
1001 dvb_generic_release (inode
, file
);
1003 /* empty event queue */
1004 fepriv
->events
.eventr
= fepriv
->events
.eventw
= 0;
1006 /* normal tune mode when opened R/W */
1007 fepriv
->tune_mode_flags
&= ~FE_TUNE_MODE_ONESHOT
;
1009 fepriv
->voltage
= -1;
1015 static int dvb_frontend_release(struct inode
*inode
, struct file
*file
)
1017 struct dvb_device
*dvbdev
= file
->private_data
;
1018 struct dvb_frontend
*fe
= dvbdev
->priv
;
1019 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
1021 dprintk ("%s\n", __FUNCTION__
);
1023 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
)
1024 fepriv
->release_jiffies
= jiffies
;
1026 return dvb_generic_release (inode
, file
);
1029 static struct file_operations dvb_frontend_fops
= {
1030 .owner
= THIS_MODULE
,
1031 .ioctl
= dvb_generic_ioctl
,
1032 .poll
= dvb_frontend_poll
,
1033 .open
= dvb_frontend_open
,
1034 .release
= dvb_frontend_release
1037 int dvb_register_frontend(struct dvb_adapter
* dvb
,
1038 struct dvb_frontend
* fe
)
1040 struct dvb_frontend_private
*fepriv
;
1041 static const struct dvb_device dvbdev_template
= {
1045 .fops
= &dvb_frontend_fops
,
1046 .kernel_ioctl
= dvb_frontend_ioctl
1049 dprintk ("%s\n", __FUNCTION__
);
1051 if (mutex_lock_interruptible(&frontend_mutex
))
1052 return -ERESTARTSYS
;
1054 fe
->frontend_priv
= kzalloc(sizeof(struct dvb_frontend_private
), GFP_KERNEL
);
1055 if (fe
->frontend_priv
== NULL
) {
1056 mutex_unlock(&frontend_mutex
);
1059 fepriv
= fe
->frontend_priv
;
1061 init_MUTEX (&fepriv
->sem
);
1062 init_waitqueue_head (&fepriv
->wait_queue
);
1063 init_waitqueue_head (&fepriv
->events
.wait_queue
);
1064 init_MUTEX (&fepriv
->events
.sem
);
1066 fepriv
->inversion
= INVERSION_OFF
;
1068 printk ("DVB: registering frontend %i (%s)...\n",
1070 fe
->ops
->info
.name
);
1072 dvb_register_device (fe
->dvb
, &fepriv
->dvbdev
, &dvbdev_template
,
1073 fe
, DVB_DEVICE_FRONTEND
);
1075 mutex_unlock(&frontend_mutex
);
1078 EXPORT_SYMBOL(dvb_register_frontend
);
1080 int dvb_unregister_frontend(struct dvb_frontend
* fe
)
1082 struct dvb_frontend_private
*fepriv
= fe
->frontend_priv
;
1083 dprintk ("%s\n", __FUNCTION__
);
1085 mutex_lock(&frontend_mutex
);
1086 dvb_unregister_device (fepriv
->dvbdev
);
1087 dvb_frontend_stop (fe
);
1088 if (fe
->ops
->release
)
1089 fe
->ops
->release(fe
);
1091 printk("dvb_frontend: Demodulator (%s) does not have a release callback!\n", fe
->ops
->info
.name
);
1092 /* fe is invalid now */
1094 mutex_unlock(&frontend_mutex
);
1097 EXPORT_SYMBOL(dvb_unregister_frontend
);