tvheadend/dvb_fe.c
2008-04-21 17:29:11 +00:00

289 lines
6.6 KiB
C

/*
* TV Input - Linux DVB interface
* Copyright (C) 2007 Andreas Öman
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <linux/dvb/frontend.h>
#include <linux/dvb/dmx.h>
#include <libhts/htscfg.h>
#include "tvhead.h"
#include "dispatch.h"
#include "dvb.h"
#include "dvb_support.h"
#include "diseqc.h"
#include "notify.h"
typedef struct dvb_fe_cmd {
TAILQ_ENTRY(dvb_fe_cmd) link;
th_dvb_mux_instance_t *tdmi;
} dvb_fe_cmd_t;
/**
* On some cards the FEC readout, tuning and such things takes a very long
* time (~0.5 s). Therefore we need to do the tuning and monitoring in a
* separate thread
*/
static void *
dvb_fe_manager(void *aux)
{
th_dvb_adapter_t *tda = aux;
struct timespec ts;
dvb_fe_cmd_t *c;
int i, v;
th_dvb_mux_instance_t *tdmi = NULL;
fe_status_t fe_status;
th_dvb_table_t *tdt;
struct dvb_frontend_parameters p;
char buf[100];
while(1) {
ts.tv_sec = time(NULL) + 1;
ts.tv_nsec = 0;
pthread_mutex_lock(&tda->tda_lock);
pthread_cond_timedwait(&tda->tda_cond, &tda->tda_lock, &ts);
c = TAILQ_FIRST(&tda->tda_fe_cmd_queue);
if(c != NULL) {
if(tdmi != NULL)
dvb_mux_unref(tdmi);
TAILQ_REMOVE(&tda->tda_fe_cmd_queue, c, link);
}
if(c != NULL) {
/* Switch to a new mux */
tdmi = c->tdmi;
if(tdmi->tdmi_refcnt == 1) {
dvb_mux_unref(tdmi);
tdmi = NULL;
pthread_mutex_unlock(&tda->tda_lock);
continue;
}
pthread_mutex_unlock(&tda->tda_lock);
p = *tdmi->tdmi_fe_params;
if(tda->tda_type == FE_QPSK) {
/* DVB-S */
int lowfreq, hifreq, switchfreq, hiband;
lowfreq = atoi(config_get_str("lnb_lowfreq", "9750000" ));
hifreq = atoi(config_get_str("lnb_hifreq", "10600000"));
switchfreq = atoi(config_get_str("lnb_switchfreq", "11700000"));
hiband = switchfreq && p.frequency > switchfreq;
diseqc_setup(tda->tda_fe_fd,
0, /* switch position */
tdmi->tdmi_polarisation == POLARISATION_HORIZONTAL,
hiband);
usleep(50000);
if(hiband)
p.frequency = abs(p.frequency - hifreq);
else
p.frequency = abs(p.frequency - lowfreq);
}
i = ioctl(tda->tda_fe_fd, FE_SET_FRONTEND, &p);
if(i != 0) {
dvb_mux_nicename(buf, sizeof(buf), tdmi);
syslog(LOG_ERR, "\"%s\" tuning to \"%s\""
" -- Front configuration failed -- %s",
tda->tda_rootpath, buf, strerror(errno));
}
free(c);
time(&tdmi->tdmi_got_adapter);
/* Now that we have tuned, start demuxing of tables */
pthread_mutex_lock(&tdmi->tdmi_table_lock);
LIST_FOREACH(tdt, &tdmi->tdmi_tables, tdt_link) {
if(tdt->tdt_fparams == NULL)
continue;
ioctl(tdt->tdt_fd, DMX_SET_FILTER, tdt->tdt_fparams);
free(tdt->tdt_fparams);
tdt->tdt_fparams = NULL;
}
pthread_mutex_unlock(&tdmi->tdmi_table_lock);
/* Allow tuning to settle */
sleep(1);
/* Reset FEC counter */
ioctl(tda->tda_fe_fd, FE_READ_UNCORRECTED_BLOCKS, &v);
}
pthread_mutex_unlock(&tda->tda_lock);
if(tdmi == NULL)
continue;
fe_status = 0;
ioctl(tda->tda_fe_fd, FE_READ_STATUS, &fe_status);
if(fe_status & FE_HAS_LOCK) {
tdmi->tdmi_status = NULL;
} else if(fe_status & FE_HAS_SYNC)
tdmi->tdmi_status = "No lock, Sync Ok";
else if(fe_status & FE_HAS_VITERBI)
tdmi->tdmi_status = "No lock, FEC stable";
else if(fe_status & FE_HAS_CARRIER)
tdmi->tdmi_status = "Carrier only";
else if(fe_status & FE_HAS_SIGNAL)
tdmi->tdmi_status = "Faint signal";
else
tdmi->tdmi_status = "No signal";
ioctl(tda->tda_fe_fd, FE_READ_UNCORRECTED_BLOCKS, &v);
if(v < 0)
v = 0;
if(fe_status & FE_HAS_LOCK) {
tdmi->tdmi_fec_err_histogram[tdmi->tdmi_fec_err_ptr] = v;
tdmi->tdmi_fec_err_ptr++;
if(tdmi->tdmi_fec_err_ptr == TDMI_FEC_ERR_HISTOGRAM_SIZE)
tdmi->tdmi_fec_err_ptr = 0;
}
}
}
/**
* Startup the FE management thread
*/
void
dvb_fe_start(th_dvb_adapter_t *tda)
{
pthread_t ptid;
pthread_create(&ptid, NULL, dvb_fe_manager, tda);
}
/**
* Stop the given TDMI
*/
void
tdmi_stop(th_dvb_mux_instance_t *tdmi)
{
th_dvb_table_t *tdt;
tdmi->tdmi_adapter->tda_mux_current = NULL;
pthread_mutex_lock(&tdmi->tdmi_table_lock);
while((tdt = LIST_FIRST(&tdmi->tdmi_tables)) != NULL)
dvb_tdt_destroy(tdt);
pthread_mutex_unlock(&tdmi->tdmi_table_lock);
tdmi->tdmi_state = TDMI_IDLE;
notify_tdmi_state_change(tdmi);
time(&tdmi->tdmi_lost_adapter);
}
/**
* Tune an adapter to a mux instance (but only if needed)
*/
void
dvb_tune_tdmi(th_dvb_mux_instance_t *tdmi, int maylog, tdmi_state_t state)
{
dvb_fe_cmd_t *c;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
char buf[100];
if(tdmi->tdmi_state != state) {
tdmi->tdmi_state = state;
notify_tdmi_state_change(tdmi);
}
if(tda->tda_mux_current == tdmi)
return;
if(tda->tda_mux_current != NULL)
tdmi_stop(tda->tda_mux_current);
tda->tda_mux_current = tdmi;
if(maylog) {
dvb_mux_nicename(buf, sizeof(buf), tdmi);
syslog(LOG_DEBUG, "\"%s\" tuning to mux \"%s\"", tda->tda_rootpath, buf);
}
/* Add tables which will be activated once the tuning is completed */
dvb_table_add_default(tdmi);
/* Send command to the thread */
c = malloc(sizeof(dvb_fe_cmd_t));
c->tdmi = tdmi;
pthread_mutex_lock(&tda->tda_lock);
tdmi->tdmi_refcnt++;
TAILQ_INSERT_TAIL(&tda->tda_fe_cmd_queue, c, link);
pthread_cond_signal(&tda->tda_cond);
pthread_mutex_unlock(&tda->tda_lock);
}
/**
* Flush pending tuning commands for frontend
*
* tda_lock must be held
*/
void
dvb_fe_flush(th_dvb_mux_instance_t *tdmi)
{
dvb_fe_cmd_t *c;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
TAILQ_FOREACH(c, &tda->tda_fe_cmd_queue, link)
if(c->tdmi == tdmi)
break;
if(c == NULL)
return;
TAILQ_REMOVE(&tda->tda_fe_cmd_queue, c, link);
dvb_mux_unref(tdmi);
free(c);
}