[deliverable/linux.git] / drivers / media / common / tuners / mt20xx.c

/*
 * i2c tv tuner chip device driver
 * controls microtune tuners, mt2032 + mt2050 at the moment.
 *
 * This "mt20xx" module was split apart from the original "tuner" module.
 */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/videodev.h>
#include "tuner-i2c.h"
#include "mt20xx.h"

static int debug;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable verbose debug messages");

/* ---------------------------------------------------------------------- */

static unsigned int optimize_vco  = 1;
module_param(optimize_vco,      int, 0644);

static unsigned int tv_antenna    = 1;
module_param(tv_antenna,        int, 0644);

static unsigned int radio_antenna;
module_param(radio_antenna,     int, 0644);

/* ---------------------------------------------------------------------- */

#define MT2032 0x04
#define MT2030 0x06
#define MT2040 0x07
#define MT2050 0x42

static char *microtune_part[] = {
	[ MT2030 ] = "MT2030",
	[ MT2032 ] = "MT2032",
	[ MT2040 ] = "MT2040",
	[ MT2050 ] = "MT2050",
};

struct microtune_priv {
	struct tuner_i2c_props i2c_props;

	unsigned int xogc;
	//unsigned int radio_if2;

	u32 frequency;
};

static int microtune_release(struct dvb_frontend *fe)
{
	kfree(fe->tuner_priv);
	fe->tuner_priv = NULL;

	return 0;
}

static int microtune_get_frequency(struct dvb_frontend *fe, u32 *frequency)
{
	struct microtune_priv *priv = fe->tuner_priv;
	*frequency = priv->frequency;
	return 0;
}

// IsSpurInBand()?
static int mt2032_spurcheck(struct dvb_frontend *fe,
			    int f1, int f2, int spectrum_from,int spectrum_to)
{
	struct microtune_priv *priv = fe->tuner_priv;
	int n1=1,n2,f;

	f1=f1/1000; //scale to kHz to avoid 32bit overflows
	f2=f2/1000;
	spectrum_from/=1000;
	spectrum_to/=1000;

	tuner_dbg("spurcheck f1=%d f2=%d  from=%d to=%d\n",
		  f1,f2,spectrum_from,spectrum_to);

	do {
	    n2=-n1;
	    f=n1*(f1-f2);
	    do {
		n2--;
		f=f-f2;
		tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);

		if( (f>spectrum_from) && (f<spectrum_to))
			tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
	    } while ( (f>(f2-spectrum_to)) || (n2>-5));
	    n1++;
	} while (n1<5);

	return 1;
}

static int mt2032_compute_freq(struct dvb_frontend *fe,
			       unsigned int rfin,
			       unsigned int if1, unsigned int if2,
			       unsigned int spectrum_from,
			       unsigned int spectrum_to,
			       unsigned char *buf,
			       int *ret_sel,
			       unsigned int xogc) //all in Hz
{
	struct microtune_priv *priv = fe->tuner_priv;
	unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
		desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;

	fref= 5250 *1000; //5.25MHz
	desired_lo1=rfin+if1;

	lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
	lo1n=lo1/8;
	lo1a=lo1-(lo1n*8);

	s=rfin/1000/1000+1090;

	if(optimize_vco) {
		if(s>1890) sel=0;
		else if(s>1720) sel=1;
		else if(s>1530) sel=2;
		else if(s>1370) sel=3;
		else sel=4; // >1090
	}
	else {
		if(s>1790) sel=0; // <1958
		else if(s>1617) sel=1;
		else if(s>1449) sel=2;
		else if(s>1291) sel=3;
		else sel=4; // >1090
	}
	*ret_sel=sel;

	lo1freq=(lo1a+8*lo1n)*fref;

	tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
		  rfin,lo1,lo1n,lo1a,sel,lo1freq);

	desired_lo2=lo1freq-rfin-if2;
	lo2=(desired_lo2)/fref;
	lo2n=lo2/8;
	lo2a=lo2-(lo2n*8);
	lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
	lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;

	tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
		  rfin,lo2,lo2n,lo2a,lo2num,lo2freq);

	if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
		tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
			   lo1a, lo1n, lo2a,lo2n);
		return(-1);
	}

	mt2032_spurcheck(fe, lo1freq, desired_lo2,  spectrum_from, spectrum_to);
	// should recalculate lo1 (one step up/down)

	// set up MT2032 register map for transfer over i2c
	buf[0]=lo1n-1;
	buf[1]=lo1a | (sel<<4);
	buf[2]=0x86; // LOGC
	buf[3]=0x0f; //reserved
	buf[4]=0x1f;
	buf[5]=(lo2n-1) | (lo2a<<5);
	if(rfin >400*1000*1000)
		buf[6]=0xe4;
	else
		buf[6]=0xf4; // set PKEN per rev 1.2
	buf[7]=8+xogc;
	buf[8]=0xc3; //reserved
	buf[9]=0x4e; //reserved
	buf[10]=0xec; //reserved
	buf[11]=(lo2num&0xff);
	buf[12]=(lo2num>>8) |0x80; // Lo2RST

	return 0;
}

static int mt2032_check_lo_lock(struct dvb_frontend *fe)
{
	struct microtune_priv *priv = fe->tuner_priv;
	int try,lock=0;
	unsigned char buf[2];

	for(try=0;try<10;try++) {
		buf[0]=0x0e;
		tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
		tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
		tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
		lock=buf[0] &0x06;

		if (lock==6)
			break;

		tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
		udelay(1000);
	}
	return lock;
}

static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock)
{
	struct microtune_priv *priv = fe->tuner_priv;
	unsigned char buf[2];
	int tad1;

	buf[0]=0x0f;
	tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
	tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
	tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
	tad1=buf[0]&0x07;

	if(tad1 ==0) return lock;
	if(tad1 ==1) return lock;

	if(tad1==2) {
		if(sel==0)
			return lock;
		else sel--;
	}
	else {
		if(sel<4)
			sel++;
		else
			return lock;
	}

	tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);

	buf[0]=0x0f;
	buf[1]=sel;
	tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
	lock=mt2032_check_lo_lock(fe);
	return lock;
}


static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin,
			       unsigned int if1, unsigned int if2,
			       unsigned int from, unsigned int to)
{
	unsigned char buf[21];
	int lint_try,ret,sel,lock=0;
	struct microtune_priv *priv = fe->tuner_priv;

	tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
		  rfin,if1,if2,from,to);

	buf[0]=0;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
	tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);

	buf[0]=0;
	ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc);
	if (ret<0)
		return;

	// send only the relevant registers per Rev. 1.2
	buf[0]=0;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4);
	buf[5]=5;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4);
	buf[11]=11;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3);
	if(ret!=3)
		tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);

	// wait for PLLs to lock (per manual), retry LINT if not.
	for(lint_try=0; lint_try<2; lint_try++) {
		lock=mt2032_check_lo_lock(fe);

		if(optimize_vco)
			lock=mt2032_optimize_vco(fe,sel,lock);
		if(lock==6) break;

		tuner_dbg("mt2032: re-init PLLs by LINT\n");
		buf[0]=7;
		buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs
		tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
		mdelay(10);
		buf[1]=8+priv->xogc;
		tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
	}

	if (lock!=6)
		tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");

	buf[0]=2;
	buf[1]=0x20; // LOGC for optimal phase noise
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
	if (ret!=2)
		tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
}


static int mt2032_set_tv_freq(struct dvb_frontend *fe,
			      struct analog_parameters *params)
{
	int if2,from,to;

	// signal bandwidth and picture carrier
	if (params->std & V4L2_STD_525_60) {
		// NTSC
		from = 40750*1000;
		to   = 46750*1000;
		if2  = 45750*1000;
	} else {
		// PAL
		from = 32900*1000;
		to   = 39900*1000;
		if2  = 38900*1000;
	}

	mt2032_set_if_freq(fe, params->frequency*62500,
			   1090*1000*1000, if2, from, to);

	return 0;
}

static int mt2032_set_radio_freq(struct dvb_frontend *fe,
				 struct analog_parameters *params)
{
	struct microtune_priv *priv = fe->tuner_priv;
	int if2;

	if (params->std & V4L2_STD_525_60) {
		tuner_dbg("pinnacle ntsc\n");
		if2 = 41300 * 1000;
	} else {
		tuner_dbg("pinnacle pal\n");
		if2 = 33300 * 1000;
	}

	// per Manual for FM tuning: first if center freq. 1085 MHz
	mt2032_set_if_freq(fe, params->frequency * 125 / 2,
			   1085*1000*1000,if2,if2,if2);

	return 0;
}

static int mt2032_set_params(struct dvb_frontend *fe,
			     struct analog_parameters *params)
{
	struct microtune_priv *priv = fe->tuner_priv;
	int ret = -EINVAL;

	switch (params->mode) {
	case V4L2_TUNER_RADIO:
		ret = mt2032_set_radio_freq(fe, params);
		priv->frequency = params->frequency * 125 / 2;
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		ret = mt2032_set_tv_freq(fe, params);
		priv->frequency = params->frequency * 62500;
		break;
	}

	return ret;
}

static struct dvb_tuner_ops mt2032_tuner_ops = {
	.set_analog_params = mt2032_set_params,
	.release           = microtune_release,
	.get_frequency     = microtune_get_frequency,
};

// Initialization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
static int mt2032_init(struct dvb_frontend *fe)
{
	struct microtune_priv *priv = fe->tuner_priv;
	unsigned char buf[21];
	int ret,xogc,xok=0;

	// Initialize Registers per spec.
	buf[1]=2; // Index to register 2
	buf[2]=0xff;
	buf[3]=0x0f;
	buf[4]=0x1f;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4);

	buf[5]=6; // Index register 6
	buf[6]=0xe4;
	buf[7]=0x8f;
	buf[8]=0xc3;
	buf[9]=0x4e;
	buf[10]=0xec;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6);

	buf[12]=13;  // Index register 13
	buf[13]=0x32;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2);

	// Adjust XOGC (register 7), wait for XOK
	xogc=7;
	do {
		tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
		mdelay(10);
		buf[0]=0x0e;
		tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
		tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
		xok=buf[0]&0x01;
		tuner_dbg("mt2032: xok = 0x%02x\n",xok);
		if (xok == 1) break;

		xogc--;
		tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
		if (xogc == 3) {
			xogc=4; // min. 4 per spec
			break;
		}
		buf[0]=0x07;
		buf[1]=0x88 + xogc;
		ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
		if (ret!=2)
			tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
	} while (xok != 1 );
	priv->xogc=xogc;

	memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops));

	return(1);
}

static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna)
{
	struct microtune_priv *priv = fe->tuner_priv;
	unsigned char buf[2];
	int ret;

	buf[0] = 6;
	buf[1] = antenna ? 0x11 : 0x10;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
	tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
}

static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2)
{
	struct microtune_priv *priv = fe->tuner_priv;
	unsigned int if1=1218*1000*1000;
	unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
	int ret;
	unsigned char buf[6];

	tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
		  freq,if1,if2);

	f_lo1=freq+if1;
	f_lo1=(f_lo1/1000000)*1000000;

	f_lo2=f_lo1-freq-if2;
	f_lo2=(f_lo2/50000)*50000;

	lo1=f_lo1/4000000;
	lo2=f_lo2/4000000;

	f_lo1_modulo= f_lo1-(lo1*4000000);
	f_lo2_modulo= f_lo2-(lo2*4000000);

	num1=4*f_lo1_modulo/4000000;
	num2=4096*(f_lo2_modulo/1000)/4000;

	// todo spurchecks

	div1a=(lo1/12)-1;
	div1b=lo1-(div1a+1)*12;

	div2a=(lo2/8)-1;
	div2b=lo2-(div2a+1)*8;

	if (debug > 1) {
		tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
		tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
			  num1,num2,div1a,div1b,div2a,div2b);
	}

	buf[0]=1;
	buf[1]= 4*div1b + num1;
	if(freq<275*1000*1000) buf[1] = buf[1]|0x80;

	buf[2]=div1a;
	buf[3]=32*div2b + num2/256;
	buf[4]=num2-(num2/256)*256;
	buf[5]=div2a;
	if(num2!=0) buf[5]=buf[5]|0x40;

	if (debug > 1) {
		int i;
		tuner_dbg("bufs is: ");
		for(i=0;i<6;i++)
			printk("%x ",buf[i]);
		printk("\n");
	}

	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6);
	if (ret!=6)
		tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
}

static int mt2050_set_tv_freq(struct dvb_frontend *fe,
			      struct analog_parameters *params)
{
	unsigned int if2;

	if (params->std & V4L2_STD_525_60) {
		// NTSC
		if2 = 45750*1000;
	} else {
		// PAL
		if2 = 38900*1000;
	}
	if (V4L2_TUNER_DIGITAL_TV == params->mode) {
		// DVB (pinnacle 300i)
		if2 = 36150*1000;
	}
	mt2050_set_if_freq(fe, params->frequency*62500, if2);
	mt2050_set_antenna(fe, tv_antenna);

	return 0;
}

static int mt2050_set_radio_freq(struct dvb_frontend *fe,
				 struct analog_parameters *params)
{
	struct microtune_priv *priv = fe->tuner_priv;
	int if2;

	if (params->std & V4L2_STD_525_60) {
		tuner_dbg("pinnacle ntsc\n");
		if2 = 41300 * 1000;
	} else {
		tuner_dbg("pinnacle pal\n");
		if2 = 33300 * 1000;
	}

	mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2);
	mt2050_set_antenna(fe, radio_antenna);

	return 0;
}

static int mt2050_set_params(struct dvb_frontend *fe,
			     struct analog_parameters *params)
{
	struct microtune_priv *priv = fe->tuner_priv;
	int ret = -EINVAL;

	switch (params->mode) {
	case V4L2_TUNER_RADIO:
		ret = mt2050_set_radio_freq(fe, params);
		priv->frequency = params->frequency * 125 / 2;
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		ret = mt2050_set_tv_freq(fe, params);
		priv->frequency = params->frequency * 62500;
		break;
	}

	return ret;
}

static struct dvb_tuner_ops mt2050_tuner_ops = {
	.set_analog_params = mt2050_set_params,
	.release           = microtune_release,
	.get_frequency     = microtune_get_frequency,
};

static int mt2050_init(struct dvb_frontend *fe)
{
	struct microtune_priv *priv = fe->tuner_priv;
	unsigned char buf[2];
	int ret;

	buf[0]=6;
	buf[1]=0x10;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); //  power

	buf[0]=0x0f;
	buf[1]=0x0f;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo

	buf[0]=0x0d;
	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
	tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);

	tuner_dbg("mt2050: sro is %x\n",buf[0]);

	memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops));

	return 0;
}

struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
				      struct i2c_adapter* i2c_adap,
				      u8 i2c_addr)
{
	struct microtune_priv *priv = NULL;
	char *name;
	unsigned char buf[21];
	int company_code;

	priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL);
	if (priv == NULL)
		return NULL;
	fe->tuner_priv = priv;

	priv->i2c_props.addr = i2c_addr;
	priv->i2c_props.adap = i2c_adap;
	priv->i2c_props.name = "mt20xx";

	//priv->radio_if2 = 10700 * 1000;	/* 10.7MHz - FM radio */

	memset(buf,0,sizeof(buf));

	name = "unknown";

	tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
	tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
	if (debug) {
		int i;
		tuner_dbg("MT20xx hexdump:");
		for(i=0;i<21;i++) {
			printk(" %02x",buf[i]);
			if(((i+1)%8)==0) printk(" ");
		}
		printk("\n");
	}
	company_code = buf[0x11] << 8 | buf[0x12];
	tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
		   company_code,buf[0x13],buf[0x14]);


	if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
	    NULL != microtune_part[buf[0x13]])
		name = microtune_part[buf[0x13]];
	switch (buf[0x13]) {
	case MT2032:
		mt2032_init(fe);
		break;
	case MT2050:
		mt2050_init(fe);
		break;
	default:
		tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
			   name);
		return NULL;
	}

	strlcpy(fe->ops.tuner_ops.info.name, name,
		sizeof(fe->ops.tuner_ops.info.name));
	tuner_info("microtune %s found, OK\n",name);
	return fe;
}

EXPORT_SYMBOL_GPL(microtune_attach);

MODULE_DESCRIPTION("Microtune tuner driver");
MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
MODULE_LICENSE("GPL");

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* i2c tv tuner chip device driver
1da177e4 LT	3	* controls microtune tuners, mt2032 + mt2050 at the moment.
96c0b7cf MK	4	*
96c0b7cf MK	5	* This "mt20xx" module was split apart from the original "tuner" module.
1da177e4 LT	6	*/
	7	#include <linux/delay.h>
	8	#include <linux/i2c.h>
ffbb807c	9	#include <linux/videodev.h>
96c0b7cf MK	10	#include "tuner-i2c.h"
	11	#include "mt20xx.h"
	12
ff699e6b	13	static int debug;
96c0b7cf MK	14	module_param(debug, int, 0644);
	15	MODULE_PARM_DESC(debug, "enable verbose debug messages");
	16
1da177e4 LT	17	/* ---------------------------------------------------------------------- */
	18
	19	static unsigned int optimize_vco = 1;
	20	module_param(optimize_vco, int, 0644);
	21
	22	static unsigned int tv_antenna = 1;
	23	module_param(tv_antenna, int, 0644);
	24
ff699e6b	25	static unsigned int radio_antenna;
1da177e4 LT	26	module_param(radio_antenna, int, 0644);
	27
	28	/* ---------------------------------------------------------------------- */
	29
	30	#define MT2032 0x04
	31	#define MT2030 0x06
	32	#define MT2040 0x07
	33	#define MT2050 0x42
	34
	35	static char *microtune_part[] = {
	36	[ MT2030 ] = "MT2030",
	37	[ MT2032 ] = "MT2032",
	38	[ MT2040 ] = "MT2040",
	39	[ MT2050 ] = "MT2050",
	40	};
	41
b2083199	42	struct microtune_priv {
db8a6956 MK	43	struct tuner_i2c_props i2c_props;
db8a6956 MK	44
b2083199	45	unsigned int xogc;
96c0b7cf MK	46	//unsigned int radio_if2;
	47
	48	u32 frequency;
b2083199 MK	49	};
b2083199 MK	50
96c0b7cf MK	51	static int microtune_release(struct dvb_frontend *fe)
	52	{
	53	kfree(fe->tuner_priv);
	54	fe->tuner_priv = NULL;
	55
	56	return 0;
	57	}
	58
	59	static int microtune_get_frequency(struct dvb_frontend fe, u32 frequency)
c22bcb07	60	{
96c0b7cf MK	61	struct microtune_priv *priv = fe->tuner_priv;
	62	*frequency = priv->frequency;
	63	return 0;
c22bcb07 MK	64	}
c22bcb07 MK	65
1da177e4	66	// IsSpurInBand()?
96c0b7cf	67	static int mt2032_spurcheck(struct dvb_frontend *fe,
1da177e4 LT	68	int f1, int f2, int spectrum_from,int spectrum_to)
1da177e4 LT	69	{
96c0b7cf	70	struct microtune_priv *priv = fe->tuner_priv;
1da177e4 LT	71	int n1=1,n2,f;
	72
	73	f1=f1/1000; //scale to kHz to avoid 32bit overflows
	74	f2=f2/1000;
	75	spectrum_from/=1000;
	76	spectrum_to/=1000;
	77
	78	tuner_dbg("spurcheck f1=%d f2=%d from=%d to=%d\n",
	79	f1,f2,spectrum_from,spectrum_to);
	80
	81	do {
	82	n2=-n1;
	83	f=n1*(f1-f2);
	84	do {
	85	n2--;
	86	f=f-f2;
	87	tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);
	88
	89	if( (f>spectrum_from) && (f<spectrum_to))
	90	tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
	91	} while ( (f>(f2-spectrum_to)) \|\| (n2>-5));
	92	n1++;
	93	} while (n1<5);
	94
	95	return 1;
	96	}
	97
96c0b7cf	98	static int mt2032_compute_freq(struct dvb_frontend *fe,
1da177e4 LT	99	unsigned int rfin,
	100	unsigned int if1, unsigned int if2,
	101	unsigned int spectrum_from,
	102	unsigned int spectrum_to,
	103	unsigned char *buf,
	104	int *ret_sel,
	105	unsigned int xogc) //all in Hz
	106	{
96c0b7cf	107	struct microtune_priv *priv = fe->tuner_priv;
4ac97914	108	unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
1da177e4 LT	109	desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;
1da177e4 LT	110
4ac97914	111	fref= 5250 *1000; //5.25MHz
1da177e4 LT	112	desired_lo1=rfin+if1;
	113
	114	lo1=(2(desired_lo1/1000)+(fref/1000)) / (2fref/1000);
4ac97914 MCC	115	lo1n=lo1/8;
4ac97914 MCC	116	lo1a=lo1-(lo1n*8);
1da177e4	117
4ac97914	118	s=rfin/1000/1000+1090;
1da177e4 LT	119
	120	if(optimize_vco) {
	121	if(s>1890) sel=0;
	122	else if(s>1720) sel=1;
	123	else if(s>1530) sel=2;
	124	else if(s>1370) sel=3;
	125	else sel=4; // >1090
	126	}
	127	else {
4ac97914 MCC	128	if(s>1790) sel=0; // <1958
	129	else if(s>1617) sel=1;
	130	else if(s>1449) sel=2;
	131	else if(s>1291) sel=3;
	132	else sel=4; // >1090
1da177e4 LT	133	}
	134	*ret_sel=sel;
	135
4ac97914	136	lo1freq=(lo1a+8lo1n)fref;
1da177e4 LT	137
	138	tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
	139	rfin,lo1,lo1n,lo1a,sel,lo1freq);
	140
4ac97914 MCC	141	desired_lo2=lo1freq-rfin-if2;
	142	lo2=(desired_lo2)/fref;
	143	lo2n=lo2/8;
	144	lo2a=lo2-(lo2n*8);
	145	lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
	146	lo2freq=(lo2a+8lo2n)fref + lo2num(fref/1000)/37801000;
1da177e4 LT	147
	148	tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
	149	rfin,lo2,lo2n,lo2a,lo2num,lo2freq);
	150
4ac97914	151	if(lo1a<0 \|\| lo1a>7 \|\| lo1n<17 \|\|lo1n>48 \|\| lo2a<0 \|\|lo2a >7 \|\|lo2n<17 \|\| lo2n>30) {
1da177e4 LT	152	tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
1da177e4 LT	153	lo1a, lo1n, lo2a,lo2n);
4ac97914 MCC	154	return(-1);
4ac97914 MCC	155	}
1da177e4	156
96c0b7cf	157	mt2032_spurcheck(fe, lo1freq, desired_lo2, spectrum_from, spectrum_to);
1da177e4 LT	158	// should recalculate lo1 (one step up/down)
	159
	160	// set up MT2032 register map for transfer over i2c
	161	buf[0]=lo1n-1;
	162	buf[1]=lo1a \| (sel<<4);
	163	buf[2]=0x86; // LOGC
	164	buf[3]=0x0f; //reserved
	165	buf[4]=0x1f;
	166	buf[5]=(lo2n-1) \| (lo2a<<5);
4ac97914 MCC	167	if(rfin >40010001000)
	168	buf[6]=0xe4;
	169	else
	170	buf[6]=0xf4; // set PKEN per rev 1.2
1da177e4 LT	171	buf[7]=8+xogc;
	172	buf[8]=0xc3; //reserved
	173	buf[9]=0x4e; //reserved
	174	buf[10]=0xec; //reserved
	175	buf[11]=(lo2num&0xff);
	176	buf[12]=(lo2num>>8) \|0x80; // Lo2RST
	177
	178	return 0;
	179	}
	180
96c0b7cf	181	static int mt2032_check_lo_lock(struct dvb_frontend *fe)
1da177e4	182	{
96c0b7cf	183	struct microtune_priv *priv = fe->tuner_priv;
1da177e4 LT	184	int try,lock=0;
	185	unsigned char buf[2];
	186
	187	for(try=0;try<10;try++) {
	188	buf[0]=0x0e;
db8a6956 MK	189	tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
db8a6956 MK	190	tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
1da177e4 LT	191	tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
	192	lock=buf[0] &0x06;
	193
	194	if (lock==6)
	195	break;
	196
	197	tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
	198	udelay(1000);
	199	}
4ac97914	200	return lock;
1da177e4 LT	201	}
1da177e4 LT	202
96c0b7cf	203	static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock)
1da177e4	204	{
96c0b7cf	205	struct microtune_priv *priv = fe->tuner_priv;
1da177e4 LT	206	unsigned char buf[2];
	207	int tad1;
	208
	209	buf[0]=0x0f;
db8a6956 MK	210	tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
db8a6956 MK	211	tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
1da177e4 LT	212	tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
	213	tad1=buf[0]&0x07;
	214
	215	if(tad1 ==0) return lock;
	216	if(tad1 ==1) return lock;
	217
	218	if(tad1==2) {
	219	if(sel==0)
	220	return lock;
	221	else sel--;
	222	}
	223	else {
	224	if(sel<4)
	225	sel++;
	226	else
	227	return lock;
	228	}
	229
	230	tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);
	231
	232	buf[0]=0x0f;
	233	buf[1]=sel;
db8a6956	234	tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
96c0b7cf	235	lock=mt2032_check_lo_lock(fe);
1da177e4 LT	236	return lock;
	237	}
	238
	239
96c0b7cf	240	static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin,
1da177e4 LT	241	unsigned int if1, unsigned int if2,
	242	unsigned int from, unsigned int to)
	243	{
	244	unsigned char buf[21];
	245	int lint_try,ret,sel,lock=0;
96c0b7cf	246	struct microtune_priv *priv = fe->tuner_priv;
1da177e4 LT	247
	248	tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
	249	rfin,if1,if2,from,to);
	250
4ac97914	251	buf[0]=0;
db8a6956 MK	252	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
db8a6956 MK	253	tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
1da177e4 LT	254
1da177e4 LT	255	buf[0]=0;
96c0b7cf	256	ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc);
1da177e4 LT	257	if (ret<0)
	258	return;
	259
4ac97914 MCC	260	// send only the relevant registers per Rev. 1.2
4ac97914 MCC	261	buf[0]=0;
db8a6956	262	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4);
4ac97914	263	buf[5]=5;
db8a6956	264	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4);
4ac97914	265	buf[11]=11;
db8a6956	266	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3);
4ac97914	267	if(ret!=3)
1da177e4 LT	268	tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);
	269
	270	// wait for PLLs to lock (per manual), retry LINT if not.
	271	for(lint_try=0; lint_try<2; lint_try++) {
96c0b7cf	272	lock=mt2032_check_lo_lock(fe);
1da177e4 LT	273
1da177e4 LT	274	if(optimize_vco)
96c0b7cf	275	lock=mt2032_optimize_vco(fe,sel,lock);
1da177e4 LT	276	if(lock==6) break;
	277
	278	tuner_dbg("mt2032: re-init PLLs by LINT\n");
	279	buf[0]=7;
b2083199	280	buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs
db8a6956	281	tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
1da177e4	282	mdelay(10);
b2083199	283	buf[1]=8+priv->xogc;
db8a6956	284	tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
4ac97914	285	}
1da177e4 LT	286
	287	if (lock!=6)
	288	tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");
	289
	290	buf[0]=2;
	291	buf[1]=0x20; // LOGC for optimal phase noise
db8a6956	292	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
1da177e4 LT	293	if (ret!=2)
	294	tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
	295	}
	296
	297
96c0b7cf MK	298	static int mt2032_set_tv_freq(struct dvb_frontend *fe,
96c0b7cf MK	299	struct analog_parameters *params)
1da177e4	300	{
1da177e4 LT	301	int if2,from,to;
	302
	303	// signal bandwidth and picture carrier
96c0b7cf	304	if (params->std & V4L2_STD_525_60) {
1da177e4 LT	305	// NTSC
	306	from = 40750*1000;
	307	to = 46750*1000;
	308	if2 = 45750*1000;
	309	} else {
	310	// PAL
	311	from = 32900*1000;
	312	to = 39900*1000;
	313	if2 = 38900*1000;
	314	}
	315
96c0b7cf	316	mt2032_set_if_freq(fe, params->frequency*62500,
1da177e4	317	109010001000, if2, from, to);
96c0b7cf MK	318
96c0b7cf MK	319	return 0;
1da177e4 LT	320	}
1da177e4 LT	321
96c0b7cf MK	322	static int mt2032_set_radio_freq(struct dvb_frontend *fe,
96c0b7cf MK	323	struct analog_parameters *params)
1da177e4	324	{
96c0b7cf MK	325	struct microtune_priv *priv = fe->tuner_priv;
	326	int if2;
	327
	328	if (params->std & V4L2_STD_525_60) {
	329	tuner_dbg("pinnacle ntsc\n");
	330	if2 = 41300 * 1000;
	331	} else {
	332	tuner_dbg("pinnacle pal\n");
	333	if2 = 33300 * 1000;
	334	}
1da177e4 LT	335
1da177e4 LT	336	// per Manual for FM tuning: first if center freq. 1085 MHz
96c0b7cf MK	337	mt2032_set_if_freq(fe, params->frequency * 125 / 2,
	338	108510001000,if2,if2,if2);
	339
	340	return 0;
1da177e4 LT	341	}
1da177e4 LT	342
96c0b7cf MK	343	static int mt2032_set_params(struct dvb_frontend *fe,
	344	struct analog_parameters *params)
	345	{
	346	struct microtune_priv *priv = fe->tuner_priv;
	347	int ret = -EINVAL;
	348
	349	switch (params->mode) {
	350	case V4L2_TUNER_RADIO:
	351	ret = mt2032_set_radio_freq(fe, params);
	352	priv->frequency = params->frequency * 125 / 2;
	353	break;
	354	case V4L2_TUNER_ANALOG_TV:
	355	case V4L2_TUNER_DIGITAL_TV:
	356	ret = mt2032_set_tv_freq(fe, params);
	357	priv->frequency = params->frequency * 62500;
	358	break;
	359	}
	360
	361	return ret;
	362	}
	363
	364	static struct dvb_tuner_ops mt2032_tuner_ops = {
	365	.set_analog_params = mt2032_set_params,
	366	.release = microtune_release,
	367	.get_frequency = microtune_get_frequency,
c22bcb07 MK	368	};
c22bcb07 MK	369
c84e6036	370	// Initialization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
96c0b7cf	371	static int mt2032_init(struct dvb_frontend *fe)
1da177e4	372	{
96c0b7cf	373	struct microtune_priv *priv = fe->tuner_priv;
4ac97914 MCC	374	unsigned char buf[21];
4ac97914 MCC	375	int ret,xogc,xok=0;
1da177e4 LT	376
1da177e4 LT	377	// Initialize Registers per spec.
4ac97914 MCC	378	buf[1]=2; // Index to register 2
	379	buf[2]=0xff;
	380	buf[3]=0x0f;
	381	buf[4]=0x1f;
db8a6956	382	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4);
4ac97914 MCC	383
	384	buf[5]=6; // Index register 6
	385	buf[6]=0xe4;
	386	buf[7]=0x8f;
	387	buf[8]=0xc3;
	388	buf[9]=0x4e;
	389	buf[10]=0xec;
db8a6956	390	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6);
4ac97914 MCC	391
	392	buf[12]=13; // Index register 13
	393	buf[13]=0x32;
db8a6956	394	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2);
4ac97914 MCC	395
	396	// Adjust XOGC (register 7), wait for XOK
	397	xogc=7;
	398	do {
	399	tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
	400	mdelay(10);
	401	buf[0]=0x0e;
db8a6956 MK	402	tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
db8a6956 MK	403	tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
4ac97914 MCC	404	xok=buf[0]&0x01;
	405	tuner_dbg("mt2032: xok = 0x%02x\n",xok);
	406	if (xok == 1) break;
	407
	408	xogc--;
1da177e4	409	tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
4ac97914 MCC	410	if (xogc == 3) {
	411	xogc=4; // min. 4 per spec
	412	break;
	413	}
	414	buf[0]=0x07;
	415	buf[1]=0x88 + xogc;
db8a6956	416	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
4ac97914	417	if (ret!=2)
1da177e4	418	tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
4ac97914	419	} while (xok != 1 );
b2083199	420	priv->xogc=xogc;
1da177e4	421
96c0b7cf	422	memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops));
c22bcb07	423
4ac97914	424	return(1);
1da177e4 LT	425	}
1da177e4 LT	426
96c0b7cf	427	static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna)
1da177e4	428	{
96c0b7cf	429	struct microtune_priv *priv = fe->tuner_priv;
56584c9e MK	430	unsigned char buf[2];
56584c9e MK	431	int ret;
1da177e4	432
56584c9e MK	433	buf[0] = 6;
56584c9e MK	434	buf[1] = antenna ? 0x11 : 0x10;
db8a6956	435	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
56584c9e	436	tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
1da177e4 LT	437	}
1da177e4 LT	438
96c0b7cf	439	static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2)
1da177e4	440	{
96c0b7cf	441	struct microtune_priv *priv = fe->tuner_priv;
1da177e4 LT	442	unsigned int if1=121810001000;
	443	unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
	444	int ret;
	445	unsigned char buf[6];
	446
	447	tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
	448	freq,if1,if2);
	449
	450	f_lo1=freq+if1;
	451	f_lo1=(f_lo1/1000000)*1000000;
	452
	453	f_lo2=f_lo1-freq-if2;
	454	f_lo2=(f_lo2/50000)*50000;
	455
	456	lo1=f_lo1/4000000;
	457	lo2=f_lo2/4000000;
	458
	459	f_lo1_modulo= f_lo1-(lo1*4000000);
	460	f_lo2_modulo= f_lo2-(lo2*4000000);
	461
	462	num1=4*f_lo1_modulo/4000000;
	463	num2=4096*(f_lo2_modulo/1000)/4000;
	464
	465	// todo spurchecks
	466
	467	div1a=(lo1/12)-1;
	468	div1b=lo1-(div1a+1)*12;
	469
	470	div2a=(lo2/8)-1;
	471	div2b=lo2-(div2a+1)*8;
	472
96c0b7cf	473	if (debug > 1) {
1da177e4 LT	474	tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
	475	tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
	476	num1,num2,div1a,div1b,div2a,div2b);
	477	}
	478
	479	buf[0]=1;
	480	buf[1]= 4*div1b + num1;
	481	if(freq<27510001000) buf[1] = buf[1]\|0x80;
	482
	483	buf[2]=div1a;
	484	buf[3]=32*div2b + num2/256;
	485	buf[4]=num2-(num2/256)*256;
	486	buf[5]=div2a;
	487	if(num2!=0) buf[5]=buf[5]\|0x40;
	488
96c0b7cf	489	if (debug > 1) {
1da177e4 LT	490	int i;
	491	tuner_dbg("bufs is: ");
	492	for(i=0;i<6;i++)
	493	printk("%x ",buf[i]);
	494	printk("\n");
	495	}
	496
db8a6956	497	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6);
4ac97914	498	if (ret!=6)
1da177e4 LT	499	tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
	500	}
	501
96c0b7cf MK	502	static int mt2050_set_tv_freq(struct dvb_frontend *fe,
96c0b7cf MK	503	struct analog_parameters *params)
1da177e4	504	{
1da177e4 LT	505	unsigned int if2;
1da177e4 LT	506
96c0b7cf	507	if (params->std & V4L2_STD_525_60) {
1da177e4	508	// NTSC
4ac97914 MCC	509	if2 = 45750*1000;
	510	} else {
	511	// PAL
	512	if2 = 38900*1000;
	513	}
96c0b7cf	514	if (V4L2_TUNER_DIGITAL_TV == params->mode) {
1da177e4 LT	515	// DVB (pinnacle 300i)
	516	if2 = 36150*1000;
	517	}
96c0b7cf MK	518	mt2050_set_if_freq(fe, params->frequency*62500, if2);
	519	mt2050_set_antenna(fe, tv_antenna);
	520
	521	return 0;
	522	}
	523
	524	static int mt2050_set_radio_freq(struct dvb_frontend *fe,
	525	struct analog_parameters *params)
	526	{
	527	struct microtune_priv *priv = fe->tuner_priv;
	528	int if2;
	529
	530	if (params->std & V4L2_STD_525_60) {
	531	tuner_dbg("pinnacle ntsc\n");
	532	if2 = 41300 * 1000;
	533	} else {
	534	tuner_dbg("pinnacle pal\n");
	535	if2 = 33300 * 1000;
	536	}
	537
	538	mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2);
	539	mt2050_set_antenna(fe, radio_antenna);
	540
	541	return 0;
1da177e4 LT	542	}
1da177e4 LT	543
96c0b7cf MK	544	static int mt2050_set_params(struct dvb_frontend *fe,
96c0b7cf MK	545	struct analog_parameters *params)
1da177e4	546	{
96c0b7cf MK	547	struct microtune_priv *priv = fe->tuner_priv;
96c0b7cf MK	548	int ret = -EINVAL;
1da177e4	549
96c0b7cf MK	550	switch (params->mode) {
	551	case V4L2_TUNER_RADIO:
	552	ret = mt2050_set_radio_freq(fe, params);
	553	priv->frequency = params->frequency * 125 / 2;
	554	break;
	555	case V4L2_TUNER_ANALOG_TV:
	556	case V4L2_TUNER_DIGITAL_TV:
	557	ret = mt2050_set_tv_freq(fe, params);
	558	priv->frequency = params->frequency * 62500;
	559	break;
	560	}
	561
	562	return ret;
1da177e4 LT	563	}
1da177e4 LT	564
96c0b7cf MK	565	static struct dvb_tuner_ops mt2050_tuner_ops = {
	566	.set_analog_params = mt2050_set_params,
	567	.release = microtune_release,
	568	.get_frequency = microtune_get_frequency,
c22bcb07 MK	569	};
c22bcb07 MK	570
96c0b7cf	571	static int mt2050_init(struct dvb_frontend *fe)
1da177e4	572	{
96c0b7cf	573	struct microtune_priv *priv = fe->tuner_priv;
1da177e4 LT	574	unsigned char buf[2];
	575	int ret;
	576
	577	buf[0]=6;
	578	buf[1]=0x10;
db8a6956	579	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // power
1da177e4 LT	580
	581	buf[0]=0x0f;
	582	buf[1]=0x0f;
db8a6956	583	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo
1da177e4 LT	584
1da177e4 LT	585	buf[0]=0x0d;
db8a6956 MK	586	ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
db8a6956 MK	587	tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
1da177e4 LT	588
1da177e4 LT	589	tuner_dbg("mt2050: sro is %x\n",buf[0]);
1da177e4	590
96c0b7cf	591	memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops));
024cf530	592
c22bcb07	593	return 0;
024cf530 MK	594	}
024cf530 MK	595
96c0b7cf MK	596	struct dvb_frontend microtune_attach(struct dvb_frontend fe,
	597	struct i2c_adapter* i2c_adap,
	598	u8 i2c_addr)
1da177e4	599	{
b2083199	600	struct microtune_priv *priv = NULL;
1da177e4	601	char *name;
4ac97914	602	unsigned char buf[21];
1da177e4 LT	603	int company_code;
1da177e4 LT	604
b2083199 MK	605	priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL);
b2083199 MK	606	if (priv == NULL)
96c0b7cf MK	607	return NULL;
96c0b7cf MK	608	fe->tuner_priv = priv;
b2083199	609
96c0b7cf MK	610	priv->i2c_props.addr = i2c_addr;
96c0b7cf MK	611	priv->i2c_props.adap = i2c_adap;
2756665c	612	priv->i2c_props.name = "mt20xx";
db8a6956	613
96c0b7cf	614	//priv->radio_if2 = 10700 * 1000; /* 10.7MHz - FM radio */
b2083199	615
1da177e4	616	memset(buf,0,sizeof(buf));
c22bcb07	617
1da177e4 LT	618	name = "unknown";
1da177e4 LT	619
db8a6956 MK	620	tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
db8a6956 MK	621	tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
96c0b7cf	622	if (debug) {
4ac97914	623	int i;
1da177e4	624	tuner_dbg("MT20xx hexdump:");
4ac97914 MCC	625	for(i=0;i<21;i++) {
	626	printk(" %02x",buf[i]);
	627	if(((i+1)%8)==0) printk(" ");
	628	}
	629	printk("\n");
	630	}
1da177e4 LT	631	company_code = buf[0x11] << 8 \| buf[0x12];
	632	tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
	633	company_code,buf[0x13],buf[0x14]);
	634
1da177e4 LT	635
	636	if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
	637	NULL != microtune_part[buf[0x13]])
	638	name = microtune_part[buf[0x13]];
	639	switch (buf[0x13]) {
	640	case MT2032:
96c0b7cf	641	mt2032_init(fe);
1da177e4 LT	642	break;
1da177e4 LT	643	case MT2050:
96c0b7cf	644	mt2050_init(fe);
1da177e4 LT	645	break;
	646	default:
	647	tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
	648	name);
5fa1247a	649	return NULL;
4ac97914	650	}
1da177e4	651
96c0b7cf MK	652	strlcpy(fe->ops.tuner_ops.info.name, name,
96c0b7cf MK	653	sizeof(fe->ops.tuner_ops.info.name));
1da177e4	654	tuner_info("microtune %s found, OK\n",name);
96c0b7cf	655	return fe;
1da177e4 LT	656	}
1da177e4 LT	657
96c0b7cf MK	658	EXPORT_SYMBOL_GPL(microtune_attach);
	659
	660	MODULE_DESCRIPTION("Microtune tuner driver");
	661	MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
	662	MODULE_LICENSE("GPL");
	663
1da177e4 LT	664	/*
	665	* Overrides for Emacs so that we follow Linus's tabbing style.
	666	* ---------------------------------------------------------------------------
	667	* Local variables:
	668	* c-basic-offset: 8
	669	* End:
	670	*/