Imported FE_REFACTORING to HEAD

1 files changed, 182 insertions, 460 deletions

diff --git a/linux/drivers/media/dvb/frontends/nxt6000.c b/linux/drivers/media/dvb/frontends/nxt6000.c
index 7983b55fd..c0fa123e9 100644
--- a/linux/drivers/media/dvb/frontends/nxt6000.c
+++ b/linux/drivers/media/dvb/frontends/nxt6000.c
@@ -1,12 +1,6 @@
 /*
 	NxtWave Communications - NXT6000 demodulator driver
 
-	This driver currently supports:
-
-	Alps TDME7 (Tuner: MITEL SP5659)
-	Alps TDED4 (Tuner: TI ALP510, external Nxt6000)
-	Comtech DVBT-6k07 (PLL IC: SP5730)
-
     Copyright (C) 2002-2003 Florian Schirmer <jolt@tuxbox.org>
     Copyright (C) 2003 Paul Andreassen <paul@andreassen.com.au>
 
@@ -32,216 +26,68 @@
 #include <linux/slab.h>
 
 #include "dvb_frontend.h"
+#include "nxt6000_priv.h"
 #include "nxt6000.h"
 
-MODULE_DESCRIPTION("NxtWave NXT6000 DVB demodulator driver");
-MODULE_AUTHOR("Florian Schirmer");
-MODULE_LICENSE("GPL");
 
-static int debug = 0;
-MODULE_PARM(debug, "i");
-
-static struct dvb_frontend_info nxt6000_info = {
-	.name = "NxtWave NXT6000",
-	.type = FE_OFDM,
-	.frequency_min = 0,
-	.frequency_max = 863250000,
-	.frequency_stepsize = 62500,
-	/*.frequency_tolerance = *//* FIXME: 12% of SR */
-	.symbol_rate_min = 0,	/* FIXME */
-	.symbol_rate_max = 9360000,	/* FIXME */
-	.symbol_rate_tolerance = 4000,
-	.notifier_delay = 0,
-	.caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
-                FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
-                FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
-                FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
-                FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
-                FE_CAN_HIERARCHY_AUTO,
-};
 
-struct nxt6000_config {
-	u8 demod_addr;
-	u8 tuner_addr;
-	u8 tuner_type;
-	u8 clock_inversion;
-	struct i2c_adapter *i2c;
-	struct dvb_adapter *dvb;
-};
+struct nxt6000_state {
+
+	struct i2c_adapter* i2c;
 
-#define TUNER_TYPE_ALP510	0
-#define TUNER_TYPE_SP5659	1
-#define TUNER_TYPE_SP5730	2
+	struct dvb_frontend_ops ops;
 
-// #define FE2NXT(fe) ((struct nxt6000_config *)((fe)->data))
-#define FREQ2DIV(freq) ((freq + 36166667) / 166667)
+	/* configuration settings */
+	const struct nxt6000_config* config;
 
+	struct dvb_frontend frontend;
+
+};
+
+static int debug = 0;
 #define dprintk if (debug) printk
 
-static int nxt6000_write(struct i2c_adapter *i2c, u8 addr, u8 reg, u8 data)
+static int nxt6000_writereg(struct nxt6000_state* state, u8 reg, u8 data)
 {
 	u8 buf[] = { reg, data };
-	struct i2c_msg msg = {.addr = addr >> 1,.flags = 0,.buf = buf,.len = 2 };
+	struct i2c_msg msg = {.addr = state->config->demod_address,.flags = 0,.buf = buf,.len = 2 };
 	int ret;
 
-	if ((ret = i2c_transfer(i2c, &msg, 1)) != 1)
-		dprintk("nxt6000: nxt6000_write error (.addr = 0x%02X, reg: 0x%02X, data: 0x%02X, ret: %d)\n", addr, reg, data, ret);
+	if ((ret = i2c_transfer(state->i2c, &msg, 1)) != 1)
+		dprintk("nxt6000: nxt6000_write error (reg: 0x%02X, data: 0x%02X, ret: %d)\n", reg, data, ret);
 
 	return (ret != 1) ? -EFAULT : 0;
 }
 
-static u8 nxt6000_writereg(struct nxt6000_config *nxt, u8 reg, u8 data)
-{
-	return nxt6000_write(nxt->i2c, nxt->demod_addr, reg, data);
-}
-
-static u8 nxt6000_read(struct i2c_adapter *i2c, u8 addr, u8 reg)
+static u8 nxt6000_readreg(struct nxt6000_state* state, u8 reg)
 {
 	int ret;
 	u8 b0[] = { reg };
 	u8 b1[] = { 0 };
 	struct i2c_msg msgs[] = {
-		{.addr = addr >> 1,.flags = 0,.buf = b0,.len = 1},
-		{.addr = addr >> 1,.flags = I2C_M_RD,.buf = b1,.len = 1}
+		{.addr = state->config->demod_address,.flags = 0,.buf = b0,.len = 1},
+		{.addr = state->config->demod_address,.flags = I2C_M_RD,.buf = b1,.len = 1}
 	};
 
-	ret = i2c_transfer(i2c, msgs, 2);
+	ret = i2c_transfer(state->i2c, msgs, 2);
 
 	if (ret != 2)
-		dprintk("nxt6000: nxt6000_read error (.addr = 0x%02X, reg: 0x%02X, ret: %d)\n", addr, reg, ret);
+		dprintk("nxt6000: nxt6000_read error (reg: 0x%02X, ret: %d)\n", reg, ret);
 
 	return b1[0];
 }
 
-static u8 nxt6000_readreg(struct nxt6000_config *nxt, u8 reg)
-{
-	return nxt6000_read(nxt->i2c, nxt->demod_addr, reg);
-}
-
-static int pll_test(struct i2c_adapter *i2c, u8 demod_addr, u8 tuner_addr)
-{
-	u8 buf [1];
-	struct i2c_msg msg = {.addr = tuner_addr >> 1,.flags = I2C_M_RD,.buf = buf,.len = 1 };
-	int ret;
-
-	nxt6000_write(i2c, demod_addr, ENABLE_TUNER_IIC, 0x01);	/* open i2c bus switch */
-	ret = i2c_transfer(i2c, &msg, 1);
-	nxt6000_write(i2c, demod_addr, ENABLE_TUNER_IIC, 0x00);	/* close i2c bus switch */
-
-	return (ret != 1) ? -EFAULT : 0;
-}
-
-static int pll_write(struct i2c_adapter *i2c, u8 demod_addr, u8 tuner_addr, u8 * buf, u8 len)
-{
-	struct i2c_msg msg = {.addr = tuner_addr >> 1,.flags = 0,.buf = buf,.len = len };
-	int ret;
-
-	nxt6000_write(i2c, demod_addr, ENABLE_TUNER_IIC, 0x01);	/* open i2c bus switch */
-	ret = i2c_transfer(i2c, &msg, 1);
-	nxt6000_write(i2c, demod_addr, ENABLE_TUNER_IIC, 0x00);	/* close i2c bus switch */
-
-	if (ret != 1)
-		dprintk("nxt6000: pll_write error %d\n", ret);
-
-	return (ret != 1) ? -EFAULT : 0;
-}
-
-static int sp5659_set_tv_freq(struct nxt6000_config *nxt, u32 freq)
-{
-	u8 buf[4];
-
-	buf[0] = (FREQ2DIV(freq) >> 8) & 0x7F;
-	buf[1] = FREQ2DIV(freq) & 0xFF;
-	buf[2] = (((FREQ2DIV(freq) >> 15) & 0x03) << 5) | 0x85;
-
-	if ((freq >= 174000000) && (freq < 230000000))
-		buf[3] = 0x82;
-	else if ((freq >= 470000000) && (freq < 782000000))
-		buf[3] = 0x85;
-	else if ((freq >= 782000000) && (freq < 863000000))
-		buf[3] = 0xC5;
-	else
-		return -EINVAL;
-
-	return pll_write(nxt->i2c, nxt->demod_addr, nxt->tuner_addr, buf, 4);
-}
-
-static int alp510_set_tv_freq(struct nxt6000_config *nxt, u32 freq)
-{
-	u8 buf[4];
-
-	buf[0] = (FREQ2DIV(freq) >> 8) & 0x7F;
-	buf[1] = FREQ2DIV(freq) & 0xFF;
-	buf[2] = 0x85;
-
-#if 0
-	if ((freq >= 47000000) && (freq < 153000000))
-		buf[3] = 0x01;
-	else if ((freq >= 153000000) && (freq < 430000000))
-		buf[3] = 0x02;
-	else if ((freq >= 430000000) && (freq < 824000000))
-		buf[3] = 0x08;
-	else if ((freq >= 824000000) && (freq < 863000000))
-		buf[3] = 0x88;
-	else
-		return -EINVAL;
-#else
-	if ((freq >= 47000000) && (freq < 153000000))
-		buf[3] = 0x01;
-	else if ((freq >= 153000000) && (freq < 430000000))
-		buf[3] = 0x02;
-	else if ((freq >= 430000000) && (freq < 824000000))
-		buf[3] = 0x0C;
-	else if ((freq >= 824000000) && (freq < 863000000))
-		buf[3] = 0x8C;
-	else
-		return -EINVAL;
-#endif
-
-	return pll_write(nxt->i2c, nxt->demod_addr, nxt->tuner_addr, buf, 4);
-}
-
-static int sp5730_set_tv_freq(struct nxt6000_config *nxt, u32 freq)
-{
-	u8 buf[4];
-
-	buf[0] = (FREQ2DIV(freq) >> 8) & 0x7F;
-	buf[1] = FREQ2DIV(freq) & 0xFF;
-	buf[2] = 0x93;
-
-	if ((freq >= 51000000) && (freq < 132100000))
-		buf[3] = 0x05;
-	else if ((freq >= 132100000) && (freq < 143000000))
-		buf[3] = 0x45;
-	else if ((freq >= 146000000) && (freq < 349100000))
-		buf[3] = 0x06;
-	else if ((freq >= 349100000) && (freq < 397100000))
-		buf[3] = 0x46;
-	else if ((freq >= 397100000) && (freq < 426000000))
-		buf[3] = 0x86;
-	else if ((freq >= 430000000) && (freq < 659100000))
-		buf[3] = 0x03;
-	else if ((freq >= 659100000) && (freq < 759100000))
-		buf[3] = 0x43;
-	else if ((freq >= 759100000) && (freq < 858000000))
-		buf[3] = 0x83;
-	else
-		return -EINVAL;
-
-	return pll_write(nxt->i2c, nxt->demod_addr, nxt->tuner_addr, buf, 4);
-}
-
-static void nxt6000_reset(struct nxt6000_config *fe)
+static void nxt6000_reset(struct nxt6000_state* state)
 {
 	u8 val;
 
-	val = nxt6000_readreg(fe, OFDM_COR_CTL);
+	val = nxt6000_readreg(state, OFDM_COR_CTL);
 
-	nxt6000_writereg(fe, OFDM_COR_CTL, val & ~COREACT);
-	nxt6000_writereg(fe, OFDM_COR_CTL, val | COREACT);
+	nxt6000_writereg(state, OFDM_COR_CTL, val & ~COREACT);
+	nxt6000_writereg(state, OFDM_COR_CTL, val | COREACT);
 }
 
-static int nxt6000_set_bandwidth(struct nxt6000_config *fe, fe_bandwidth_t bandwidth)
+static int nxt6000_set_bandwidth(struct nxt6000_state* state, fe_bandwidth_t bandwidth)
 {
 	u16 nominal_rate;
 	int result;
@@ -264,43 +110,43 @@ static int nxt6000_set_bandwidth(struct nxt6000_config *fe, fe_bandwidth_t bandw
 		return -EINVAL;
 	}
 
-	if ((result = nxt6000_writereg(fe, OFDM_TRL_NOMINALRATE_1, nominal_rate & 0xFF)) < 0)
+	if ((result = nxt6000_writereg(state, OFDM_TRL_NOMINALRATE_1, nominal_rate & 0xFF)) < 0)
 		return result;
 
-	return nxt6000_writereg(fe, OFDM_TRL_NOMINALRATE_2, (nominal_rate >> 8) & 0xFF);
+	return nxt6000_writereg(state, OFDM_TRL_NOMINALRATE_2, (nominal_rate >> 8) & 0xFF);
 }
 
-static int nxt6000_set_guard_interval(struct nxt6000_config *fe, fe_guard_interval_t guard_interval)
+static int nxt6000_set_guard_interval(struct nxt6000_state* state, fe_guard_interval_t guard_interval)
 {
 	switch (guard_interval) {
 
 	case GUARD_INTERVAL_1_32:
-		return nxt6000_writereg(fe, OFDM_COR_MODEGUARD, 0x00 | (nxt6000_readreg(fe, OFDM_COR_MODEGUARD) & ~0x03));
+		return nxt6000_writereg(state, OFDM_COR_MODEGUARD, 0x00 | (nxt6000_readreg(state, OFDM_COR_MODEGUARD) & ~0x03));
 
 	case GUARD_INTERVAL_1_16:
-		return nxt6000_writereg(fe, OFDM_COR_MODEGUARD, 0x01 | (nxt6000_readreg(fe, OFDM_COR_MODEGUARD) & ~0x03));
+		return nxt6000_writereg(state, OFDM_COR_MODEGUARD, 0x01 | (nxt6000_readreg(state, OFDM_COR_MODEGUARD) & ~0x03));
 
 	case GUARD_INTERVAL_AUTO:
 	case GUARD_INTERVAL_1_8:
-		return nxt6000_writereg(fe, OFDM_COR_MODEGUARD, 0x02 | (nxt6000_readreg(fe, OFDM_COR_MODEGUARD) & ~0x03));
+		return nxt6000_writereg(state, OFDM_COR_MODEGUARD, 0x02 | (nxt6000_readreg(state, OFDM_COR_MODEGUARD) & ~0x03));
 
 	case GUARD_INTERVAL_1_4:
-		return nxt6000_writereg(fe, OFDM_COR_MODEGUARD, 0x03 | (nxt6000_readreg(fe, OFDM_COR_MODEGUARD) & ~0x03));
+		return nxt6000_writereg(state, OFDM_COR_MODEGUARD, 0x03 | (nxt6000_readreg(state, OFDM_COR_MODEGUARD) & ~0x03));
 
 	default:
 		return -EINVAL;
 	}
 }
 
-static int nxt6000_set_inversion(struct nxt6000_config *fe, fe_spectral_inversion_t inversion)
+static int nxt6000_set_inversion(struct nxt6000_state* state, fe_spectral_inversion_t inversion)
 {
 	switch (inversion) {
 
 	case INVERSION_OFF:
-		return nxt6000_writereg(fe, OFDM_ITB_CTL, 0x00);
+		return nxt6000_writereg(state, OFDM_ITB_CTL, 0x00);
 
 	case INVERSION_ON:
-		return nxt6000_writereg(fe, OFDM_ITB_CTL, ITBINV);
+		return nxt6000_writereg(state, OFDM_ITB_CTL, ITBINV);
 
 	default:
 		return -EINVAL;
@@ -308,24 +154,24 @@ static int nxt6000_set_inversion(struct nxt6000_config *fe, fe_spectral_inversio
 	}
 }
 
-static int nxt6000_set_transmission_mode(struct nxt6000_config *fe, fe_transmit_mode_t transmission_mode)
+static int nxt6000_set_transmission_mode(struct nxt6000_state* state, fe_transmit_mode_t transmission_mode)
 {
 	int result;
 
 	switch (transmission_mode) {
 
 	case TRANSMISSION_MODE_2K:
-		if ((result = nxt6000_writereg(fe, EN_DMD_RACQ, 0x00 | (nxt6000_readreg(fe, EN_DMD_RACQ) & ~0x03))) < 0)
+		if ((result = nxt6000_writereg(state, EN_DMD_RACQ, 0x00 | (nxt6000_readreg(state, EN_DMD_RACQ) & ~0x03))) < 0)
 			return result;
 
-		return nxt6000_writereg(fe, OFDM_COR_MODEGUARD, (0x00 << 2) | (nxt6000_readreg(fe, OFDM_COR_MODEGUARD) & ~0x04));
+		return nxt6000_writereg(state, OFDM_COR_MODEGUARD, (0x00 << 2) | (nxt6000_readreg(state, OFDM_COR_MODEGUARD) & ~0x04));
 
 	case TRANSMISSION_MODE_8K:
 	case TRANSMISSION_MODE_AUTO:
-		if ((result = nxt6000_writereg(fe, EN_DMD_RACQ, 0x02 | (nxt6000_readreg(fe, EN_DMD_RACQ) & ~0x03))) < 0)
+		if ((result = nxt6000_writereg(state, EN_DMD_RACQ, 0x02 | (nxt6000_readreg(state, EN_DMD_RACQ) & ~0x03))) < 0)
 			return result;
 
-		return nxt6000_writereg(fe, OFDM_COR_MODEGUARD, (0x01 << 2) | (nxt6000_readreg(fe, OFDM_COR_MODEGUARD) & ~0x04));
+		return nxt6000_writereg(state, OFDM_COR_MODEGUARD, (0x01 << 2) | (nxt6000_readreg(state, OFDM_COR_MODEGUARD) & ~0x04));
 
 	default:
 		return -EINVAL;
@@ -333,35 +179,43 @@ static int nxt6000_set_transmission_mode(struct nxt6000_config *fe, fe_transmit_
 	}
 }
 
-static void nxt6000_setup(struct nxt6000_config *fe)
+static void nxt6000_setup(struct dvb_frontend* fe)
 {
-	nxt6000_writereg(fe, RS_COR_SYNC_PARAM, SYNC_PARAM);
-	nxt6000_writereg(fe, BER_CTRL, /*(1 << 2) | */ (0x01 << 1) | 0x01);
-	nxt6000_writereg(fe, VIT_COR_CTL, VIT_COR_RESYNC);
-	nxt6000_writereg(fe, OFDM_COR_CTL, (0x01 << 5) | (nxt6000_readreg(fe, OFDM_COR_CTL) & 0x0F));
-	nxt6000_writereg(fe, OFDM_COR_MODEGUARD, FORCEMODE8K | 0x02);
-	nxt6000_writereg(fe, OFDM_AGC_CTL, AGCLAST | INITIAL_AGC_BW);
-	nxt6000_writereg(fe, OFDM_ITB_FREQ_1, 0x06);
-	nxt6000_writereg(fe, OFDM_ITB_FREQ_2, 0x31);
-	nxt6000_writereg(fe, OFDM_CAS_CTL, (0x01 << 7) | (0x02 << 3) | 0x04);
-	nxt6000_writereg(fe, CAS_FREQ, 0xBB);	/* CHECKME */
-	nxt6000_writereg(fe, OFDM_SYR_CTL, 1 << 2);
-	nxt6000_writereg(fe, OFDM_PPM_CTL_1, PPM256);
-	nxt6000_writereg(fe, OFDM_TRL_NOMINALRATE_1, 0x49);
-	nxt6000_writereg(fe, OFDM_TRL_NOMINALRATE_2, 0x72);
-	nxt6000_writereg(fe, ANALOG_CONTROL_0, 1 << 5);
-	nxt6000_writereg(fe, EN_DMD_RACQ, (1 << 7) | (3 << 4) | 2);
-	nxt6000_writereg(fe, DIAG_CONFIG, TB_SET);
-
-	if (fe->clock_inversion)
-		nxt6000_writereg(fe, SUB_DIAG_MODE_SEL, CLKINVERSION);
+	struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+
+	nxt6000_writereg(state, RS_COR_SYNC_PARAM, SYNC_PARAM);
+	nxt6000_writereg(state, BER_CTRL, /*(1 << 2) | */ (0x01 << 1) | 0x01);
+	nxt6000_writereg(state, VIT_COR_CTL, VIT_COR_RESYNC);
+	nxt6000_writereg(state, OFDM_COR_CTL, (0x01 << 5) | (nxt6000_readreg(state, OFDM_COR_CTL) & 0x0F));
+	nxt6000_writereg(state, OFDM_COR_MODEGUARD, FORCEMODE8K | 0x02);
+	nxt6000_writereg(state, OFDM_AGC_CTL, AGCLAST | INITIAL_AGC_BW);
+	nxt6000_writereg(state, OFDM_ITB_FREQ_1, 0x06);
+	nxt6000_writereg(state, OFDM_ITB_FREQ_2, 0x31);
+	nxt6000_writereg(state, OFDM_CAS_CTL, (0x01 << 7) | (0x02 << 3) | 0x04);
+	nxt6000_writereg(state, CAS_FREQ, 0xBB);	/* CHECKME */
+	nxt6000_writereg(state, OFDM_SYR_CTL, 1 << 2);
+	nxt6000_writereg(state, OFDM_PPM_CTL_1, PPM256);
+	nxt6000_writereg(state, OFDM_TRL_NOMINALRATE_1, 0x49);
+	nxt6000_writereg(state, OFDM_TRL_NOMINALRATE_2, 0x72);
+	nxt6000_writereg(state, ANALOG_CONTROL_0, 1 << 5);
+	nxt6000_writereg(state, EN_DMD_RACQ, (1 << 7) | (3 << 4) | 2);
+	nxt6000_writereg(state, DIAG_CONFIG, TB_SET);
+
+	if (state->config->clock_inversion)
+		nxt6000_writereg(state, SUB_DIAG_MODE_SEL, CLKINVERSION);
 	else
-		nxt6000_writereg(fe, SUB_DIAG_MODE_SEL, 0);
+		nxt6000_writereg(state, SUB_DIAG_MODE_SEL, 0);
 
-	nxt6000_writereg(fe, TS_FORMAT, 0);
+	nxt6000_writereg(state, TS_FORMAT, 0);
+
+	if (state->config->pll_init) {
+		nxt6000_writereg(state, ENABLE_TUNER_IIC, 0x01);	/* open i2c bus switch */
+		state->config->pll_init(fe);
+		nxt6000_writereg(state, ENABLE_TUNER_IIC, 0x00);	/* close i2c bus switch */
+	}
 }
 
-static void nxt6000_dump_status(struct nxt6000_config *fe)
+static void nxt6000_dump_status(struct nxt6000_state *state)
 {
 	u8 val;
 
@@ -379,12 +233,12 @@ static void nxt6000_dump_status(struct nxt6000_config *fe)
 */
 	printk("NXT6000 status:");
 
-	val = nxt6000_readreg(fe, RS_COR_STAT);
+	val = nxt6000_readreg(state, RS_COR_STAT);
 
 	printk(" DATA DESCR LOCK: %d,", val & 0x01);
 	printk(" DATA SYNC LOCK: %d,", (val >> 1) & 0x01);
 
-	val = nxt6000_readreg(fe, VIT_SYNC_STATUS);
+	val = nxt6000_readreg(state, VIT_SYNC_STATUS);
 
 	printk(" VITERBI LOCK: %d,", (val >> 7) & 0x01);
 
@@ -415,7 +269,7 @@ static void nxt6000_dump_status(struct nxt6000_config *fe)
 
 	}
 
-	val = nxt6000_readreg(fe, OFDM_COR_STAT);
+	val = nxt6000_readreg(state, OFDM_COR_STAT);
 
 	printk(" CHCTrack: %d,", (val >> 7) & 0x01);
 	printk(" TPSLock: %d,", (val >> 6) & 0x01);
@@ -457,7 +311,7 @@ static void nxt6000_dump_status(struct nxt6000_config *fe)
 
 	}
 
-	val = nxt6000_readreg(fe, OFDM_SYR_STAT);
+	val = nxt6000_readreg(state, OFDM_SYR_STAT);
 
 	printk(" SYRLock: %d,", (val >> 4) & 0x01);
 	printk(" SYRMode: %s,", (val >> 2) & 0x01 ? "8K" : "2K");
@@ -481,7 +335,7 @@ static void nxt6000_dump_status(struct nxt6000_config *fe)
 		break;
 	}
 
-	val = nxt6000_readreg(fe, OFDM_TPS_RCVD_3);
+	val = nxt6000_readreg(state, OFDM_TPS_RCVD_3);
 
 	switch ((val >> 4) & 0x07) {
 
@@ -537,7 +391,7 @@ static void nxt6000_dump_status(struct nxt6000_config *fe)
 
 	}
 
-	val = nxt6000_readreg(fe, OFDM_TPS_RCVD_4);
+	val = nxt6000_readreg(state, OFDM_TPS_RCVD_4);
 
 	printk(" TPSMode: %s,", val & 0x01 ? "8K" : "2K");
 
@@ -562,288 +416,156 @@ static void nxt6000_dump_status(struct nxt6000_config *fe)
 	}
 
 	/* Strange magic required to gain access to RF_AGC_STATUS */
-	nxt6000_readreg(fe, RF_AGC_VAL_1);
-	val = nxt6000_readreg(fe, RF_AGC_STATUS);
-	val = nxt6000_readreg(fe, RF_AGC_STATUS);
+	nxt6000_readreg(state, RF_AGC_VAL_1);
+	val = nxt6000_readreg(state, RF_AGC_STATUS);
+	val = nxt6000_readreg(state, RF_AGC_STATUS);
 
 	printk(" RF AGC LOCK: %d,", (val >> 4) & 0x01);
 	printk("\n");
 }
 
-static int nxt6000_ioctl(struct dvb_frontend *f, unsigned int cmd, void *arg)
-{
-	struct nxt6000_config *fe = (struct nxt6000_config *) f->data;
-
-	switch (cmd) {
-
-	case FE_GET_INFO:
-		memcpy(arg, &nxt6000_info, sizeof(struct dvb_frontend_info));
-		return 0;
-
-	case FE_READ_STATUS:
-		{
-			fe_status_t *status = (fe_status_t *) arg;
-
-			u8 core_status;
-
-			*status = 0;
-
-			core_status = nxt6000_readreg(fe, OFDM_COR_STAT);
 
-			if (core_status & AGCLOCKED)
-				*status |= FE_HAS_SIGNAL;
 
-			if (nxt6000_readreg(fe, OFDM_SYR_STAT) & GI14_SYR_LOCK)
-				*status |= FE_HAS_CARRIER;
 
-			if (nxt6000_readreg(fe, VIT_SYNC_STATUS) & VITINSYNC)
-				*status |= FE_HAS_VITERBI;
 
-			if (nxt6000_readreg(fe, RS_COR_STAT) & RSCORESTATUS)
-				*status |= FE_HAS_SYNC;
 
-			if ((core_status & TPSLOCKED) && (*status == (FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)))
-				*status |= FE_HAS_LOCK;
 
-			if (debug)
-				nxt6000_dump_status(fe);
 
-			return 0;
 
-		}
 
-	case FE_READ_BER:
-		{
-			u32 *ber = (u32 *) arg;
 
-			*ber = 0;
-
-			return 0;
-
-		}
-
-	case FE_READ_SIGNAL_STRENGTH:
-		{
-			s16 *signal = (s16 *) arg;
-/*
-			*signal=(((signed char)readreg(client, 0x16))+128)<<8;
-*/
-			*signal = 0;
-			return 0;
-
-		}
-
-	case FE_READ_SNR:
-		{
-			s16 *snr = (s16 *) arg;
-/*
-			*snr=readreg(client, 0x24)<<8;
-			*snr|=readreg(client, 0x25);
-*/
-			*snr = 0;
-			break;
-		}
-
-	case FE_READ_UNCORRECTED_BLOCKS:
-		{
-			u32 *ublocks = (u32 *) arg;
-
-			*ublocks = 0;
-			break;
-		}
-
-	case FE_INIT:
-		nxt6000_reset(fe);
-		nxt6000_setup(fe);
-		break;
-
-	case FE_SET_FRONTEND:
-		{
-			struct dvb_frontend_parameters *param = (struct dvb_frontend_parameters *) arg;
-			int result;
+static int nxt6000_read_status(struct dvb_frontend* fe, fe_status_t* status)
+{
+	u8 core_status;
+	struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
 
-			switch (fe->tuner_type) {
+	*status = 0;
 
-			case TUNER_TYPE_ALP510:
-				if ((result = alp510_set_tv_freq(fe, param->frequency)) < 0)
-					return result;
-				break;
+	core_status = nxt6000_readreg(state, OFDM_COR_STAT);
 
-			case TUNER_TYPE_SP5659:
-				if ((result = sp5659_set_tv_freq(fe, param->frequency)) < 0)
-					return result;
-				break;
+	if (core_status & AGCLOCKED)
+		*status |= FE_HAS_SIGNAL;
 
-			case TUNER_TYPE_SP5730:
-				if ((result = sp5730_set_tv_freq(fe, param->frequency)) < 0)
-					return result;
-				break;
+	if (nxt6000_readreg(state, OFDM_SYR_STAT) & GI14_SYR_LOCK)
+		*status |= FE_HAS_CARRIER;
 
-			default:
-				return -EFAULT;
+	if (nxt6000_readreg(state, VIT_SYNC_STATUS) & VITINSYNC)
+		*status |= FE_HAS_VITERBI;
 
-			}
+	if (nxt6000_readreg(state, RS_COR_STAT) & RSCORESTATUS)
+		*status |= FE_HAS_SYNC;
 
-			if ((result = nxt6000_set_bandwidth(fe, param->u.ofdm.bandwidth)) < 0)
-				return result;
-			if ((result = nxt6000_set_guard_interval(fe, param->u.ofdm.guard_interval)) < 0)
-				return result;
-			if ((result = nxt6000_set_transmission_mode(fe, param->u.ofdm.transmission_mode)) < 0)
-				return result;
-			if ((result = nxt6000_set_inversion(fe, param->inversion)) < 0)
-				return result;
+	if ((core_status & TPSLOCKED) && (*status == (FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)))
+		*status |= FE_HAS_LOCK;
 
-			break;
-		}
-
-	default:
-		return -EOPNOTSUPP;
-	}
+	if (debug)
+		nxt6000_dump_status(state);
 
 	return 0;
 }
 
-static u8 demod_addr_tbl[] = { 0x14, 0x18, 0x24, 0x28 };
-
-static struct i2c_client client_template;
-
-static int attach_adapter(struct i2c_adapter *adapter)
+static int nxt6000_init(struct dvb_frontend* fe)
 {
-	struct i2c_client *client;
-	struct nxt6000_config *nxt;
-	u8 addr_nr;
-	int ret;
-
-	if ((nxt = kmalloc(sizeof(struct nxt6000_config), GFP_KERNEL)) == NULL)
-		return -ENOMEM;
-
-	memset(nxt, 0, sizeof(*nxt));
-	nxt->i2c = adapter;
-
-	for (addr_nr = 0; addr_nr < sizeof(demod_addr_tbl); addr_nr++) {
+	struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
 
-		if (nxt6000_read(adapter, demod_addr_tbl[addr_nr], OFDM_MSC_REV) != NXT6000ASICDEVICE)
-			continue;
+	nxt6000_reset(state);
+	nxt6000_setup(fe);
 
-		if (pll_test(adapter, demod_addr_tbl[addr_nr], 0xC0) == 0) {
-			nxt->tuner_addr = 0xC0;
-			nxt->tuner_type = TUNER_TYPE_ALP510;
-			nxt->clock_inversion = 1;
-
-			dprintk("nxt6000: detected TI ALP510 tuner at 0x%02X\n", nxt->tuner_addr);
-
-		} else if (pll_test(adapter, demod_addr_tbl[addr_nr], 0xC2) == 0) {
-			nxt->tuner_addr = 0xC2;
-			nxt->tuner_type = TUNER_TYPE_SP5659;
-			nxt->clock_inversion = 0;
+	return 0;
+}
 
-			dprintk("nxt6000: detected MITEL SP5659 tuner at 0x%02X\n", nxt->tuner_addr);
 
-		} else if (pll_test(adapter, demod_addr_tbl[addr_nr], 0xC0) == 0) {
-			nxt->tuner_addr = 0xC0;
-			nxt->tuner_type = TUNER_TYPE_SP5730;
-			nxt->clock_inversion = 0;
+static int nxt6000_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *param)
+{
+	struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+	int result;
 
-			dprintk("nxt6000: detected SP5730 tuner at 0x%02X\n", nxt->tuner_addr);
+	nxt6000_writereg(state, ENABLE_TUNER_IIC, 0x01);	/* open i2c bus switch */
+	state->config->pll_set(fe, param);
+	nxt6000_writereg(state, ENABLE_TUNER_IIC, 0x00);	/* close i2c bus switch */
 
-		} else {
-			printk("nxt6000: unable to detect tuner\n");
-			continue;
-		}
-	}
+	if ((result = nxt6000_set_bandwidth(state, param->u.ofdm.bandwidth)) < 0)
+		return result;
+	if ((result = nxt6000_set_guard_interval(state, param->u.ofdm.guard_interval)) < 0)
+		return result;
+	if ((result = nxt6000_set_transmission_mode(state, param->u.ofdm.transmission_mode)) < 0)
+		return result;
+	if ((result = nxt6000_set_inversion(state, param->inversion)) < 0)
+		return result;
 
-	if (addr_nr == sizeof(demod_addr_tbl)) {
-		kfree(nxt);
-		return -ENODEV;
-	}
+	return 0;
+}
 
-	nxt->demod_addr = demod_addr_tbl[addr_nr];
 
-	if (NULL == (client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
-		kfree(nxt);
-		return -ENOMEM;
-	}
+static void nxt6000_release(struct dvb_frontend* fe)
+{
+	struct nxt6000_state* state = (struct nxt6000_state*) fe->demodulator_priv;
+	kfree(state);
+}
 
-	memcpy(client, &client_template, sizeof(struct i2c_client));
-	client->adapter = adapter;
-	client->addr = demod_addr_tbl[addr_nr];
-	i2c_set_clientdata(client, (void *) nxt);
+static struct dvb_frontend_ops nxt6000_ops;
 
-	ret = i2c_attach_client(client);
-	if (ret) 
-		goto out;
+struct dvb_frontend* nxt6000_attach(const struct nxt6000_config* config,
+				    struct i2c_adapter* i2c)
+{
+	struct nxt6000_state* state = NULL;
 
-	BUG_ON(!nxt->dvb);
+	/* allocate memory for the internal state */
+	state = (struct nxt6000_state*) kmalloc(sizeof(struct nxt6000_state), GFP_KERNEL);
+	if (state == NULL) goto error;
 
-	ret = dvb_register_frontend(nxt6000_ioctl, nxt->dvb, nxt, &nxt6000_info, THIS_MODULE);
-	if (ret) {
-		i2c_detach_client(client);
-		goto out;
-	}
+	/* setup the state */
+	state->config = config;
+	state->i2c = i2c;
+	memcpy(&state->ops, &nxt6000_ops, sizeof(struct dvb_frontend_ops));
 
-	ret = 0;
-out:
-	kfree(client);
-	kfree(nxt);
-	return ret;
-}
+	/* check if the demod is there */
+	if (nxt6000_readreg(state, OFDM_MSC_REV) != NXT6000ASICDEVICE) goto error;
 
-static int detach_client(struct i2c_client *client)
-{
-	struct nxt6000_config *state = (struct nxt6000_config *) i2c_get_clientdata(client);
-	dvb_unregister_frontend(nxt6000_ioctl, state->dvb);
-	i2c_detach_client(client);
-	BUG_ON(state->dvb);
-	kfree(client);
-	kfree(state);
-	return 0;
-}
+	/* create dvb_frontend */
+	state->frontend.ops = &state->ops;
+	state->frontend.demodulator_priv = state;
+	return &state->frontend;
 
-static int command(struct i2c_client *client, unsigned int cmd, void *arg)
-{
-	struct nxt6000_config *state = (struct nxt6000_config *) i2c_get_clientdata(client);
-
-	switch (cmd) {
-	case FE_REGISTER:{
-			state->dvb = (struct dvb_adapter *) arg;
-			break;
-		}
-	case FE_UNREGISTER:{
-			state->dvb = NULL;
-			break;
-		}
-	default:
-		return -EOPNOTSUPP;
-	}
-	return 0;
+error:
+	if (state) kfree(state);
+	return NULL;
 }
 
-static struct i2c_driver driver = {
-	.owner = THIS_MODULE,
-	.name = "nxt6000",
-	.id = I2C_DRIVERID_DVBFE_NXT6000,
-	.flags = I2C_DF_NOTIFY,
-	.attach_adapter = attach_adapter,
-	.detach_client = detach_client,
-	.command = command,
+static struct dvb_frontend_ops nxt6000_ops = {
+
+	.info = {
+		.name = "NxtWave NXT6000 DVB-T",
+		.type = FE_OFDM,
+		.frequency_min = 0,
+		.frequency_max = 863250000,
+		.frequency_stepsize = 62500,
+		/*.frequency_tolerance = *//* FIXME: 12% of SR */
+		.symbol_rate_min = 0,	/* FIXME */
+		.symbol_rate_max = 9360000,	/* FIXME */
+		.symbol_rate_tolerance = 4000,
+		.caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+	                FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
+	                FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
+	                FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+	                FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
+	                FE_CAN_HIERARCHY_AUTO,
+	},
+
+	.release = nxt6000_release,
+
+	.init = nxt6000_init,
+
+	.set_frontend = nxt6000_set_frontend,
+
+	.read_status = nxt6000_read_status,
 };
 
-static struct i2c_client client_template = {
-	I2C_DEVNAME("nxt6000"),
-	.flags = I2C_CLIENT_ALLOW_USE,
-	.driver = &driver,
-};
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 
-static __init int nxt6000_init(void)
-{
-	return i2c_add_driver(&driver);
-}
-
-static __exit void nxt6000_exit(void)
-{
-	if (i2c_del_driver(&driver))
-		printk("nxt6000: driver deregistration failed\n");
-}
+MODULE_DESCRIPTION("NxtWave NXT6000 DVB-T demodulator driver");
+MODULE_AUTHOR("Florian Schirmer");
+MODULE_LICENSE("GPL");
 
-module_init(nxt6000_init);
-module_exit(nxt6000_exit);
+EXPORT_SYMBOL(nxt6000_attach);