[deliverable/linux.git] / drivers / media / tuners / mt2266.c

/*
 *  Driver for Microtune MT2266 "Direct conversion low power broadband tuner"
 *
 *  Copyright (c) 2007 Olivier DANET <odanet@caramail.com>
 *
 *  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.
 */

#include <linux/module.h>
#include <linux/delay.h>
#include <linux/dvb/frontend.h>
#include <linux/i2c.h>
#include <linux/slab.h>

#include "dvb_frontend.h"
#include "mt2266.h"

#define I2C_ADDRESS 0x60

#define REG_PART_REV   0
#define REG_TUNE       1
#define REG_BAND       6
#define REG_BANDWIDTH  8
#define REG_LOCK       0x12

#define PART_REV 0x85

struct mt2266_priv {
	struct mt2266_config *cfg;
	struct i2c_adapter   *i2c;

	u32 frequency;
	u32 bandwidth;
	u8 band;
};

#define MT2266_VHF 1
#define MT2266_UHF 0

/* Here, frequencies are expressed in kiloHertz to avoid 32 bits overflows */

static int debug;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");

#define dprintk(args...) do { if (debug) {printk(KERN_DEBUG "MT2266: " args); printk("\n"); }} while (0)

// Reads a single register
static int mt2266_readreg(struct mt2266_priv *priv, u8 reg, u8 *val)
{
	struct i2c_msg msg[2] = {
		{ .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(priv->i2c, msg, 2) != 2) {
		printk(KERN_WARNING "MT2266 I2C read failed\n");
		return -EREMOTEIO;
	}
	return 0;
}

// Writes a single register
static int mt2266_writereg(struct mt2266_priv *priv, u8 reg, u8 val)
{
	u8 buf[2] = { reg, val };
	struct i2c_msg msg = {
		.addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = 2
	};
	if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
		printk(KERN_WARNING "MT2266 I2C write failed\n");
		return -EREMOTEIO;
	}
	return 0;
}

// Writes a set of consecutive registers
static int mt2266_writeregs(struct mt2266_priv *priv,u8 *buf, u8 len)
{
	struct i2c_msg msg = {
		.addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = len
	};
	if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
		printk(KERN_WARNING "MT2266 I2C write failed (len=%i)\n",(int)len);
		return -EREMOTEIO;
	}
	return 0;
}

// Initialisation sequences
static u8 mt2266_init1[] = { REG_TUNE, 0x00, 0x00, 0x28,
				 0x00, 0x52, 0x99, 0x3f };

static u8 mt2266_init2[] = {
    0x17, 0x6d, 0x71, 0x61, 0xc0, 0xbf, 0xff, 0xdc, 0x00, 0x0a, 0xd4,
    0x03, 0x64, 0x64, 0x64, 0x64, 0x22, 0xaa, 0xf2, 0x1e, 0x80, 0x14,
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7f, 0x5e, 0x3f, 0xff, 0xff,
    0xff, 0x00, 0x77, 0x0f, 0x2d
};

static u8 mt2266_init_8mhz[] = { REG_BANDWIDTH, 0x22, 0x22, 0x22, 0x22,
						0x22, 0x22, 0x22, 0x22 };

static u8 mt2266_init_7mhz[] = { REG_BANDWIDTH, 0x32, 0x32, 0x32, 0x32,
						0x32, 0x32, 0x32, 0x32 };

static u8 mt2266_init_6mhz[] = { REG_BANDWIDTH, 0xa7, 0xa7, 0xa7, 0xa7,
						0xa7, 0xa7, 0xa7, 0xa7 };

static u8 mt2266_uhf[] = { 0x1d, 0xdc, 0x00, 0x0a, 0xd4, 0x03, 0x64, 0x64,
			   0x64, 0x64, 0x22, 0xaa, 0xf2, 0x1e, 0x80, 0x14 };

static u8 mt2266_vhf[] = { 0x1d, 0xfe, 0x00, 0x00, 0xb4, 0x03, 0xa5, 0xa5,
			   0xa5, 0xa5, 0x82, 0xaa, 0xf1, 0x17, 0x80, 0x1f };

#define FREF 30000       // Quartz oscillator 30 MHz

static int mt2266_set_params(struct dvb_frontend *fe)
{
	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
	struct mt2266_priv *priv;
	int ret=0;
	u32 freq;
	u32 tune;
	u8  lnaband;
	u8  b[10];
	int i;
	u8 band;

	priv = fe->tuner_priv;

	freq = priv->frequency / 1000; /* Hz -> kHz */
	if (freq < 470000 && freq > 230000)
		return -EINVAL; /* Gap between VHF and UHF bands */

	priv->frequency = c->frequency;
	tune = 2 * freq * (8192/16) / (FREF/16);
	band = (freq < 300000) ? MT2266_VHF : MT2266_UHF;
	if (band == MT2266_VHF)
		tune *= 2;

	switch (c->bandwidth_hz) {
	case 6000000:
		mt2266_writeregs(priv, mt2266_init_6mhz,
				 sizeof(mt2266_init_6mhz));
		break;
	case 8000000:
		mt2266_writeregs(priv, mt2266_init_8mhz,
				 sizeof(mt2266_init_8mhz));
		break;
	case 7000000:
	default:
		mt2266_writeregs(priv, mt2266_init_7mhz,
				 sizeof(mt2266_init_7mhz));
		break;
	}
	priv->bandwidth = c->bandwidth_hz;

	if (band == MT2266_VHF && priv->band == MT2266_UHF) {
		dprintk("Switch from UHF to VHF");
		mt2266_writereg(priv, 0x05, 0x04);
		mt2266_writereg(priv, 0x19, 0x61);
		mt2266_writeregs(priv, mt2266_vhf, sizeof(mt2266_vhf));
	} else if (band == MT2266_UHF && priv->band == MT2266_VHF) {
		dprintk("Switch from VHF to UHF");
		mt2266_writereg(priv, 0x05, 0x52);
		mt2266_writereg(priv, 0x19, 0x61);
		mt2266_writeregs(priv, mt2266_uhf, sizeof(mt2266_uhf));
	}
	msleep(10);

	if (freq <= 495000)
		lnaband = 0xEE;
	else if (freq <= 525000)
		lnaband = 0xDD;
	else if (freq <= 550000)
		lnaband = 0xCC;
	else if (freq <= 580000)
		lnaband = 0xBB;
	else if (freq <= 605000)
		lnaband = 0xAA;
	else if (freq <= 630000)
		lnaband = 0x99;
	else if (freq <= 655000)
		lnaband = 0x88;
	else if (freq <= 685000)
		lnaband = 0x77;
	else if (freq <= 710000)
		lnaband = 0x66;
	else if (freq <= 735000)
		lnaband = 0x55;
	else if (freq <= 765000)
		lnaband = 0x44;
	else if (freq <= 802000)
		lnaband = 0x33;
	else if (freq <= 840000)
		lnaband = 0x22;
	else
		lnaband = 0x11;

	b[0] = REG_TUNE;
	b[1] = (tune >> 8) & 0x1F;
	b[2] = tune & 0xFF;
	b[3] = tune >> 13;
	mt2266_writeregs(priv,b,4);

	dprintk("set_parms: tune=%d band=%d %s",
		(int) tune, (int) lnaband,
		(band == MT2266_UHF) ? "UHF" : "VHF");
	dprintk("set_parms: [1..3]: %2x %2x %2x",
		(int) b[1], (int) b[2], (int)b[3]);

	if (band == MT2266_UHF) {
		b[0] = 0x05;
		b[1] = (priv->band == MT2266_VHF) ? 0x52 : 0x62;
		b[2] = lnaband;
		mt2266_writeregs(priv, b, 3);
	}

	/* Wait for pll lock or timeout */
	i = 0;
	do {
		mt2266_readreg(priv,REG_LOCK,b);
		if (b[0] & 0x40)
			break;
		msleep(10);
		i++;
	} while (i<10);
	dprintk("Lock when i=%i",(int)i);

	if (band == MT2266_UHF && priv->band == MT2266_VHF)
		mt2266_writereg(priv, 0x05, 0x62);

	priv->band = band;

	return ret;
}

static void mt2266_calibrate(struct mt2266_priv *priv)
{
	mt2266_writereg(priv, 0x11, 0x03);
	mt2266_writereg(priv, 0x11, 0x01);
	mt2266_writeregs(priv, mt2266_init1, sizeof(mt2266_init1));
	mt2266_writeregs(priv, mt2266_init2, sizeof(mt2266_init2));
	mt2266_writereg(priv, 0x33, 0x5e);
	mt2266_writereg(priv, 0x10, 0x10);
	mt2266_writereg(priv, 0x10, 0x00);
	mt2266_writeregs(priv, mt2266_init_8mhz, sizeof(mt2266_init_8mhz));
	msleep(25);
	mt2266_writereg(priv, 0x17, 0x6d);
	mt2266_writereg(priv, 0x1c, 0x00);
	msleep(75);
	mt2266_writereg(priv, 0x17, 0x6d);
	mt2266_writereg(priv, 0x1c, 0xff);
}

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

static int mt2266_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
{
	struct mt2266_priv *priv = fe->tuner_priv;
	*bandwidth = priv->bandwidth;
	return 0;
}

static int mt2266_init(struct dvb_frontend *fe)
{
	int ret;
	struct mt2266_priv *priv = fe->tuner_priv;
	ret = mt2266_writereg(priv, 0x17, 0x6d);
	if (ret < 0)
		return ret;
	ret = mt2266_writereg(priv, 0x1c, 0xff);
	if (ret < 0)
		return ret;
	return 0;
}

static int mt2266_sleep(struct dvb_frontend *fe)
{
	struct mt2266_priv *priv = fe->tuner_priv;
	mt2266_writereg(priv, 0x17, 0x6d);
	mt2266_writereg(priv, 0x1c, 0x00);
	return 0;
}

static int mt2266_release(struct dvb_frontend *fe)
{
	kfree(fe->tuner_priv);
	fe->tuner_priv = NULL;
	return 0;
}

static const struct dvb_tuner_ops mt2266_tuner_ops = {
	.info = {
		.name           = "Microtune MT2266",
		.frequency_min  = 174000000,
		.frequency_max  = 862000000,
		.frequency_step =     50000,
	},
	.release       = mt2266_release,
	.init          = mt2266_init,
	.sleep         = mt2266_sleep,
	.set_params    = mt2266_set_params,
	.get_frequency = mt2266_get_frequency,
	.get_bandwidth = mt2266_get_bandwidth
};

struct dvb_frontend * mt2266_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2266_config *cfg)
{
	struct mt2266_priv *priv = NULL;
	u8 id = 0;

	priv = kzalloc(sizeof(struct mt2266_priv), GFP_KERNEL);
	if (priv == NULL)
		return NULL;

	priv->cfg      = cfg;
	priv->i2c      = i2c;
	priv->band     = MT2266_UHF;

	if (mt2266_readreg(priv, 0, &id)) {
		kfree(priv);
		return NULL;
	}
	if (id != PART_REV) {
		kfree(priv);
		return NULL;
	}
	printk(KERN_INFO "MT2266: successfully identified\n");
	memcpy(&fe->ops.tuner_ops, &mt2266_tuner_ops, sizeof(struct dvb_tuner_ops));

	fe->tuner_priv = priv;
	mt2266_calibrate(priv);
	return fe;
}
EXPORT_SYMBOL(mt2266_attach);

MODULE_AUTHOR("Olivier DANET");
MODULE_DESCRIPTION("Microtune MT2266 silicon tuner driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
54d75eba OD	1	/*
	2	* Driver for Microtune MT2266 "Direct conversion low power broadband tuner"
	3	*
	4	* Copyright (c) 2007 Olivier DANET <odanet@caramail.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/module.h>
54d75eba OD	18	#include <linux/delay.h>
	19	#include <linux/dvb/frontend.h>
	20	#include <linux/i2c.h>
5a0e3ad6	21	#include <linux/slab.h>
54d75eba OD	22
	23	#include "dvb_frontend.h"
	24	#include "mt2266.h"
	25
	26	#define I2C_ADDRESS 0x60
	27
	28	#define REG_PART_REV 0
	29	#define REG_TUNE 1
	30	#define REG_BAND 6
	31	#define REG_BANDWIDTH 8
	32	#define REG_LOCK 0x12
	33
	34	#define PART_REV 0x85
	35
	36	struct mt2266_priv {
	37	struct mt2266_config *cfg;
	38	struct i2c_adapter *i2c;
	39
	40	u32 frequency;
	41	u32 bandwidth;
542794be	42	u8 band;
54d75eba OD	43	};
54d75eba OD	44
542794be OD	45	#define MT2266_VHF 1
	46	#define MT2266_UHF 0
	47
54d75eba OD	48	/* Here, frequencies are expressed in kiloHertz to avoid 32 bits overflows */
	49
	50	static int debug;
	51	module_param(debug, int, 0644);
	52	MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
	53
	54	#define dprintk(args...) do { if (debug) {printk(KERN_DEBUG "MT2266: " args); printk("\n"); }} while (0)
	55
	56	// Reads a single register
	57	static int mt2266_readreg(struct mt2266_priv priv, u8 reg, u8 val)
	58	{
	59	struct i2c_msg msg[2] = {
	60	{ .addr = priv->cfg->i2c_address, .flags = 0, .buf = &reg, .len = 1 },
	61	{ .addr = priv->cfg->i2c_address, .flags = I2C_M_RD, .buf = val, .len = 1 },
	62	};
	63	if (i2c_transfer(priv->i2c, msg, 2) != 2) {
	64	printk(KERN_WARNING "MT2266 I2C read failed\n");
	65	return -EREMOTEIO;
	66	}
	67	return 0;
	68	}
	69
	70	// Writes a single register
	71	static int mt2266_writereg(struct mt2266_priv *priv, u8 reg, u8 val)
	72	{
	73	u8 buf[2] = { reg, val };
	74	struct i2c_msg msg = {
	75	.addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = 2
	76	};
	77	if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
	78	printk(KERN_WARNING "MT2266 I2C write failed\n");
	79	return -EREMOTEIO;
	80	}
	81	return 0;
	82	}
	83
	84	// Writes a set of consecutive registers
	85	static int mt2266_writeregs(struct mt2266_priv priv,u8 buf, u8 len)
	86	{
	87	struct i2c_msg msg = {
	88	.addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = len
	89	};
	90	if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
	91	printk(KERN_WARNING "MT2266 I2C write failed (len=%i)\n",(int)len);
	92	return -EREMOTEIO;
	93	}
	94	return 0;
	95	}
	96
	97	// Initialisation sequences
542794be OD	98	static u8 mt2266_init1[] = { REG_TUNE, 0x00, 0x00, 0x28,
542794be OD	99	0x00, 0x52, 0x99, 0x3f };
54d75eba OD	100
54d75eba OD	101	static u8 mt2266_init2[] = {
542794be OD	102	0x17, 0x6d, 0x71, 0x61, 0xc0, 0xbf, 0xff, 0xdc, 0x00, 0x0a, 0xd4,
	103	0x03, 0x64, 0x64, 0x64, 0x64, 0x22, 0xaa, 0xf2, 0x1e, 0x80, 0x14,
	104	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7f, 0x5e, 0x3f, 0xff, 0xff,
	105	0xff, 0x00, 0x77, 0x0f, 0x2d
	106	};
	107
	108	static u8 mt2266_init_8mhz[] = { REG_BANDWIDTH, 0x22, 0x22, 0x22, 0x22,
	109	0x22, 0x22, 0x22, 0x22 };
54d75eba	110
542794be OD	111	static u8 mt2266_init_7mhz[] = { REG_BANDWIDTH, 0x32, 0x32, 0x32, 0x32,
542794be OD	112	0x32, 0x32, 0x32, 0x32 };
54d75eba	113
542794be OD	114	static u8 mt2266_init_6mhz[] = { REG_BANDWIDTH, 0xa7, 0xa7, 0xa7, 0xa7,
542794be OD	115	0xa7, 0xa7, 0xa7, 0xa7 };
54d75eba	116
542794be OD	117	static u8 mt2266_uhf[] = { 0x1d, 0xdc, 0x00, 0x0a, 0xd4, 0x03, 0x64, 0x64,
	118	0x64, 0x64, 0x22, 0xaa, 0xf2, 0x1e, 0x80, 0x14 };
	119
	120	static u8 mt2266_vhf[] = { 0x1d, 0xfe, 0x00, 0x00, 0xb4, 0x03, 0xa5, 0xa5,
	121	0xa5, 0xa5, 0x82, 0xaa, 0xf1, 0x17, 0x80, 0x1f };
54d75eba OD	122
	123	#define FREF 30000 // Quartz oscillator 30 MHz
	124
14d24d14	125	static int mt2266_set_params(struct dvb_frontend *fe)
54d75eba	126	{
82c0126f	127	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
54d75eba OD	128	struct mt2266_priv *priv;
	129	int ret=0;
	130	u32 freq;
	131	u32 tune;
	132	u8 lnaband;
	133	u8 b[10];
	134	int i;
542794be	135	u8 band;
54d75eba OD	136
	137	priv = fe->tuner_priv;
	138
82c0126f	139	freq = priv->frequency / 1000; /* Hz -> kHz */
542794be OD	140	if (freq < 470000 && freq > 230000)
542794be OD	141	return -EINVAL; /* Gap between VHF and UHF bands */
542794be	142
82c0126f	143	priv->frequency = c->frequency;
542794be OD	144	tune = 2 * freq * (8192/16) / (FREF/16);
	145	band = (freq < 300000) ? MT2266_VHF : MT2266_UHF;
	146	if (band == MT2266_VHF)
	147	tune *= 2;
	148
82c0126f MCC	149	switch (c->bandwidth_hz) {
82c0126f MCC	150	case 6000000:
542794be OD	151	mt2266_writeregs(priv, mt2266_init_6mhz,
	152	sizeof(mt2266_init_6mhz));
	153	break;
82c0126f	154	case 8000000:
542794be OD	155	mt2266_writeregs(priv, mt2266_init_8mhz,
542794be OD	156	sizeof(mt2266_init_8mhz));
82c0126f MCC	157	break;
	158	case 7000000:
	159	default:
	160	mt2266_writeregs(priv, mt2266_init_7mhz,
	161	sizeof(mt2266_init_7mhz));
542794be OD	162	break;
542794be OD	163	}
c6f56e7d	164	priv->bandwidth = c->bandwidth_hz;
542794be OD	165
	166	if (band == MT2266_VHF && priv->band == MT2266_UHF) {
	167	dprintk("Switch from UHF to VHF");
	168	mt2266_writereg(priv, 0x05, 0x04);
	169	mt2266_writereg(priv, 0x19, 0x61);
	170	mt2266_writeregs(priv, mt2266_vhf, sizeof(mt2266_vhf));
	171	} else if (band == MT2266_UHF && priv->band == MT2266_VHF) {
	172	dprintk("Switch from VHF to UHF");
	173	mt2266_writereg(priv, 0x05, 0x52);
	174	mt2266_writereg(priv, 0x19, 0x61);
	175	mt2266_writeregs(priv, mt2266_uhf, sizeof(mt2266_uhf));
	176	}
	177	msleep(10);
	178
	179	if (freq <= 495000)
	180	lnaband = 0xEE;
	181	else if (freq <= 525000)
	182	lnaband = 0xDD;
	183	else if (freq <= 550000)
	184	lnaband = 0xCC;
	185	else if (freq <= 580000)
	186	lnaband = 0xBB;
	187	else if (freq <= 605000)
	188	lnaband = 0xAA;
	189	else if (freq <= 630000)
	190	lnaband = 0x99;
	191	else if (freq <= 655000)
	192	lnaband = 0x88;
	193	else if (freq <= 685000)
	194	lnaband = 0x77;
	195	else if (freq <= 710000)
	196	lnaband = 0x66;
	197	else if (freq <= 735000)
	198	lnaband = 0x55;
	199	else if (freq <= 765000)
	200	lnaband = 0x44;
	201	else if (freq <= 802000)
	202	lnaband = 0x33;
	203	else if (freq <= 840000)
	204	lnaband = 0x22;
	205	else
	206	lnaband = 0x11;
54d75eba OD	207
	208	b[0] = REG_TUNE;
	209	b[1] = (tune >> 8) & 0x1F;
	210	b[2] = tune & 0xFF;
	211	b[3] = tune >> 13;
	212	mt2266_writeregs(priv,b,4);
	213
542794be OD	214	dprintk("set_parms: tune=%d band=%d %s",
	215	(int) tune, (int) lnaband,
	216	(band == MT2266_UHF) ? "UHF" : "VHF");
	217	dprintk("set_parms: [1..3]: %2x %2x %2x",
	218	(int) b[1], (int) b[2], (int)b[3]);
	219
	220	if (band == MT2266_UHF) {
	221	b[0] = 0x05;
	222	b[1] = (priv->band == MT2266_VHF) ? 0x52 : 0x62;
	223	b[2] = lnaband;
	224	mt2266_writeregs(priv, b, 3);
	225	}
54d75eba	226
542794be	227	/* Wait for pll lock or timeout */
54d75eba OD	228	i = 0;
	229	do {
	230	mt2266_readreg(priv,REG_LOCK,b);
542794be	231	if (b[0] & 0x40)
54d75eba OD	232	break;
	233	msleep(10);
	234	i++;
	235	} while (i<10);
b6884a17	236	dprintk("Lock when i=%i",(int)i);
542794be OD	237
	238	if (band == MT2266_UHF && priv->band == MT2266_VHF)
	239	mt2266_writereg(priv, 0x05, 0x62);
	240
	241	priv->band = band;
	242
54d75eba OD	243	return ret;
	244	}
	245
	246	static void mt2266_calibrate(struct mt2266_priv *priv)
	247	{
542794be OD	248	mt2266_writereg(priv, 0x11, 0x03);
	249	mt2266_writereg(priv, 0x11, 0x01);
	250	mt2266_writeregs(priv, mt2266_init1, sizeof(mt2266_init1));
	251	mt2266_writeregs(priv, mt2266_init2, sizeof(mt2266_init2));
	252	mt2266_writereg(priv, 0x33, 0x5e);
	253	mt2266_writereg(priv, 0x10, 0x10);
	254	mt2266_writereg(priv, 0x10, 0x00);
	255	mt2266_writeregs(priv, mt2266_init_8mhz, sizeof(mt2266_init_8mhz));
54d75eba	256	msleep(25);
542794be OD	257	mt2266_writereg(priv, 0x17, 0x6d);
542794be OD	258	mt2266_writereg(priv, 0x1c, 0x00);
54d75eba	259	msleep(75);
542794be OD	260	mt2266_writereg(priv, 0x17, 0x6d);
542794be OD	261	mt2266_writereg(priv, 0x1c, 0xff);
54d75eba OD	262	}
	263
	264	static int mt2266_get_frequency(struct dvb_frontend fe, u32 frequency)
	265	{
	266	struct mt2266_priv *priv = fe->tuner_priv;
	267	*frequency = priv->frequency;
	268	return 0;
	269	}
	270
	271	static int mt2266_get_bandwidth(struct dvb_frontend fe, u32 bandwidth)
	272	{
	273	struct mt2266_priv *priv = fe->tuner_priv;
	274	*bandwidth = priv->bandwidth;
	275	return 0;
	276	}
	277
	278	static int mt2266_init(struct dvb_frontend *fe)
	279	{
542794be	280	int ret;
54d75eba	281	struct mt2266_priv *priv = fe->tuner_priv;
542794be OD	282	ret = mt2266_writereg(priv, 0x17, 0x6d);
	283	if (ret < 0)
	284	return ret;
	285	ret = mt2266_writereg(priv, 0x1c, 0xff);
	286	if (ret < 0)
	287	return ret;
54d75eba OD	288	return 0;
	289	}
	290
	291	static int mt2266_sleep(struct dvb_frontend *fe)
	292	{
	293	struct mt2266_priv *priv = fe->tuner_priv;
542794be OD	294	mt2266_writereg(priv, 0x17, 0x6d);
542794be OD	295	mt2266_writereg(priv, 0x1c, 0x00);
54d75eba OD	296	return 0;
	297	}
	298
	299	static int mt2266_release(struct dvb_frontend *fe)
	300	{
	301	kfree(fe->tuner_priv);
	302	fe->tuner_priv = NULL;
	303	return 0;
	304	}
	305
	306	static const struct dvb_tuner_ops mt2266_tuner_ops = {
	307	.info = {
	308	.name = "Microtune MT2266",
542794be OD	309	.frequency_min = 174000000,
542794be OD	310	.frequency_max = 862000000,
54d75eba OD	311	.frequency_step = 50000,
	312	},
	313	.release = mt2266_release,
	314	.init = mt2266_init,
	315	.sleep = mt2266_sleep,
	316	.set_params = mt2266_set_params,
	317	.get_frequency = mt2266_get_frequency,
	318	.get_bandwidth = mt2266_get_bandwidth
	319	};
	320
	321	struct dvb_frontend * mt2266_attach(struct dvb_frontend fe, struct i2c_adapter i2c, struct mt2266_config *cfg)
	322	{
	323	struct mt2266_priv *priv = NULL;
	324	u8 id = 0;
	325
	326	priv = kzalloc(sizeof(struct mt2266_priv), GFP_KERNEL);
	327	if (priv == NULL)
	328	return NULL;
	329
	330	priv->cfg = cfg;
	331	priv->i2c = i2c;
542794be	332	priv->band = MT2266_UHF;
54d75eba	333
542794be	334	if (mt2266_readreg(priv, 0, &id)) {
54d75eba OD	335	kfree(priv);
	336	return NULL;
	337	}
	338	if (id != PART_REV) {
	339	kfree(priv);
	340	return NULL;
	341	}
	342	printk(KERN_INFO "MT2266: successfully identified\n");
	343	memcpy(&fe->ops.tuner_ops, &mt2266_tuner_ops, sizeof(struct dvb_tuner_ops));
	344
	345	fe->tuner_priv = priv;
	346	mt2266_calibrate(priv);
	347	return fe;
	348	}
	349	EXPORT_SYMBOL(mt2266_attach);
	350
	351	MODULE_AUTHOR("Olivier DANET");
	352	MODULE_DESCRIPTION("Microtune MT2266 silicon tuner driver");
	353	MODULE_LICENSE("GPL");