Commit 46f73f93 authored by Olivier DANET's avatar Olivier DANET Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB: Update for MT2060 to use dvb_tuner_ops 



new tuner api
minor fixes for tuning

Signed-off-by: default avatarOlivier DANET <odanet@caramail.com>
Signed-off-by: default avatarPatrick Boettcher <pb@linuxtv.org>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@infradead.org>
parent 83fa9079

drivers/media/dvb/dvb-usb/dibusb-common.c

+5 −82
Original line number Diff line number Diff line
@@ -168,40 +168,6 @@ int dibusb_read_eeprom_byte(struct dvb_usb_device *d, u8 offs, u8 *val) 
}

EXPORT_SYMBOL(dibusb_read_eeprom_byte);



static struct mt2060_config stk3000p_mt2060_config = {

	.i2c_address = 0x60,

};



static int dibusb_tuner_init(struct dvb_frontend *fe)

{

	struct dvb_usb_device *d = fe->dvb->priv;

	struct dibusb_state *st = d->priv;



	if (d->tuner_pass_ctrl && st->mt2060_present) {

		int ret;

		d->tuner_pass_ctrl(d->fe, 1, stk3000p_mt2060_config.i2c_address);

		ret = mt2060_init(&st->mt2060);

		d->tuner_pass_ctrl(d->fe, 0, 0);

		return ret;

	}

	return dvb_usb_pll_init_i2c(fe);

}



static int dibusb_tuner_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)

{

	struct dvb_usb_device *d = fe->dvb->priv;

	struct dibusb_state *st = d->priv;



	if (d->tuner_pass_ctrl && st->mt2060_present) {

		int ret;

		d->tuner_pass_ctrl(d->fe, 1, stk3000p_mt2060_config.i2c_address);

		ret = mt2060_set(&st->mt2060,fep);

		d->tuner_pass_ctrl(d->fe,0,0);

		return ret;

	}

	return dvb_usb_pll_set_i2c(fe,fep);

}



static const struct dib3000p_agc_config dib3000p_agc_panasonic_env57h1xd5 = {

	{ 0x51, 0x301d, 0x0, 0x1cc7, 0xdc29, 0x570a,

	0xbae1, 0x8ccd, 0x3b6d, 0x551d, 0xa, 0x951e }
@@ -212,64 +178,21 @@ static const struct dib3000p_agc_config dib3000p_agc_microtune_mt2060 = { 
	0xa8f6, 0x5eb8, 0x65ff, 0x40ff,	0x8a, 0x1114 }

};



static struct mt2060_config stk3000p_mt2060_config = {

	.i2c_address = 0x60,

};



int dibusb_dib3000mc_frontend_attach(struct dvb_usb_device *d)

{

	struct dib3000_config demod_cfg;

	struct dibusb_state *st = d->priv;



	demod_cfg.agc      = &dib3000p_agc_panasonic_env57h1xd5;

	demod_cfg.pll_set  = dibusb_tuner_set;

	demod_cfg.pll_init = dibusb_tuner_init;



	for (demod_cfg.demod_address = 0x8; demod_cfg.demod_address < 0xd; demod_cfg.demod_address++)

		if ((d->fe = dib3000mc_attach(&demod_cfg,&d->i2c_adap,&st->ops)) != NULL) {

			d->tuner_pass_ctrl = st->ops.tuner_pass_ctrl;

			return 0;

		}



	return -ENODEV;

}

EXPORT_SYMBOL(dibusb_dib3000mc_frontend_attach);



int dibusb_dib3000mc_tuner_attach (struct dvb_usb_device *d)

{

	int ret;

	u8 a,b;

	u16 if1 = 1220;



	if (d->tuner_pass_ctrl) {

		struct dibusb_state *st = d->priv;

		d->tuner_pass_ctrl(d->fe, 1, stk3000p_mt2060_config.i2c_address);

		// First IF calibration for Liteon Sticks

		if (d->udev->descriptor.idVendor == USB_VID_LITEON &&

		    d->udev->descriptor.idProduct == USB_PID_LITEON_DVB_T_WARM) {



			dibusb_read_eeprom_byte(d,0x7E,&a);

			dibusb_read_eeprom_byte(d,0x7F,&b);



			if (a == 0xFF && b == 0xFF)

				if1 = 1220;

			else if (a == 0x00)

				if1 = 1220+b;

			else if (a == 0x80)

				if1 = 1220-b;

			else {

				warn("LITE-ON DVB-T Tuner : Strange IF1 calibration :%2X %2X\n",(int)a,(int)b);

				if1 = 1220;

			}

		}

		if ((ret = mt2060_attach(&st->mt2060,&stk3000p_mt2060_config, &d->i2c_adap,if1)) != 0) {

			/* not found - use panasonic pll parameters */

			d->pll_addr = 0x60;

			d->pll_desc = &dvb_pll_env57h1xd5;

		} else {

			st->mt2060_present = 1;

			/* set the correct agc parameters for the dib3000p */

			dib3000mc_set_agc_config(d->fe, &dib3000p_agc_microtune_mt2060);

		}

		d->tuner_pass_ctrl(d->fe,0,0);

	}

	return 0;

	return -ENODEV;

}

EXPORT_SYMBOL(dibusb_dib3000mc_tuner_attach);

drivers/media/dvb/dvb-usb/dibusb.h

+0 −1
Original line number Diff line number Diff line
@@ -97,7 +97,6 @@ 


struct dibusb_state {

	struct dib_fe_xfer_ops ops;

	struct mt2060_state mt2060;

	int mt2060_present;



	/* for RC5 remote control */

drivers/media/dvb/frontends/mt2060.c

+122 −68
Original line number Diff line number Diff line
@@ -19,14 +19,16 @@ 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.=

 */



/* See mt2060_priv.h for details */



/* In that file, frequencies are expressed in kiloHertz to avoid 32 bits overflows */



#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/delay.h>

#include <linux/dvb/frontend.h>

#include <linux/i2c.h>



#include "dvb_frontend.h"



#include "mt2060.h"

#include "mt2060_priv.h"
@@ -37,14 +39,14 @@ MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 
#define dprintk(args...) do { if (debug) {printk(KERN_DEBUG "MT2060: " args); printk("\n"); }} while (0)



// Reads a single register

static int mt2060_readreg(struct mt2060_state *state, u8 reg, u8 *val)

static int mt2060_readreg(struct mt2060_priv *priv, u8 reg, u8 *val)

{

	struct i2c_msg msg[2] = {

		{ .addr = state->config->i2c_address, .flags = 0,        .buf = &reg, .len = 1 },

		{ .addr = state->config->i2c_address, .flags = I2C_M_RD, .buf = val,  .len = 1 },

		{ .addr = priv->cfg->i2c_address, .flags = 0,        .buf = &reg, .len = 1 },

		{ .addr = priv->cfg->i2c_address, .flags = I2C_M_RD, .buf = val,  .len = 1 },

	};



	if (i2c_transfer(state->i2c, msg, 2) != 2) {

	if (i2c_transfer(priv->i2c, msg, 2) != 2) {

		printk(KERN_WARNING "mt2060 I2C read failed\n");

		return -EREMOTEIO;

	}
@@ -52,16 +54,14 @@ static int mt2060_readreg(struct mt2060_state *state, u8 reg, u8 *val) 
}



// Writes a single register

static int mt2060_writereg(struct mt2060_state *state, u8 reg, u8 val)

static int mt2060_writereg(struct mt2060_priv *priv, u8 reg, u8 val)

{

	u8 buf[2];

	u8 buf[2] = { reg, val };

	struct i2c_msg msg = {

		.addr = state->config->i2c_address, .flags = 0, .buf = buf, .len = 2

		.addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = 2

	};

	buf[0]=reg;

	buf[1]=val;



	if (i2c_transfer(state->i2c, &msg, 1) != 1) {

	if (i2c_transfer(priv->i2c, &msg, 1) != 1) {

		printk(KERN_WARNING "mt2060 I2C write failed\n");

		return -EREMOTEIO;

	}
@@ -69,12 +69,12 @@ static int mt2060_writereg(struct mt2060_state *state, u8 reg, u8 val) 
}



// Writes a set of consecutive registers

static int mt2060_writeregs(struct mt2060_state *state,u8 *buf, u8 len)

static int mt2060_writeregs(struct mt2060_priv *priv,u8 *buf, u8 len)

{

	struct i2c_msg msg = {

		.addr = state->config->i2c_address, .flags = 0, .buf = buf, .len = len

		.addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = len

	};

	if (i2c_transfer(state->i2c, &msg, 1) != 1) {

	if (i2c_transfer(priv->i2c, &msg, 1) != 1) {

		printk(KERN_WARNING "mt2060 I2C write failed (len=%i)\n",(int)len);

		return -EREMOTEIO;

	}
@@ -95,20 +95,6 @@ static u8 mt2060_config2[] = { 
};



//  VGAG=3, V1CSE=1

static u8 mt2060_config3[] = {

	REG_VGAG,

	0x33

};



int mt2060_init(struct mt2060_state *state)

{

	if (mt2060_writeregs(state,mt2060_config1,sizeof(mt2060_config1)))

		return -EREMOTEIO;

	if (mt2060_writeregs(state,mt2060_config3,sizeof(mt2060_config3)))

		return -EREMOTEIO;

	return 0;

}

EXPORT_SYMBOL(mt2060_init);



#ifdef  MT2060_SPURCHECK

/* The function below calculates the frequency offset between the output frequency if2
@@ -167,8 +153,9 @@ static int mt2060_spurcheck(u32 lo1,u32 lo2,u32 if2) 
#define IF2  36150       // IF2 frequency = 36.150 MHz

#define FREF 16000       // Quartz oscillator 16 MHz



int mt2060_set(struct mt2060_state *state, struct dvb_frontend_parameters *fep)

static int mt2060_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)

{

	struct mt2060_priv *priv;

	int ret=0;

	int i=0;

	u32 freq;
@@ -178,17 +165,23 @@ int mt2060_set(struct mt2060_state *state, struct dvb_frontend_parameters *fep) 
	u8  b[8];

	u32 if1;



	if1 = state->if1_freq;

	priv = fe->tuner_priv;



	if1 = priv->if1_freq;

	b[0] = REG_LO1B1;

	b[1] = 0xFF;

	mt2060_writeregs(state,b,2);



	freq = fep->frequency / 1000; // Hz -> kHz

	mt2060_writeregs(priv,b,2);



	freq = params->frequency / 1000; // Hz -> kHz

	priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;



	f_lo1 = freq + if1 * 1000;

	f_lo1 = (f_lo1 / 250) * 250;

	f_lo2 = f_lo1 - freq - IF2;

	f_lo2 = (f_lo2/50)*50;

	// From the Comtech datasheet, the step used is 50kHz. The tuner chip could be more precise

	f_lo2 = ((f_lo2 + 25) / 50) * 50;

	priv->frequency =  (f_lo1 - f_lo2 - IF2) * 1000,



#ifdef MT2060_SPURCHECK

	// LO-related spurs detection and correction
@@ -197,12 +190,14 @@ int mt2060_set(struct mt2060_state *state, struct dvb_frontend_parameters *fep) 
	f_lo2 += num1;

#endif

	//Frequency LO1 = 16MHz * (DIV1 + NUM1/64 )

	div1 = f_lo1 / FREF;

	num1 = (64 * (f_lo1 % FREF)  )/FREF;

	num1 = f_lo1 / (FREF / 64);

	div1 = num1 / 64;

	num1 &= 0x3f;



	// Frequency LO2 = 16MHz * (DIV2 + NUM2/8192 )

	div2 = f_lo2 / FREF;

	num2 = (16384 * (f_lo2 % FREF) /FREF +1)/2;

	num2 = f_lo2 * 64 / (FREF / 128);

	div2 = num2 / 8192;

	num2 &= 0x1fff;



	if (freq <=  95000) lnaband = 0xB0; else

	if (freq <= 180000) lnaband = 0xA0; else
@@ -223,85 +218,144 @@ int mt2060_set(struct mt2060_state *state, struct dvb_frontend_parameters *fep) 
	b[5] = ((num2 >>12) & 1) | (div2 << 1);



	dprintk("IF1: %dMHz",(int)if1);

	dprintk("PLL freq: %d  f_lo1: %d  f_lo2: %d  (kHz)",(int)freq,(int)f_lo1,(int)f_lo2);

	dprintk("PLL div1: %d  num1: %d  div2: %d  num2: %d",(int)div1,(int)num1,(int)div2,(int)num2);

	dprintk("PLL freq=%dkHz  f_lo1=%dkHz  f_lo2=%dkHz",(int)freq,(int)f_lo1,(int)f_lo2);

	dprintk("PLL div1=%d  num1=%d  div2=%d  num2=%d",(int)div1,(int)num1,(int)div2,(int)num2);

	dprintk("PLL [1..5]: %2x %2x %2x %2x %2x",(int)b[1],(int)b[2],(int)b[3],(int)b[4],(int)b[5]);



	mt2060_writeregs(state,b,6);

	mt2060_writeregs(priv,b,6);



	//Waits for pll lock or timeout

	i = 0;

	do {

		mt2060_readreg(state,REG_LO_STATUS,b);

		if ((b[0] & 0x88)==0x88) break;

		mt2060_readreg(priv,REG_LO_STATUS,b);

		if ((b[0] & 0x88)==0x88)

			break;

		msleep(4);

		i++;

	} while (i<10);



	return ret;

}

EXPORT_SYMBOL(mt2060_set);



/* from usbsnoop.log */

static void mt2060_calibrate(struct mt2060_state *state)

static void mt2060_calibrate(struct mt2060_priv *priv)

{

	u8 b = 0;

	int i = 0;



	if (mt2060_writeregs(state,mt2060_config1,sizeof(mt2060_config1)))

	if (mt2060_writeregs(priv,mt2060_config1,sizeof(mt2060_config1)))

		return;

	if (mt2060_writeregs(state,mt2060_config2,sizeof(mt2060_config2)))

	if (mt2060_writeregs(priv,mt2060_config2,sizeof(mt2060_config2)))

		return;



	do {

		b |= (1 << 6); // FM1SS;

		mt2060_writereg(state, REG_LO2C1,b);

		mt2060_writereg(priv, REG_LO2C1,b);

		msleep(20);



		if (i == 0) {

			b |= (1 << 7); // FM1CA;

			mt2060_writereg(state, REG_LO2C1,b);

			mt2060_writereg(priv, REG_LO2C1,b);

			b &= ~(1 << 7); // FM1CA;

			msleep(20);

		}



		b &= ~(1 << 6); // FM1SS

		mt2060_writereg(state, REG_LO2C1,b);

		mt2060_writereg(priv, REG_LO2C1,b);



		msleep(20);

		i++;

	} while (i < 9);



	i = 0;

	while (i++ < 10 && mt2060_readreg(state, REG_MISC_STAT, &b) == 0 && (b & (1 << 6)) == 0)

	while (i++ < 10 && mt2060_readreg(priv, REG_MISC_STAT, &b) == 0 && (b & (1 << 6)) == 0)

		msleep(20);



	if (i < 10) {

		mt2060_readreg(state, REG_FM_FREQ, &state->fmfreq); // now find out, what is fmreq used for :)

		dprintk("calibration was successful: %d", state->fmfreq);

		mt2060_readreg(priv, REG_FM_FREQ, &priv->fmfreq); // now find out, what is fmreq used for :)

		dprintk("calibration was successful: %d", (int)priv->fmfreq);

	} else

		dprintk("FMCAL timed out");

}



static int mt2060_calc_regs(struct dvb_frontend *fe, struct dvb_frontend_parameters *params, u8 *buf, int buf_len)

{

	return -ENODEV;

}



static int mt2060_get_frequency(struct dvb_frontend *fe, u32 *frequency)

{

	struct mt2060_priv *priv = fe->tuner_priv;

	*frequency = priv->frequency;

	return 0;

}



static int mt2060_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)

{

	struct mt2060_priv *priv = fe->tuner_priv;

	*bandwidth = priv->bandwidth;

	return 0;

}



static int mt2060_sleep(struct dvb_frontend *fe)

{

	struct mt2060_priv *priv = fe->tuner_priv;

	return mt2060_writereg(priv, REG_VGAG,0x30);

}



static int mt2060_release(struct dvb_frontend *fe)

{

	kfree(fe->tuner_priv);

	fe->tuner_priv = NULL;

	return 0;

}



static const struct dvb_tuner_ops mt2060_tuner_ops = {

	.info = {

		.name           = "Microtune MT2060",

		.frequency_min  =  48000000,

		.frequency_max  = 860000000,

		.frequency_step =     50000,

	},



	.release       = mt2060_release,



	.sleep         = mt2060_sleep,



	.set_params    = mt2060_set_params,

	.calc_regs     = mt2060_calc_regs,

	.get_frequency = mt2060_get_frequency,

	.get_bandwidth = mt2060_get_bandwidth

};



/* This functions tries to identify a MT2060 tuner by reading the PART/REV register. This is hasty. */

int mt2060_attach(struct mt2060_state *state, struct mt2060_config *config, struct i2c_adapter *i2c,u16 if1)

int mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1)

{

	struct mt2060_priv *priv = NULL;

	u8 id = 0;

	memset(state,0,sizeof(struct mt2060_state));



	state->config = config;

	state->i2c = i2c;

	state->if1_freq = if1;

	priv = kzalloc(sizeof(struct mt2060_priv), GFP_KERNEL);

	if (priv == NULL)

		return -ENOMEM;



	if (mt2060_readreg(state,REG_PART_REV,&id) != 0)

		return -ENODEV;

	priv->cfg      = cfg;

	priv->i2c      = i2c;

	priv->if1_freq = if1;



	if (id != PART_REV)

	if (mt2060_readreg(priv,REG_PART_REV,&id) != 0) {

		kfree(priv);

		return -ENODEV;

	}



	if (id != PART_REV) {

		kfree(priv);

		return -ENODEV;

	}

	printk(KERN_INFO "MT2060: successfully identified\n");

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



	fe->tuner_priv = priv;



	mt2060_calibrate(state);

	mt2060_calibrate(priv);



	return 0;

}

drivers/media/dvb/frontends/mt2060.h

+3 −12
Original line number Diff line number Diff line
@@ -22,23 +22,14 @@ 
#ifndef MT2060_H

#define MT2060_H



#include <linux/i2c.h>

#include <linux/dvb/frontend.h>

struct dvb_frontend;

struct i2c_adapter;



struct mt2060_config {

	u8 i2c_address;

	/* Shall we add settings for the discrete outputs ? */

};



struct mt2060_state {

	struct mt2060_config *config;

	struct i2c_adapter *i2c;

	u16 if1_freq;

	u8 fmfreq;

};



extern int mt2060_init(struct mt2060_state *state);

extern int mt2060_set(struct mt2060_state *state, struct dvb_frontend_parameters *fep);

extern int mt2060_attach(struct mt2060_state *state, struct mt2060_config *config, struct i2c_adapter *i2c,u16 if1);

extern int mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1);



#endif

drivers/media/dvb/frontends/mt2060_priv.h

+10 −0
Original line number Diff line number Diff line
@@ -92,4 +92,14 @@ 


#define PART_REV 0x63 // The current driver works only with PART=6 and REV=3 chips



struct mt2060_priv {

	struct mt2060_config *cfg;

	struct i2c_adapter   *i2c;



	u32 frequency;

	u32 bandwidth;

	u16 if1_freq;

	u8  fmfreq;

};



#endif