Nxt6000 based frontend driver

1 files changed, 417 insertions, 0 deletions

diff --git a/linux/drivers/media/dvb/frontends/nxt6000.c b/linux/drivers/media/dvb/frontends/nxt6000.c
new file mode 100644
index 000000000..984f065f7
--- /dev/null
+++ b/linux/drivers/media/dvb/frontends/nxt6000.c
@@ -0,0 +1,417 @@
+/* 
+
+	NxtWave Communications - NXT6000 demodulator driver
+	
+	This driver currently supports:
+	
+	Alps TDME7 (Tuner: MITEL SP5659)
+	Alps TDED4 (Tuner: TI ALP510, external Nxt6000)
+
+    Copyright (C) 2002-2003 Florian Schirmer <schirmer@taytron.net>
+
+    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 2 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, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/    
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <asm/io.h>
+#include <linux/i2c.h>
+
+#include "dvb_frontend.h"
+#include "nxt6000.h"
+
+MODULE_DESCRIPTION("NxtWave NXT6000 DVB demodulator driver");
+MODULE_AUTHOR("Florian Schirmer");
+MODULE_LICENSE("GPL");
+
+static struct dvb_frontend_info nxt6000_info = {
+
+	.name = "NxtWave NXT6000",
+	.type = FE_OFDM,
+	.frequency_min = 48250000,
+	.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_BANDWIDTH_AUTO |
+			FE_CAN_GUARD_INTERVAL_AUTO |
+			FE_CAN_HIERARCHY_AUTO,
+
+};
+
+static int nxt6000_writereg(struct dvb_i2c_bus *i2c, u8 reg, u8 data)
+{
+
+	u8 buf[] = {reg, data};
+	struct i2c_msg msg = {addr: 0x14 >> 1, flags: 0, buf: buf, len: 2};
+	int ret;
+	
+	if ((ret = i2c->xfer(i2c, &msg, 1)) != 1)
+		printk("nxt6000: nxt6000_write error (reg: 0x%02X <- data: 0x%02X)\n", reg, data);
+
+	return (ret != 1) ? -EFAULT : 0;
+	
+}
+
+static u8 nxt6000_readreg(struct dvb_i2c_bus *i2c, u8 reg)
+{
+	int ret;
+
+	u8 b0[] = {reg};
+	u8 b1[] = {0};
+	struct i2c_msg msgs[] = {{addr: 0x14 >> 1, flags: 0, buf: b0, len: 1},
+							{addr: 0x14 >> 1, flags: I2C_M_RD, buf: b1, len: 1}};
+
+	ret = i2c->xfer(i2c, msgs, 2);
+	
+	if (ret != 2)
+		printk("nxt6000: nxt6000_read error (reg: 0x%02X, ret=%d)\n", reg, ret);
+	
+	return b1[0];
+
+}
+
+static int pll_write(struct dvb_i2c_bus *i2c, u8 addr, u8 *buf, u8 len)
+{
+
+	struct i2c_msg msg = {addr: addr >> 1, flags: 0, buf: buf, len: len};
+	int ret;
+				
+	nxt6000_writereg(i2c, ENABLE_TUNER_IIC, 0x01);		/* open i2c bus switch */
+	ret = i2c->xfer(i2c, &msg, 1);
+	nxt6000_writereg(i2c, ENABLE_TUNER_IIC, 0x00);		/* close i2c bus switch */
+										
+	if (ret != 1)
+		printk("nxt6000: pll_write error %d\n", ret);
+																
+	return (ret != 1) ? -EFAULT : 0;
+
+}
+
+#define FREQ2DIV(freq) ((freq + 36166667) / 166667)
+
+static int sp5659_set_tv_freq(struct dvb_i2c_bus *i2c, 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(i2c, 0xC2, buf, 4);
+	
+}
+
+static int alp510_set_tv_freq(struct dvb_i2c_bus *i2c, u32 freq)
+{
+
+	u8 buf[4];
+
+	buf[0] = (FREQ2DIV(freq) >> 8) & 0x7F;
+	buf[1] = FREQ2DIV(freq) & 0xFF;
+	buf[2] = 0x85;
+	
+	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;
+
+	// Enable 8K SAW BW mode
+	buf[3] |= (1 << 2);
+
+	return pll_write(i2c, 0xC0, buf, 4);
+	
+}
+
+#if 0
+static int SetInversion(struct dvb_i2c_bus *i2c, int inversion)
+{
+	u8 val;
+	
+	if (inversion == stv->inv) 
+		return 0;
+	stv->inv=inversion;
+	switch (inversion) {
+	case INVERSION_AUTO: // Hmm, return EINVAL or leave it like this?
+	default:
+	case INVERSION_OFF:
+		val=0x01;
+		break;
+	case INVERSION_ON:
+		val=0x00;
+		break;
+	}
+	writereg(client, 0x0c, 
+		 (readreg(client, 0x0c)&0xfe)|val);
+	return 0;
+}
+#endif
+
+static void nxt6000_reset(struct dvb_i2c_bus *i2c)
+{
+
+	nxt6000_writereg(i2c, RS_COR_SYNC_PARAM, SYNC_PARAM);
+	nxt6000_writereg(i2c, BER_CTRL, /*(1 << 2) |*/ (1 << 1) | 1);
+	nxt6000_writereg(i2c, VIT_COR_CTL, (1 << 7) | (1 << 1));
+//	VIT_BER_TIMER_?
+	nxt6000_writereg(i2c, OFDM_COR_CTL, (1 << 5) | (nxt6000_readreg(i2c, OFDM_COR_CTL) & 0x0F));
+	// Auto mode with MODE8K & 1/8 guard as default
+	nxt6000_writereg(i2c, OFDM_COR_MODEGUARD, (1 << 2) | 2);
+//	OFDM_AGC_CTL tune zap time
+	nxt6000_writereg(i2c, OFDM_ITB_FREQ_1, 0x06);
+	nxt6000_writereg(i2c, OFDM_ITB_FREQ_2, 0x31);
+//	CAS_FREQ
+	nxt6000_writereg(i2c, OFDM_SYR_CTL, 1 << 2);
+	nxt6000_writereg(i2c, OFDM_PPM_CTL_1, PPM256);
+	nxt6000_writereg(i2c, OFDM_TRL_NOMINALRATE_1, 0x49);
+	nxt6000_writereg(i2c, OFDM_TRL_NOMINALRATE_2, 0x72);
+	nxt6000_writereg(i2c, ANALOG_CONTROL_0, 1 << 5);
+	nxt6000_writereg(i2c, EN_DMD_RACQ, (1 << 7) | (3 << 4) | 2);
+	nxt6000_writereg(i2c, DIAG_CONFIG, TB_SET);
+	nxt6000_writereg(i2c, SUB_DIAG_MODE_SEL, 0);
+	nxt6000_writereg(i2c, SUB_DIAG_MODE_SEL, CLKINVERSION);
+	nxt6000_writereg(i2c, TS_FORMAT, 0);
+//	nxt6000_writereg(i2c, TS_FORMAT, GATED_CLOCK);
+
+}
+
+#if 1
+static void nxt6000_dump_status(struct dvb_i2c_bus *i2c)
+{
+
+	printk("RS_COR_STAT: 0x%02X\n", nxt6000_readreg(i2c, RS_COR_STAT));
+	printk("VIT_SYNC_STATUS: 0x%02X\n", nxt6000_readreg(i2c, VIT_SYNC_STATUS));
+	printk("OFDM_COR_STAT: 0x%02X\n", nxt6000_readreg(i2c, OFDM_COR_STAT));
+	printk("OFDM_SYR_STAT: 0x%02X\n", nxt6000_readreg(i2c, OFDM_SYR_STAT));
+	printk("OFDM_TPS_RCVD_1: 0x%02X\n", nxt6000_readreg(i2c, OFDM_TPS_RCVD_1));
+//	printk("OFDM_TPS_RCVD_2: 0x%02X\n", nxt6000_readreg(i2c, OFDM_TPS_RCVD_2));
+//	printk("OFDM_TPS_RCVD_3: 0x%02X\n", nxt6000_readreg(i2c, OFDM_TPS_RCVD_3));
+//	printk("OFDM_TPS_RCVD_4: 0x%02X\n", nxt6000_readreg(i2c, OFDM_TPS_RCVD_4));
+//	printk("OFDM_TPS_RESERVED_1: 0x%02X\n", nxt6000_readreg(i2c, OFDM_TPS_RESERVED_1));
+//	printk("OFDM_TPS_RESERVED_2: 0x%02X\n", nxt6000_readreg(i2c, OFDM_TPS_RESERVED_2));
+//	printk("RF_AGC_STATUS: 0x%02X\n", nxt6000_readreg(i2c, RF_AGC_STATUS));
+
+}
+#endif
+
+static int nxt6000_ioctl(struct dvb_frontend *fe, unsigned int cmd, void *arg)
+{
+
+	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;
+#if 0
+			u8 core_status;
+			nxt6000_dump_status(fe->i2c);
+
+			*status = 0;
+			
+			core_status = nxt6000_readreg(fe->i2c, OFDM_COR_STAT);
+
+			if (core_status & AGCLOCKED)
+				*status |= FE_HAS_SIGNAL;
+
+			if (nxt6000_readreg(fe->i2c, OFDM_SYR_STAT) & GI14_SYR_LOCK)
+				*status |= FE_HAS_CARRIER;
+
+			if (nxt6000_readreg(fe->i2c, VIT_SYNC_STATUS) & VITINSYNC)
+				*status |= FE_HAS_VITERBI;
+
+			if (nxt6000_readreg(fe->i2c, RS_COR_STAT) & RSCORESTATUS)
+				*status |= FE_HAS_SYNC;
+				
+			if (core_status & TPSLOCKED)
+				*status |= FE_HAS_LOCK;
+#endif
+			*status = FE_HAS_LOCK;
+
+			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;
+
+			return 0;
+			
+		}
+	
+		case FE_READ_SNR:
+		{
+//			s16 *snr = (s16 *)arg;
+
+//		*snr=readreg(client, 0x24)<<8;
+//		*snr|=readreg(client, 0x25);
+
+			break;
+		}
+	
+		case FE_READ_UNCORRECTED_BLOCKS: 
+		{
+			u32 *ublocks = (u32 *)arg;
+
+			*ublocks = 0;
+
+			break;
+		}
+	
+		case FE_INIT:
+		case FE_RESET:
+
+			nxt6000_reset(fe->i2c);
+		
+			break;
+
+		case FE_SET_FRONTEND:
+		{
+			struct dvb_frontend_parameters *param = (struct dvb_frontend_parameters *)arg;
+
+			//SetInversion(client, param->Inversion);
+			//SetFEC(client, param->u.qpsk.FEC_inner);
+			//SetSymbolrate(client, param->u.qpsk.SymbolRate);
+			alp510_set_tv_freq(fe->i2c, param->frequency);
+		
+			break;
+		}
+
+		default:
+
+			return -EOPNOTSUPP;
+
+	}
+
+	return 0;
+	
+} 
+
+static int nxt6000_attach(struct dvb_i2c_bus *i2c)
+{
+
+	u8 core_rev;
+
+	printk("nxt6000: attach\n");
+	
+	if ((core_rev = nxt6000_readreg(i2c, OFDM_MSC_REV)) != NXT6000ASICDEVICE) {
+
+		printk("nxt6000: core revision is wrong (0x%02X != 0x0B)\n", core_rev);
+
+		return -ENODEV;
+		
+	}
+	
+	if (pll_write(i2c, 0xC0, NULL, 0) == 0) {
+	
+		printk("nxt6000: detected TI ALP510 tuner\n");
+		
+	} else if (pll_write(i2c, 0xC2, NULL, 0) == 0) {
+	
+		printk("nxt6000: detected MITEL SP5659 tuner\n");
+		
+	} else {
+
+		printk("nxt6000: unable to detect tuner\n");
+	
+		return -EINVAL;
+		
+	}
+	  
+	printk("nxt6000: attached at %d:%d\n", i2c->adapter->num, i2c->id);
+	
+	nxt6000_reset(i2c);
+	alp510_set_tv_freq(i2c, 658000000);
+	nxt6000_dump_status(i2c);
+
+	return dvb_register_frontend(nxt6000_ioctl, i2c, NULL, &nxt6000_info);
+	
+}
+
+static void nxt6000_detach(struct dvb_i2c_bus *i2c)
+{
+
+	printk("nxt6000: detach\n");
+
+	dvb_unregister_frontend(nxt6000_ioctl, i2c);
+	
+}
+
+static __init int nxt6000_init(void)
+{
+
+	printk("nxt6000: init\n");
+	
+	return dvb_register_i2c_device(THIS_MODULE, nxt6000_attach, nxt6000_detach);
+	
+}
+
+static __exit void nxt6000_exit(void)
+{
+
+	printk("nxt6000: cleanup\n");
+
+	dvb_unregister_i2c_device(nxt6000_attach);
+
+}
+
+module_init(nxt6000_init);
+module_exit(nxt6000_exit);