[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / common / 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 dvb_frontend_parameters *params)
{
	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 = params->frequency / 1000; // Hz -> kHz
	if (freq < 470000 && freq > 230000)
		return -EINVAL; /* Gap between VHF and UHF bands */
	priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
	priv->frequency = freq * 1000;

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

	switch (params->u.ofdm.bandwidth) {
	case BANDWIDTH_6_MHZ:
		mt2266_writeregs(priv, mt2266_init_6mhz,
				 sizeof(mt2266_init_6mhz));
		break;
	case BANDWIDTH_7_MHZ:
		mt2266_writeregs(priv, mt2266_init_7mhz,
				 sizeof(mt2266_init_7mhz));
		break;
	case BANDWIDTH_8_MHZ:
	default:
		mt2266_writeregs(priv, mt2266_init_8mhz,
				 sizeof(mt2266_init_8mhz));
		break;
	}

	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
	125	static int mt2266_set_params(struct dvb_frontend fe, struct dvb_frontend_parameters params)
	126	{
	127	struct mt2266_priv *priv;
	128	int ret=0;
	129	u32 freq;
	130	u32 tune;
	131	u8 lnaband;
	132	u8 b[10];
	133	int i;
542794be	134	u8 band;
54d75eba OD	135
	136	priv = fe->tuner_priv;
	137
54d75eba	138	freq = params->frequency / 1000; // Hz -> kHz
542794be OD	139	if (freq < 470000 && freq > 230000)
542794be OD	140	return -EINVAL; /* Gap between VHF and UHF bands */
54d75eba OD	141	priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
54d75eba OD	142	priv->frequency = freq * 1000;
542794be OD	143
	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
	149	switch (params->u.ofdm.bandwidth) {
	150	case BANDWIDTH_6_MHZ:
	151	mt2266_writeregs(priv, mt2266_init_6mhz,
	152	sizeof(mt2266_init_6mhz));
	153	break;
	154	case BANDWIDTH_7_MHZ:
	155	mt2266_writeregs(priv, mt2266_init_7mhz,
	156	sizeof(mt2266_init_7mhz));
	157	break;
	158	case BANDWIDTH_8_MHZ:
	159	default:
	160	mt2266_writeregs(priv, mt2266_init_8mhz,
	161	sizeof(mt2266_init_8mhz));
	162	break;
	163	}
	164
	165	if (band == MT2266_VHF && priv->band == MT2266_UHF) {
	166	dprintk("Switch from UHF to VHF");
	167	mt2266_writereg(priv, 0x05, 0x04);
	168	mt2266_writereg(priv, 0x19, 0x61);
	169	mt2266_writeregs(priv, mt2266_vhf, sizeof(mt2266_vhf));
	170	} else if (band == MT2266_UHF && priv->band == MT2266_VHF) {
	171	dprintk("Switch from VHF to UHF");
	172	mt2266_writereg(priv, 0x05, 0x52);
	173	mt2266_writereg(priv, 0x19, 0x61);
	174	mt2266_writeregs(priv, mt2266_uhf, sizeof(mt2266_uhf));
	175	}
	176	msleep(10);
	177
	178	if (freq <= 495000)
	179	lnaband = 0xEE;
	180	else if (freq <= 525000)
	181	lnaband = 0xDD;
	182	else if (freq <= 550000)
	183	lnaband = 0xCC;
	184	else if (freq <= 580000)
	185	lnaband = 0xBB;
	186	else if (freq <= 605000)
	187	lnaband = 0xAA;
	188	else if (freq <= 630000)
	189	lnaband = 0x99;
	190	else if (freq <= 655000)
	191	lnaband = 0x88;
	192	else if (freq <= 685000)
	193	lnaband = 0x77;
	194	else if (freq <= 710000)
	195	lnaband = 0x66;
	196	else if (freq <= 735000)
	197	lnaband = 0x55;
	198	else if (freq <= 765000)
	199	lnaband = 0x44;
	200	else if (freq <= 802000)
	201	lnaband = 0x33;
	202	else if (freq <= 840000)
	203	lnaband = 0x22;
	204	else
	205	lnaband = 0x11;
54d75eba OD	206
	207	b[0] = REG_TUNE;
	208	b[1] = (tune >> 8) & 0x1F;
	209	b[2] = tune & 0xFF;
	210	b[3] = tune >> 13;
	211	mt2266_writeregs(priv,b,4);
	212
542794be OD	213	dprintk("set_parms: tune=%d band=%d %s",
	214	(int) tune, (int) lnaband,
	215	(band == MT2266_UHF) ? "UHF" : "VHF");
	216	dprintk("set_parms: [1..3]: %2x %2x %2x",
	217	(int) b[1], (int) b[2], (int)b[3]);
	218
	219	if (band == MT2266_UHF) {
	220	b[0] = 0x05;
	221	b[1] = (priv->band == MT2266_VHF) ? 0x52 : 0x62;
	222	b[2] = lnaband;
	223	mt2266_writeregs(priv, b, 3);
	224	}
54d75eba	225
542794be	226	/* Wait for pll lock or timeout */
54d75eba OD	227	i = 0;
	228	do {
	229	mt2266_readreg(priv,REG_LOCK,b);
542794be	230	if (b[0] & 0x40)
54d75eba OD	231	break;
	232	msleep(10);
	233	i++;
	234	} while (i<10);
b6884a17	235	dprintk("Lock when i=%i",(int)i);
542794be OD	236
	237	if (band == MT2266_UHF && priv->band == MT2266_VHF)
	238	mt2266_writereg(priv, 0x05, 0x62);
	239
	240	priv->band = band;
	241
54d75eba OD	242	return ret;
	243	}
	244
	245	static void mt2266_calibrate(struct mt2266_priv *priv)
	246	{
542794be OD	247	mt2266_writereg(priv, 0x11, 0x03);
	248	mt2266_writereg(priv, 0x11, 0x01);
	249	mt2266_writeregs(priv, mt2266_init1, sizeof(mt2266_init1));
	250	mt2266_writeregs(priv, mt2266_init2, sizeof(mt2266_init2));
	251	mt2266_writereg(priv, 0x33, 0x5e);
	252	mt2266_writereg(priv, 0x10, 0x10);
	253	mt2266_writereg(priv, 0x10, 0x00);
	254	mt2266_writeregs(priv, mt2266_init_8mhz, sizeof(mt2266_init_8mhz));
54d75eba	255	msleep(25);
542794be OD	256	mt2266_writereg(priv, 0x17, 0x6d);
542794be OD	257	mt2266_writereg(priv, 0x1c, 0x00);
54d75eba	258	msleep(75);
542794be OD	259	mt2266_writereg(priv, 0x17, 0x6d);
542794be OD	260	mt2266_writereg(priv, 0x1c, 0xff);
54d75eba OD	261	}
	262
	263	static int mt2266_get_frequency(struct dvb_frontend fe, u32 frequency)
	264	{
	265	struct mt2266_priv *priv = fe->tuner_priv;
	266	*frequency = priv->frequency;
	267	return 0;
	268	}
	269
	270	static int mt2266_get_bandwidth(struct dvb_frontend fe, u32 bandwidth)
	271	{
	272	struct mt2266_priv *priv = fe->tuner_priv;
	273	*bandwidth = priv->bandwidth;
	274	return 0;
	275	}
	276
	277	static int mt2266_init(struct dvb_frontend *fe)
	278	{
542794be	279	int ret;
54d75eba	280	struct mt2266_priv *priv = fe->tuner_priv;
542794be OD	281	ret = mt2266_writereg(priv, 0x17, 0x6d);
	282	if (ret < 0)
	283	return ret;
	284	ret = mt2266_writereg(priv, 0x1c, 0xff);
	285	if (ret < 0)
	286	return ret;
54d75eba OD	287	return 0;
	288	}
	289
	290	static int mt2266_sleep(struct dvb_frontend *fe)
	291	{
	292	struct mt2266_priv *priv = fe->tuner_priv;
542794be OD	293	mt2266_writereg(priv, 0x17, 0x6d);
542794be OD	294	mt2266_writereg(priv, 0x1c, 0x00);
54d75eba OD	295	return 0;
	296	}
	297
	298	static int mt2266_release(struct dvb_frontend *fe)
	299	{
	300	kfree(fe->tuner_priv);
	301	fe->tuner_priv = NULL;
	302	return 0;
	303	}
	304
	305	static const struct dvb_tuner_ops mt2266_tuner_ops = {
	306	.info = {
	307	.name = "Microtune MT2266",
542794be OD	308	.frequency_min = 174000000,
542794be OD	309	.frequency_max = 862000000,
54d75eba OD	310	.frequency_step = 50000,
	311	},
	312	.release = mt2266_release,
	313	.init = mt2266_init,
	314	.sleep = mt2266_sleep,
	315	.set_params = mt2266_set_params,
	316	.get_frequency = mt2266_get_frequency,
	317	.get_bandwidth = mt2266_get_bandwidth
	318	};
	319
	320	struct dvb_frontend * mt2266_attach(struct dvb_frontend fe, struct i2c_adapter i2c, struct mt2266_config *cfg)
	321	{
	322	struct mt2266_priv *priv = NULL;
	323	u8 id = 0;
	324
	325	priv = kzalloc(sizeof(struct mt2266_priv), GFP_KERNEL);
	326	if (priv == NULL)
	327	return NULL;
	328
	329	priv->cfg = cfg;
	330	priv->i2c = i2c;
542794be	331	priv->band = MT2266_UHF;
54d75eba	332
542794be	333	if (mt2266_readreg(priv, 0, &id)) {
54d75eba OD	334	kfree(priv);
	335	return NULL;
	336	}
	337	if (id != PART_REV) {
	338	kfree(priv);
	339	return NULL;
	340	}
	341	printk(KERN_INFO "MT2266: successfully identified\n");
	342	memcpy(&fe->ops.tuner_ops, &mt2266_tuner_ops, sizeof(struct dvb_tuner_ops));
	343
	344	fe->tuner_priv = priv;
	345	mt2266_calibrate(priv);
	346	return fe;
	347	}
	348	EXPORT_SYMBOL(mt2266_attach);
	349
	350	MODULE_AUTHOR("Olivier DANET");
	351	MODULE_DESCRIPTION("Microtune MT2266 silicon tuner driver");
	352	MODULE_LICENSE("GPL");