2 * dvb-core.c: DVB core driver
4 * Copyright (C) 1999-2001 Ralph Metzler
7 * for convergence integrated media GmbH
9 * Copyright (C) 2004 Andrew de Quincey (tuning thread cleanup)
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version 2
14 * of the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
27 #include <linux/string.h>
28 #include <linux/kernel.h>
29 #include <linux/sched.h>
30 #include <linux/wait.h>
31 #include <linux/slab.h>
32 #include <linux/poll.h>
33 #include <linux/module.h>
34 #include <linux/list.h>
35 #include <asm/processor.h>
36 #include <asm/semaphore.h>
38 #include "dvb_frontend.h"
40 #include "dvb_functions.h"
42 #define FESTATE_IDLE 1
43 #define FESTATE_RETUNE 2
44 #define FESTATE_TUNING_FAST 4
45 #define FESTATE_TUNING_SLOW 8
46 #define FESTATE_TUNED 16
47 #define FESTATE_ZIGZAG_FAST 32
48 #define FESTATE_ZIGZAG_SLOW 64
49 #define FESTATE_DISEQC 128
50 #define FESTATE_WAITFORLOCK (FESTATE_TUNING_FAST | FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW | FESTATE_DISEQC)
51 #define FESTATE_SEARCHING_FAST (FESTATE_TUNING_FAST | FESTATE_ZIGZAG_FAST)
52 #define FESTATE_SEARCHING_SLOW (FESTATE_TUNING_SLOW | FESTATE_ZIGZAG_SLOW)
53 #define FESTATE_LOSTLOCK (FESTATE_ZIGZAG_FAST | FESTATE_ZIGZAG_SLOW)
55 * FESTATE_IDLE. No tuning parameters have been supplied and the loop is idling.
56 * FESTATE_RETUNE. Parameters have been supplied, but we have not yet performed the first tune.
57 * FESTATE_TUNING_FAST. Tuning parameters have been supplied and fast zigzag scan is in progress.
58 * FESTATE_TUNING_SLOW. Tuning parameters have been supplied. Fast zigzag failed, so we're trying again, but slower.
59 * FESTATE_TUNED. The frontend has successfully locked on.
60 * FESTATE_ZIGZAG_FAST. The lock has been lost, and a fast zigzag has been initiated to try and regain it.
61 * FESTATE_ZIGZAG_SLOW. The lock has been lost. Fast zigzag has been failed, so we're trying again, but slower.
62 * FESTATE_DISEQC. A DISEQC command has just been issued.
63 * FESTATE_WAITFORLOCK. When we're waiting for a lock.
64 * FESTATE_SEARCHING_FAST. When we're searching for a signal using a fast zigzag scan.
65 * FESTATE_SEARCHING_SLOW. When we're searching for a signal using a slow zigzag scan.
66 * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again.
70 static int dvb_frontend_debug
= 0;
71 static int dvb_shutdown_timeout
= 5;
72 static int dvb_override_frequency_bending
= 0;
73 static int dvb_force_auto_inversion
= 0;
74 static int dvb_override_tune_delay
= 0;
76 static int do_frequency_bending
= 0;
78 #define dprintk if (dvb_frontend_debug) printk
82 struct dvb_fe_events
{
83 struct dvb_frontend_event events
[MAX_EVENT
];
87 wait_queue_head_t wait_queue
;
92 struct dvb_frontend_data
{
93 struct dvb_frontend_info
*info
;
94 struct dvb_frontend frontend
;
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
;
109 int started_auto_step
;
119 struct dvb_frontend_ioctl_data
{
120 struct list_head list_head
;
121 struct dvb_adapter
*adapter
;
122 int (*before_ioctl
) (struct dvb_frontend
*frontend
,
123 unsigned int cmd
, void *arg
);
124 int (*after_ioctl
) (struct dvb_frontend
*frontend
,
125 unsigned int cmd
, void *arg
);
126 void *before_after_data
;
130 struct dvb_frontend_notifier_data
{
131 struct list_head list_head
;
132 struct dvb_adapter
*adapter
;
133 void (*callback
) (fe_status_t s
, void *data
);
138 static LIST_HEAD(frontend_list
);
139 static LIST_HEAD(frontend_ioctl_list
);
140 static LIST_HEAD(frontend_notifier_list
);
142 static DECLARE_MUTEX(frontend_mutex
);
145 static int dvb_frontend_internal_ioctl (struct dvb_frontend
*frontend
,
146 unsigned int cmd
, void *arg
)
148 int err
= -EOPNOTSUPP
;
150 dprintk ("%s\n", __FUNCTION__
);
152 if (frontend
->before_ioctl
)
153 err
= frontend
->before_ioctl (frontend
, cmd
, arg
);
155 if (err
== -EOPNOTSUPP
) {
156 err
= frontend
->ioctl (frontend
, cmd
, arg
);
158 if ((err
== -EOPNOTSUPP
) && frontend
->after_ioctl
)
159 err
= frontend
->after_ioctl (frontend
, cmd
, arg
);
167 * if 2 tuners are located side by side you can get interferences when
168 * they try to tune to the same frequency, so both lose sync.
169 * We will slightly mistune in this case. The AFC of the demodulator
170 * should make it still possible to receive the requested transponder
173 static void dvb_bend_frequency (struct dvb_frontend_data
*this_fe
, int recursive
)
175 struct list_head
*entry
;
176 int stepsize
= this_fe
->info
->frequency_stepsize
;
177 int this_fe_adap_num
= this_fe
->frontend
.i2c
->adapter
->num
;
180 if (!stepsize
|| recursive
> 10) {
181 printk ("%s: too deep recursion, check frequency_stepsize "
182 "in your frontend code!\n", __FUNCTION__
);
186 dprintk ("%s\n", __FUNCTION__
);
189 if (down_interruptible (&frontend_mutex
))
192 this_fe
->bending
= 0;
195 list_for_each (entry
, &frontend_list
) {
196 struct dvb_frontend_data
*fe
;
199 fe
= list_entry (entry
, struct dvb_frontend_data
, list_head
);
201 if (fe
->frontend
.i2c
->adapter
->num
!= this_fe_adap_num
)
204 f
= fe
->parameters
.frequency
;
208 frequency
= this_fe
->parameters
.frequency
;
209 frequency
+= this_fe
->lnb_drift
;
210 frequency
+= this_fe
->bending
;
212 if (this_fe
!= fe
&& (fe
->state
!= FESTATE_IDLE
) &&
213 frequency
> f
- stepsize
&& frequency
< f
+ stepsize
)
216 this_fe
->bending
+= stepsize
;
218 this_fe
->bending
= -this_fe
->bending
;
220 dvb_bend_frequency (this_fe
, recursive
+ 1);
226 up (&frontend_mutex
);
230 static void dvb_call_frontend_notifiers (struct dvb_frontend_data
*fe
,
233 dprintk ("%s\n", __FUNCTION__
);
235 if (((s
^ fe
->status
) & FE_HAS_LOCK
) && (s
& FE_HAS_LOCK
))
236 dvb_delay (fe
->info
->notifier_delay
);
240 if (!(s
& FE_HAS_LOCK
) && (fe
->info
->caps
& FE_CAN_MUTE_TS
))
244 * now tell the Demux about the TS status changes...
246 if (fe
->frontend
.notifier_callback
)
247 fe
->frontend
.notifier_callback(fe
->status
, fe
->frontend
.notifier_data
);
251 static void dvb_frontend_add_event (struct dvb_frontend_data
*fe
, fe_status_t status
)
253 struct dvb_fe_events
*events
= &fe
->events
;
254 struct dvb_frontend_event
*e
;
257 dprintk ("%s\n", __FUNCTION__
);
259 if (down_interruptible (&events
->sem
))
262 wp
= (events
->eventw
+ 1) % MAX_EVENT
;
264 if (wp
== events
->eventr
) {
265 events
->overflow
= 1;
266 events
->eventr
= (events
->eventr
+ 1) % MAX_EVENT
;
269 e
= &events
->events
[events
->eventw
];
271 memcpy (&e
->parameters
, &fe
->parameters
,
272 sizeof (struct dvb_frontend_parameters
));
274 if (status
& FE_HAS_LOCK
)
275 dvb_frontend_internal_ioctl (&fe
->frontend
,
283 dvb_call_frontend_notifiers (fe
, status
);
285 wake_up_interruptible (&events
->wait_queue
);
289 static int dvb_frontend_get_event (struct dvb_frontend_data
*fe
,
290 struct dvb_frontend_event
*event
, int flags
)
292 struct dvb_fe_events
*events
= &fe
->events
;
294 dprintk ("%s\n", __FUNCTION__
);
296 if (events
->overflow
) {
297 events
->overflow
= 0;
301 if (events
->eventw
== events
->eventr
) {
304 if (flags
& O_NONBLOCK
)
309 ret
= wait_event_interruptible (events
->wait_queue
,
310 events
->eventw
!= events
->eventr
);
312 if (down_interruptible (&fe
->sem
))
319 if (down_interruptible (&events
->sem
))
322 memcpy (event
, &events
->events
[events
->eventr
],
323 sizeof(struct dvb_frontend_event
));
325 events
->eventr
= (events
->eventr
+ 1) % MAX_EVENT
;
332 static void dvb_frontend_init (struct dvb_frontend_data
*fe
)
334 struct dvb_frontend
*frontend
= &fe
->frontend
;
336 dprintk ("DVB: initialising frontend %i:%i (%s)...\n",
337 frontend
->i2c
->adapter
->num
, frontend
->i2c
->id
,
340 dvb_frontend_internal_ioctl (frontend
, FE_INIT
, NULL
);
343 static void update_delay (int *quality
, int *delay
, int min_delay
, int locked
)
347 dprintk ("%s\n", __FUNCTION__
);
350 (*quality
) = (*quality
* 220 + 36*256) / 256;
352 (*quality
) = (*quality
* 220 + 0) / 256;
357 *delay
= min_delay
+ q2
* HZ
/ (128*128);
361 * Performs automatic twiddling of frontend parameters.
363 * @param fe The frontend concerned.
364 * @param check_wrapped Checks if an iteration has completed. DO NOT SET ON THE FIRST ATTEMPT
365 * @returns Number of complete iterations that have been performed.
367 static int dvb_frontend_autotune(struct dvb_frontend_data
*fe
, int check_wrapped
)
371 int original_inversion
= fe
->parameters
.inversion
;
372 u32 original_frequency
= fe
->parameters
.frequency
;
374 // are we using autoinversion?
375 autoinversion
= ((!(fe
->info
->caps
& FE_CAN_INVERSION_AUTO
)) && (fe
->parameters
.inversion
== INVERSION_AUTO
));
377 // setup parameters correctly
379 // calculate the lnb_drift
380 fe
->lnb_drift
= fe
->auto_step
* fe
->step_size
;
382 // wrap the auto_step if we've exceeded the maximum drift
383 if (fe
->lnb_drift
> fe
->max_drift
) {
385 fe
->auto_sub_step
= 0;
389 // perform inversion and +/- zigzag
390 switch(fe
->auto_sub_step
) {
392 // try with the current inversion and current drift setting
397 if (!autoinversion
) break;
399 fe
->inversion
= (fe
->inversion
== INVERSION_OFF
) ? INVERSION_ON
: INVERSION_OFF
;
404 if (fe
->lnb_drift
== 0) break;
406 fe
->lnb_drift
= -fe
->lnb_drift
;
411 if (fe
->lnb_drift
== 0) break;
412 if (!autoinversion
) break;
414 fe
->inversion
= (fe
->inversion
== INVERSION_OFF
) ? INVERSION_ON
: INVERSION_OFF
;
415 fe
->lnb_drift
= -fe
->lnb_drift
;
421 fe
->auto_sub_step
= -1; // it'll be incremented to 0 in a moment
425 if (!ready
) fe
->auto_sub_step
++;
428 // if this attempt would hit where we started, indicate a complete iteration has occurred
429 if ((fe
->auto_step
== fe
->started_auto_step
) && (fe
->auto_sub_step
== 0) && check_wrapped
) {
433 // perform frequency bending if necessary
434 if ((dvb_override_frequency_bending
!= 1) && do_frequency_bending
)
435 dvb_bend_frequency(fe
, 0);
438 dprintk("%s: drift:%i bending:%i inversion:%i auto_step:%i auto_sub_step:%i started_auto_step:%i\n",
439 __FUNCTION__
, fe
->lnb_drift
, fe
->bending
, fe
->inversion
, fe
->auto_step
, fe
->auto_sub_step
,
440 fe
->started_auto_step
);
442 // set the frontend itself
443 fe
->parameters
.frequency
+= fe
->lnb_drift
+ fe
->bending
;
444 if (autoinversion
) fe
->parameters
.inversion
= fe
->inversion
;
445 dvb_frontend_internal_ioctl (&fe
->frontend
, FE_SET_FRONTEND
, &fe
->parameters
);
446 fe
->parameters
.frequency
= original_frequency
;
447 fe
->parameters
.inversion
= original_inversion
;
456 static int dvb_frontend_is_exiting (struct dvb_frontend_data
*fe
)
461 if (fe
->dvbdev
->writers
== 1)
462 if (jiffies
- fe
->release_jiffies
> dvb_shutdown_timeout
* HZ
)
468 static int dvb_frontend_should_wakeup (struct dvb_frontend_data
*fe
)
474 return dvb_frontend_is_exiting(fe
);
477 static void dvb_frontend_wakeup (struct dvb_frontend_data
*fe
) {
479 wake_up_interruptible(&fe
->wait_queue
);
482 static int dvb_frontend_thread (void *data
)
484 struct dvb_frontend_data
*fe
= (struct dvb_frontend_data
*) data
;
485 unsigned long timeout
;
487 int quality
= 0, delay
= 3*HZ
;
489 int check_wrapped
= 0;
491 dprintk ("%s\n", __FUNCTION__
);
493 snprintf (name
, sizeof(name
), "kdvb-fe-%i:%i",
494 fe
->frontend
.i2c
->adapter
->num
, fe
->frontend
.i2c
->id
);
496 dvb_kernel_thread_setup (name
);
498 dvb_call_frontend_notifiers (fe
, 0);
499 dvb_frontend_init (fe
);
503 up (&fe
->sem
); /* is locked when we enter the thread... */
505 timeout
= wait_event_interruptible_timeout(fe
->wait_queue
,0 != dvb_frontend_should_wakeup (fe
), delay
);
506 if (-ERESTARTSYS
== timeout
|| 0 != dvb_frontend_is_exiting (fe
)) {
507 /* got signal or quitting */
511 if (down_interruptible (&fe
->sem
))
514 // if we've got no parameters, just keep idling
515 if (fe
->state
& FESTATE_IDLE
) {
521 // get the frontend status
522 dvb_frontend_internal_ioctl (&fe
->frontend
, FE_READ_STATUS
, &s
);
524 dvb_frontend_add_event (fe
, s
);
526 // if we're not tuned, and we have a lock, move to the TUNED state
527 if ((fe
->state
& FESTATE_WAITFORLOCK
) && (s
& FE_HAS_LOCK
)) {
528 update_delay(&quality
, &delay
, fe
->min_delay
, s
& FE_HAS_LOCK
);
529 fe
->state
= FESTATE_TUNED
;
531 // if we're tuned, then we have determined the correct inversion
532 if ((!(fe
->info
->caps
& FE_CAN_INVERSION_AUTO
)) && (fe
->parameters
.inversion
== INVERSION_AUTO
)) {
533 fe
->parameters
.inversion
= fe
->inversion
;
538 // if we are tuned already, check we're still locked
539 if (fe
->state
& FESTATE_TUNED
) {
540 update_delay(&quality
, &delay
, fe
->min_delay
, s
& FE_HAS_LOCK
);
542 // we're tuned, and the lock is still good...
543 if (s
& FE_HAS_LOCK
) {
546 // if we _WERE_ tuned, but now don't have a lock, need to zigzag
547 fe
->state
= FESTATE_ZIGZAG_FAST
;
548 fe
->started_auto_step
= fe
->auto_step
;
554 // don't actually do anything if we're in the LOSTLOCK state, the frontend is set to
555 // FE_CAN_RECOVER, and the max_drift is 0
556 if ((fe
->state
& FESTATE_LOSTLOCK
) &&
557 (fe
->info
->caps
& FE_CAN_RECOVER
) && (fe
->max_drift
== 0)) {
558 update_delay(&quality
, &delay
, fe
->min_delay
, s
& FE_HAS_LOCK
);
562 // don't do anything if we're in the DISEQC state, since this might be someone
563 // with a motorized dish controlled by DISEQC. If its actually a re-tune, there will
564 // be a SET_FRONTEND soon enough.
565 if (fe
->state
& FESTATE_DISEQC
) {
566 update_delay(&quality
, &delay
, fe
->min_delay
, s
& FE_HAS_LOCK
);
570 // if we're in the RETUNE state, set everything up for a brand new scan,
571 // keeping the current inversion setting, as the next tune is _very_ likely
572 // to require the same
573 if (fe
->state
& FESTATE_RETUNE
) {
576 fe
->auto_sub_step
= 0;
577 fe
->started_auto_step
= 0;
582 if ((fe
->state
& FESTATE_SEARCHING_FAST
) || (fe
->state
& FESTATE_RETUNE
)) {
583 delay
= fe
->min_delay
;
586 if (dvb_frontend_autotune(fe
, check_wrapped
)) {
587 // OK, if we've run out of trials at the fast speed. Drop back to
588 // slow for the _next_ attempt
589 fe
->state
= FESTATE_SEARCHING_SLOW
;
590 fe
->started_auto_step
= fe
->auto_step
;
595 // if we've just retuned, enter the ZIGZAG_FAST state. This ensures
596 // we cannot return from an FE_SET_FRONTEND ioctl before the first frontend
598 if (fe
->state
& FESTATE_RETUNE
) {
599 fe
->state
= FESTATE_TUNING_FAST
;
600 wake_up_interruptible(&fe
->wait_queue
);
605 if (fe
->state
& FESTATE_SEARCHING_SLOW
) {
606 update_delay(&quality
, &delay
, fe
->min_delay
, s
& FE_HAS_LOCK
);
608 // Note: don't bother checking for wrapping; we stay in this state
609 // until we get a lock
610 dvb_frontend_autotune(fe
, 0);
614 if (dvb_shutdown_timeout
)
615 dvb_frontend_internal_ioctl (&fe
->frontend
, FE_SLEEP
, NULL
);
622 dvb_frontend_wakeup(fe
);
627 static void dvb_frontend_stop (struct dvb_frontend_data
*fe
)
631 dprintk ("%s\n", __FUNCTION__
);
639 /* check if the thread is really alive */
640 if (kill_proc(fe
->thread_pid
, 0, 1) == -ESRCH
) {
641 printk("dvb_frontend_stop: thread PID %d already died\n",
643 /* make sure the mutex was not held by the thread */
644 init_MUTEX (&fe
->sem
);
648 /* wake up the frontend thread, so it notices that fe->exit == 1 */
649 dvb_frontend_wakeup(fe
);
651 /* wait until the frontend thread has exited */
652 ret
= wait_event_interruptible(fe
->wait_queue
,0 == fe
->thread_pid
);
653 if (-ERESTARTSYS
!= ret
) {
654 fe
->state
= FESTATE_IDLE
;
657 fe
->state
= FESTATE_IDLE
;
659 /* paranoia check in case a signal arrived */
661 printk("dvb_frontend_stop: warning: thread PID %d won't exit\n",
666 static int dvb_frontend_start (struct dvb_frontend_data
*fe
)
670 dprintk ("%s\n", __FUNCTION__
);
672 if (fe
->thread_pid
) {
676 dvb_frontend_stop (fe
);
679 if (signal_pending(current
))
681 if (down_interruptible (&fe
->sem
))
684 fe
->state
= FESTATE_IDLE
;
689 ret
= kernel_thread (dvb_frontend_thread
, fe
, 0);
691 printk("dvb_frontend_start: failed to start kernel_thread (%d)\n", ret
);
695 fe
->thread_pid
= ret
;
701 static int dvb_frontend_ioctl (struct inode
*inode
, struct file
*file
,
702 unsigned int cmd
, void *parg
)
704 struct dvb_device
*dvbdev
= file
->private_data
;
705 struct dvb_frontend_data
*fe
= dvbdev
->priv
;
706 struct dvb_frontend_tune_settings fetunesettings
;
709 dprintk ("%s\n", __FUNCTION__
);
711 if (!fe
|| !fe
->frontend
.ioctl
|| fe
->exit
)
714 if (down_interruptible (&fe
->sem
))
718 case FE_DISEQC_SEND_MASTER_CMD
:
719 case FE_DISEQC_SEND_BURST
:
722 dvb_call_frontend_notifiers (fe
, 0);
723 dvb_frontend_internal_ioctl (&fe
->frontend
, cmd
, parg
);
724 fe
->state
= FESTATE_DISEQC
;
727 case FE_SET_FRONTEND
:
728 fe
->state
= FESTATE_RETUNE
;
730 memcpy (&fe
->parameters
, parg
,
731 sizeof (struct dvb_frontend_parameters
));
733 memset(&fetunesettings
, 0, sizeof(struct dvb_frontend_tune_settings
));
734 memcpy(&fetunesettings
.parameters
, parg
,
735 sizeof (struct dvb_frontend_parameters
));
737 // force auto frequency inversion if requested
738 if (dvb_force_auto_inversion
) {
739 fe
->parameters
.inversion
= INVERSION_AUTO
;
740 fetunesettings
.parameters
.inversion
= INVERSION_AUTO
;
743 // get frontend-specific tuning settings
744 if (dvb_frontend_internal_ioctl(&fe
->frontend
, FE_GET_TUNE_SETTINGS
, &fetunesettings
) == 0) {
745 fe
->min_delay
= (fetunesettings
.min_delay_ms
* HZ
) / 1000;
746 fe
->max_drift
= fetunesettings
.max_drift
;
747 fe
->step_size
= fetunesettings
.step_size
;
750 switch(fe
->info
->type
) {
752 fe
->min_delay
= HZ
/20; // default mindelay of 50ms
753 fe
->step_size
= fe
->parameters
.u
.qpsk
.symbol_rate
/ 16000;
754 fe
->max_drift
= fe
->parameters
.u
.qpsk
.symbol_rate
/ 2000;
758 fe
->min_delay
= HZ
/20; // default mindelay of 50ms
760 fe
->max_drift
= 0; // don't want any zigzagging under DVB-C frontends
764 fe
->min_delay
= HZ
/20; // default mindelay of 50ms
765 fe
->step_size
= fe
->info
->frequency_stepsize
* 2;
766 fe
->max_drift
= (fe
->info
->frequency_stepsize
* 2) + 1;
770 if (dvb_override_tune_delay
> 0) {
771 fe
->min_delay
= (dvb_override_tune_delay
* HZ
) / 1000;
774 dvb_frontend_add_event (fe
, 0);
778 err
= dvb_frontend_get_event (fe
, parg
, file
->f_flags
);
780 case FE_GET_FRONTEND
:
781 memcpy (parg
, &fe
->parameters
,
782 sizeof (struct dvb_frontend_parameters
));
783 /* fall-through... */
785 err
= dvb_frontend_internal_ioctl (&fe
->frontend
, cmd
, parg
);
792 // Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't do it, it is done for it.
793 if ((cmd
== FE_GET_INFO
) && (err
== 0)) {
794 struct dvb_frontend_info
* tmp
= (struct dvb_frontend_info
*) parg
;
795 tmp
->caps
|= FE_CAN_INVERSION_AUTO
;
798 // if the frontend has just been set, wait until the first tune has finished.
799 // This ensures the app doesn't start reading data too quickly, perhaps from the
800 // previous lock, which is REALLY CONFUSING TO DEBUG!
801 if ((cmd
== FE_SET_FRONTEND
) && (err
== 0)) {
802 dvb_frontend_wakeup(fe
);
803 err
= wait_event_interruptible(fe
->wait_queue
, fe
->state
& ~FESTATE_RETUNE
);
810 static unsigned int dvb_frontend_poll (struct file
*file
, struct poll_table_struct
*wait
)
812 struct dvb_device
*dvbdev
= file
->private_data
;
813 struct dvb_frontend_data
*fe
= dvbdev
->priv
;
815 dprintk ("%s\n", __FUNCTION__
);
817 poll_wait (file
, &fe
->events
.wait_queue
, wait
);
819 if (fe
->events
.eventw
!= fe
->events
.eventr
)
820 return (POLLIN
| POLLRDNORM
| POLLPRI
);
826 static int dvb_frontend_open (struct inode
*inode
, struct file
*file
)
828 struct dvb_device
*dvbdev
= file
->private_data
;
829 struct dvb_frontend_data
*fe
= dvbdev
->priv
;
832 dprintk ("%s\n", __FUNCTION__
);
834 if ((ret
= dvb_generic_open (inode
, file
)) < 0)
837 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
838 ret
= dvb_frontend_start (fe
);
840 dvb_generic_release (inode
, file
);
842 /* empty event queue */
843 fe
->events
.eventr
= fe
->events
.eventw
= 0;
850 static int dvb_frontend_release (struct inode
*inode
, struct file
*file
)
852 struct dvb_device
*dvbdev
= file
->private_data
;
853 struct dvb_frontend_data
*fe
= dvbdev
->priv
;
855 dprintk ("%s\n", __FUNCTION__
);
857 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
)
858 fe
->release_jiffies
= jiffies
;
860 return dvb_generic_release (inode
, file
);
866 dvb_add_frontend_ioctls (struct dvb_adapter
*adapter
,
867 int (*before_ioctl
) (struct dvb_frontend
*frontend
,
868 unsigned int cmd
, void *arg
),
869 int (*after_ioctl
) (struct dvb_frontend
*frontend
,
870 unsigned int cmd
, void *arg
),
871 void *before_after_data
)
873 struct dvb_frontend_ioctl_data
*ioctl
;
874 struct list_head
*entry
;
876 dprintk ("%s\n", __FUNCTION__
);
878 if (down_interruptible (&frontend_mutex
))
881 ioctl
= kmalloc (sizeof(struct dvb_frontend_ioctl_data
), GFP_KERNEL
);
884 up (&frontend_mutex
);
888 ioctl
->adapter
= adapter
;
889 ioctl
->before_ioctl
= before_ioctl
;
890 ioctl
->after_ioctl
= after_ioctl
;
891 ioctl
->before_after_data
= before_after_data
;
893 list_add_tail (&ioctl
->list_head
, &frontend_ioctl_list
);
895 list_for_each (entry
, &frontend_list
) {
896 struct dvb_frontend_data
*fe
;
898 fe
= list_entry (entry
, struct dvb_frontend_data
, list_head
);
900 if (fe
->frontend
.i2c
->adapter
== adapter
&&
901 fe
->frontend
.before_ioctl
== NULL
&&
902 fe
->frontend
.after_ioctl
== NULL
)
904 fe
->frontend
.before_ioctl
= before_ioctl
;
905 fe
->frontend
.after_ioctl
= after_ioctl
;
906 fe
->frontend
.before_after_data
= before_after_data
;
910 up (&frontend_mutex
);
917 dvb_remove_frontend_ioctls (struct dvb_adapter
*adapter
,
918 int (*before_ioctl
) (struct dvb_frontend
*frontend
,
919 unsigned int cmd
, void *arg
),
920 int (*after_ioctl
) (struct dvb_frontend
*frontend
,
921 unsigned int cmd
, void *arg
))
923 struct list_head
*entry
, *n
;
925 dprintk ("%s\n", __FUNCTION__
);
927 down (&frontend_mutex
);
929 list_for_each (entry
, &frontend_list
) {
930 struct dvb_frontend_data
*fe
;
932 fe
= list_entry (entry
, struct dvb_frontend_data
, list_head
);
934 if (fe
->frontend
.i2c
->adapter
== adapter
&&
935 fe
->frontend
.before_ioctl
== before_ioctl
&&
936 fe
->frontend
.after_ioctl
== after_ioctl
)
938 fe
->frontend
.before_ioctl
= NULL
;
939 fe
->frontend
.after_ioctl
= NULL
;
944 list_for_each_safe (entry
, n
, &frontend_ioctl_list
) {
945 struct dvb_frontend_ioctl_data
*ioctl
;
947 ioctl
= list_entry (entry
, struct dvb_frontend_ioctl_data
, list_head
);
949 if (ioctl
->adapter
== adapter
&&
950 ioctl
->before_ioctl
== before_ioctl
&&
951 ioctl
->after_ioctl
== after_ioctl
)
953 list_del (&ioctl
->list_head
);
960 up (&frontend_mutex
);
965 dvb_add_frontend_notifier (struct dvb_adapter
*adapter
,
966 void (*callback
) (fe_status_t s
, void *data
),
969 struct dvb_frontend_notifier_data
*notifier
;
970 struct list_head
*entry
;
972 dprintk ("%s\n", __FUNCTION__
);
974 if (down_interruptible (&frontend_mutex
))
977 notifier
= kmalloc (sizeof(struct dvb_frontend_notifier_data
), GFP_KERNEL
);
980 up (&frontend_mutex
);
984 notifier
->adapter
= adapter
;
985 notifier
->callback
= callback
;
986 notifier
->data
= data
;
988 list_add_tail (¬ifier
->list_head
, &frontend_notifier_list
);
990 list_for_each (entry
, &frontend_list
) {
991 struct dvb_frontend_data
*fe
;
993 fe
= list_entry (entry
, struct dvb_frontend_data
, list_head
);
995 if (fe
->frontend
.i2c
->adapter
== adapter
&&
996 fe
->frontend
.notifier_callback
== NULL
)
998 fe
->frontend
.notifier_callback
= callback
;
999 fe
->frontend
.notifier_data
= data
;
1003 up (&frontend_mutex
);
1010 dvb_remove_frontend_notifier (struct dvb_adapter
*adapter
,
1011 void (*callback
) (fe_status_t s
, void *data
))
1013 struct list_head
*entry
, *n
;
1015 dprintk ("%s\n", __FUNCTION__
);
1017 down (&frontend_mutex
);
1019 list_for_each (entry
, &frontend_list
) {
1020 struct dvb_frontend_data
*fe
;
1022 fe
= list_entry (entry
, struct dvb_frontend_data
, list_head
);
1024 if (fe
->frontend
.i2c
->adapter
== adapter
&&
1025 fe
->frontend
.notifier_callback
== callback
)
1027 fe
->frontend
.notifier_callback
= NULL
;
1032 list_for_each_safe (entry
, n
, &frontend_notifier_list
) {
1033 struct dvb_frontend_notifier_data
*notifier
;
1035 notifier
= list_entry (entry
, struct dvb_frontend_notifier_data
, list_head
);
1037 if (notifier
->adapter
== adapter
&&
1038 notifier
->callback
== callback
)
1040 list_del (¬ifier
->list_head
);
1047 up (&frontend_mutex
);
1051 static struct file_operations dvb_frontend_fops
= {
1052 .owner
= THIS_MODULE
,
1053 .ioctl
= dvb_generic_ioctl
,
1054 .poll
= dvb_frontend_poll
,
1055 .open
= dvb_frontend_open
,
1056 .release
= dvb_frontend_release
1062 dvb_register_frontend (int (*ioctl
) (struct dvb_frontend
*frontend
,
1063 unsigned int cmd
, void *arg
),
1064 struct dvb_i2c_bus
*i2c
,
1066 struct dvb_frontend_info
*info
)
1068 struct list_head
*entry
;
1069 struct dvb_frontend_data
*fe
;
1070 static const struct dvb_device dvbdev_template
= {
1074 .fops
= &dvb_frontend_fops
,
1075 .kernel_ioctl
= dvb_frontend_ioctl
1078 dprintk ("%s\n", __FUNCTION__
);
1080 if (down_interruptible (&frontend_mutex
))
1081 return -ERESTARTSYS
;
1083 if (!(fe
= kmalloc (sizeof (struct dvb_frontend_data
), GFP_KERNEL
))) {
1084 up (&frontend_mutex
);
1088 memset (fe
, 0, sizeof (struct dvb_frontend_data
));
1090 init_MUTEX (&fe
->sem
);
1091 init_waitqueue_head (&fe
->wait_queue
);
1092 init_waitqueue_head (&fe
->events
.wait_queue
);
1093 init_MUTEX (&fe
->events
.sem
);
1094 fe
->events
.eventw
= fe
->events
.eventr
= 0;
1095 fe
->events
.overflow
= 0;
1097 fe
->frontend
.ioctl
= ioctl
;
1098 fe
->frontend
.i2c
= i2c
;
1099 fe
->frontend
.data
= data
;
1101 fe
->inversion
= INVERSION_OFF
;
1103 list_for_each (entry
, &frontend_ioctl_list
) {
1104 struct dvb_frontend_ioctl_data
*ioctl
;
1106 ioctl
= list_entry (entry
,
1107 struct dvb_frontend_ioctl_data
,
1110 if (ioctl
->adapter
== i2c
->adapter
) {
1111 fe
->frontend
.before_ioctl
= ioctl
->before_ioctl
;
1112 fe
->frontend
.after_ioctl
= ioctl
->after_ioctl
;
1113 fe
->frontend
.before_after_data
= ioctl
->before_after_data
;
1118 list_for_each (entry
, &frontend_notifier_list
) {
1119 struct dvb_frontend_notifier_data
*notifier
;
1121 notifier
= list_entry (entry
,
1122 struct dvb_frontend_notifier_data
,
1125 if (notifier
->adapter
== i2c
->adapter
) {
1126 fe
->frontend
.notifier_callback
= notifier
->callback
;
1127 fe
->frontend
.notifier_data
= notifier
->data
;
1132 list_add_tail (&fe
->list_head
, &frontend_list
);
1134 printk ("DVB: registering frontend %i:%i (%s)...\n",
1135 fe
->frontend
.i2c
->adapter
->num
, fe
->frontend
.i2c
->id
,
1138 dvb_register_device (i2c
->adapter
, &fe
->dvbdev
, &dvbdev_template
,
1139 fe
, DVB_DEVICE_FRONTEND
);
1141 if ((info
->caps
& FE_NEEDS_BENDING
) || (dvb_override_frequency_bending
== 2))
1142 do_frequency_bending
= 1;
1144 up (&frontend_mutex
);
1150 int dvb_unregister_frontend (int (*ioctl
) (struct dvb_frontend
*frontend
,
1151 unsigned int cmd
, void *arg
),
1152 struct dvb_i2c_bus
*i2c
)
1154 struct list_head
*entry
, *n
;
1156 dprintk ("%s\n", __FUNCTION__
);
1158 down (&frontend_mutex
);
1160 list_for_each_safe (entry
, n
, &frontend_list
) {
1161 struct dvb_frontend_data
*fe
;
1163 fe
= list_entry (entry
, struct dvb_frontend_data
, list_head
);
1165 if (fe
->frontend
.ioctl
== ioctl
&& fe
->frontend
.i2c
== i2c
) {
1166 dvb_unregister_device (fe
->dvbdev
);
1168 up (&frontend_mutex
);
1169 dvb_frontend_stop (fe
);
1175 up (&frontend_mutex
);
1179 MODULE_PARM(dvb_frontend_debug
,"i");
1180 MODULE_PARM(dvb_shutdown_timeout
,"i");
1181 MODULE_PARM(dvb_override_frequency_bending
,"i");
1182 MODULE_PARM(dvb_force_auto_inversion
,"i");
1183 MODULE_PARM(dvb_override_tune_delay
,"i");
1185 MODULE_PARM_DESC(dvb_frontend_debug
, "enable verbose debug messages");
1186 MODULE_PARM_DESC(dvb_shutdown_timeout
, "wait <shutdown_timeout> seconds after close() before suspending hardware");
1187 MODULE_PARM_DESC(dvb_override_frequency_bending
, "0: normal (default), 1: never use frequency bending, 2: always use frequency bending");
1188 MODULE_PARM_DESC(dvb_force_auto_inversion
, "0: normal (default), 1: INVERSION_AUTO forced always");
1189 MODULE_PARM_DESC(dvb_override_tune_delay
, "0: normal (default), >0 => delay in milliseconds to wait for lock after a tune attempt");