[mirror_ubuntu-artful-kernel.git] / drivers / media / dvb-frontends / stb6000.c

  /*
     Driver for ST STB6000 DVBS Silicon tuner

     Copyright (C) 2008 Igor M. Liplianin (liplianin@me.by)

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  */

#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dvb/frontend.h>
#include <asm/types.h>

#include "stb6000.h"

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

struct stb6000_priv {
	/* i2c details */
	int i2c_address;
	struct i2c_adapter *i2c;
	u32 frequency;
};

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

static int stb6000_sleep(struct dvb_frontend *fe)
{
	struct stb6000_priv *priv = fe->tuner_priv;
	int ret;
	u8 buf[] = { 10, 0 };
	struct i2c_msg msg = {
		.addr = priv->i2c_address,
		.flags = 0,
		.buf = buf,
		.len = 2
	};

	dprintk("%s:\n", __func__);

	if (fe->ops.i2c_gate_ctrl)
		fe->ops.i2c_gate_ctrl(fe, 1);

	ret = i2c_transfer(priv->i2c, &msg, 1);
	if (ret != 1)
		dprintk("%s: i2c error\n", __func__);

	if (fe->ops.i2c_gate_ctrl)
		fe->ops.i2c_gate_ctrl(fe, 0);

	return (ret == 1) ? 0 : ret;
}

static int stb6000_set_params(struct dvb_frontend *fe)
{
	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
	struct stb6000_priv *priv = fe->tuner_priv;
	unsigned int n, m;
	int ret;
	u32 freq_mhz;
	int bandwidth;
	u8 buf[12];
	struct i2c_msg msg = {
		.addr = priv->i2c_address,
		.flags = 0,
		.buf = buf,
		.len = 12
	};

	dprintk("%s:\n", __func__);

	freq_mhz = p->frequency / 1000;
	bandwidth = p->symbol_rate / 1000000;

	if (bandwidth > 31)
		bandwidth = 31;

	if ((freq_mhz > 949) && (freq_mhz < 2151)) {
		buf[0] = 0x01;
		buf[1] = 0xac;
		if (freq_mhz < 1950)
			buf[1] = 0xaa;
		if (freq_mhz < 1800)
			buf[1] = 0xa8;
		if (freq_mhz < 1650)
			buf[1] = 0xa6;
		if (freq_mhz < 1530)
			buf[1] = 0xa5;
		if (freq_mhz < 1470)
			buf[1] = 0xa4;
		if (freq_mhz < 1370)
			buf[1] = 0xa2;
		if (freq_mhz < 1300)
			buf[1] = 0xa1;
		if (freq_mhz < 1200)
			buf[1] = 0xa0;
		if (freq_mhz < 1075)
			buf[1] = 0xbc;
		if (freq_mhz < 1000)
			buf[1] = 0xba;
		if (freq_mhz < 1075) {
			n = freq_mhz / 8; /* vco=lo*4 */
			m = 2;
		} else {
			n = freq_mhz / 16; /* vco=lo*2 */
			m = 1;
		}
		buf[2] = n >> 1;
		buf[3] = (unsigned char)(((n & 1) << 7) |
					(m * freq_mhz - n * 16) | 0x60);
		buf[4] = 0x04;
		buf[5] = 0x0e;

		buf[6] = (unsigned char)(bandwidth);

		buf[7] = 0xd8;
		buf[8] = 0xd0;
		buf[9] = 0x50;
		buf[10] = 0xeb;
		buf[11] = 0x4f;

		if (fe->ops.i2c_gate_ctrl)
			fe->ops.i2c_gate_ctrl(fe, 1);

		ret = i2c_transfer(priv->i2c, &msg, 1);
		if (ret != 1)
			dprintk("%s: i2c error\n", __func__);

		udelay(10);
		if (fe->ops.i2c_gate_ctrl)
			fe->ops.i2c_gate_ctrl(fe, 0);

		buf[0] = 0x07;
		buf[1] = 0xdf;
		buf[2] = 0xd0;
		buf[3] = 0x50;
		buf[4] = 0xfb;
		msg.len = 5;

		if (fe->ops.i2c_gate_ctrl)
			fe->ops.i2c_gate_ctrl(fe, 1);

		ret = i2c_transfer(priv->i2c, &msg, 1);
		if (ret != 1)
			dprintk("%s: i2c error\n", __func__);

		udelay(10);
		if (fe->ops.i2c_gate_ctrl)
			fe->ops.i2c_gate_ctrl(fe, 0);

		priv->frequency = freq_mhz * 1000;

		return (ret == 1) ? 0 : ret;
	}
	return -1;
}

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

static const struct dvb_tuner_ops stb6000_tuner_ops = {
	.info = {
		.name = "ST STB6000",
		.frequency_min = 950000,
		.frequency_max = 2150000
	},
	.release = stb6000_release,
	.sleep = stb6000_sleep,
	.set_params = stb6000_set_params,
	.get_frequency = stb6000_get_frequency,
};

struct dvb_frontend *stb6000_attach(struct dvb_frontend *fe, int addr,
						struct i2c_adapter *i2c)
{
	struct stb6000_priv *priv = NULL;
	u8 b0[] = { 0 };
	u8 b1[] = { 0, 0 };
	struct i2c_msg msg[2] = {
		{
			.addr = addr,
			.flags = 0,
			.buf = b0,
			.len = 0
		}, {
			.addr = addr,
			.flags = I2C_M_RD,
			.buf = b1,
			.len = 2
		}
	};
	int ret;

	dprintk("%s:\n", __func__);

	if (fe->ops.i2c_gate_ctrl)
		fe->ops.i2c_gate_ctrl(fe, 1);

	/* is some i2c device here ? */
	ret = i2c_transfer(i2c, msg, 2);
	if (fe->ops.i2c_gate_ctrl)
		fe->ops.i2c_gate_ctrl(fe, 0);

	if (ret != 2)
		return NULL;

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

	priv->i2c_address = addr;
	priv->i2c = i2c;

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

	fe->tuner_priv = priv;

	return fe;
}
EXPORT_SYMBOL(stb6000_attach);

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

MODULE_DESCRIPTION("DVB STB6000 driver");
MODULE_AUTHOR("Igor M. Liplianin <liplianin@me.by>");
MODULE_LICENSE("GPL");
Commit	Line	Data
e4aab64c IL	1	/*
	2	Driver for ST STB6000 DVBS Silicon tuner
	3
	4	Copyright (C) 2008 Igor M. Liplianin (liplianin@me.by)
	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
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20
	21	*/
	22
5a0e3ad6	23	#include <linux/slab.h>
e4aab64c IL	24	#include <linux/module.h>
	25	#include <linux/dvb/frontend.h>
	26	#include <asm/types.h>
	27
	28	#include "stb6000.h"
	29
	30	static int debug;
	31	#define dprintk(args...) \
	32	do { \
	33	if (debug) \
	34	printk(KERN_DEBUG "stb6000: " args); \
	35	} while (0)
	36
	37	struct stb6000_priv {
	38	/* i2c details */
	39	int i2c_address;
	40	struct i2c_adapter *i2c;
	41	u32 frequency;
	42	};
	43
	44	static int stb6000_release(struct dvb_frontend *fe)
	45	{
	46	kfree(fe->tuner_priv);
	47	fe->tuner_priv = NULL;
	48	return 0;
	49	}
	50
	51	static int stb6000_sleep(struct dvb_frontend *fe)
	52	{
	53	struct stb6000_priv *priv = fe->tuner_priv;
	54	int ret;
	55	u8 buf[] = { 10, 0 };
	56	struct i2c_msg msg = {
	57	.addr = priv->i2c_address,
	58	.flags = 0,
	59	.buf = buf,
	60	.len = 2
	61	};
	62
	63	dprintk("%s:\n", __func__);
	64
	65	if (fe->ops.i2c_gate_ctrl)
	66	fe->ops.i2c_gate_ctrl(fe, 1);
	67
	68	ret = i2c_transfer(priv->i2c, &msg, 1);
	69	if (ret != 1)
	70	dprintk("%s: i2c error\n", __func__);
	71
	72	if (fe->ops.i2c_gate_ctrl)
	73	fe->ops.i2c_gate_ctrl(fe, 0);
	74
	75	return (ret == 1) ? 0 : ret;
	76	}
	77
14d24d14	78	static int stb6000_set_params(struct dvb_frontend *fe)
e4aab64c	79	{
3608dbb6	80	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
e4aab64c IL	81	struct stb6000_priv *priv = fe->tuner_priv;
	82	unsigned int n, m;
	83	int ret;
	84	u32 freq_mhz;
	85	int bandwidth;
	86	u8 buf[12];
	87	struct i2c_msg msg = {
	88	.addr = priv->i2c_address,
	89	.flags = 0,
	90	.buf = buf,
	91	.len = 12
	92	};
	93
	94	dprintk("%s:\n", __func__);
	95
3608dbb6 MCC	96	freq_mhz = p->frequency / 1000;
3608dbb6 MCC	97	bandwidth = p->symbol_rate / 1000000;
e4aab64c IL	98
	99	if (bandwidth > 31)
	100	bandwidth = 31;
	101
	102	if ((freq_mhz > 949) && (freq_mhz < 2151)) {
	103	buf[0] = 0x01;
	104	buf[1] = 0xac;
	105	if (freq_mhz < 1950)
	106	buf[1] = 0xaa;
	107	if (freq_mhz < 1800)
	108	buf[1] = 0xa8;
	109	if (freq_mhz < 1650)
	110	buf[1] = 0xa6;
	111	if (freq_mhz < 1530)
	112	buf[1] = 0xa5;
	113	if (freq_mhz < 1470)
	114	buf[1] = 0xa4;
	115	if (freq_mhz < 1370)
	116	buf[1] = 0xa2;
	117	if (freq_mhz < 1300)
	118	buf[1] = 0xa1;
	119	if (freq_mhz < 1200)
	120	buf[1] = 0xa0;
	121	if (freq_mhz < 1075)
	122	buf[1] = 0xbc;
	123	if (freq_mhz < 1000)
	124	buf[1] = 0xba;
	125	if (freq_mhz < 1075) {
	126	n = freq_mhz / 8; /* vco=lo4 /
	127	m = 2;
	128	} else {
	129	n = freq_mhz / 16; /* vco=lo2 /
	130	m = 1;
	131	}
	132	buf[2] = n >> 1;
	133	buf[3] = (unsigned char)(((n & 1) << 7) \|
	134	(m * freq_mhz - n * 16) \| 0x60);
	135	buf[4] = 0x04;
	136	buf[5] = 0x0e;
	137
	138	buf[6] = (unsigned char)(bandwidth);
	139
	140	buf[7] = 0xd8;
	141	buf[8] = 0xd0;
	142	buf[9] = 0x50;
	143	buf[10] = 0xeb;
	144	buf[11] = 0x4f;
	145
	146	if (fe->ops.i2c_gate_ctrl)
	147	fe->ops.i2c_gate_ctrl(fe, 1);
	148
	149	ret = i2c_transfer(priv->i2c, &msg, 1);
	150	if (ret != 1)
	151	dprintk("%s: i2c error\n", __func__);
	152
	153	udelay(10);
	154	if (fe->ops.i2c_gate_ctrl)
	155	fe->ops.i2c_gate_ctrl(fe, 0);
	156
	157	buf[0] = 0x07;
	158	buf[1] = 0xdf;
	159	buf[2] = 0xd0;
	160	buf[3] = 0x50;
	161	buf[4] = 0xfb;
162	msg.len = 5;
163
164	if (fe->ops.i2c_gate_ctrl)
165	fe->ops.i2c_gate_ctrl(fe, 1);
166
167	ret = i2c_transfer(priv->i2c, &msg, 1);
168	if (ret != 1)
169	dprintk("%s: i2c error\n", __func__);
170
171	udelay(10);
172	if (fe->ops.i2c_gate_ctrl)
173	fe->ops.i2c_gate_ctrl(fe, 0);
174
175	priv->frequency = freq_mhz * 1000;
176
177	return (ret == 1) ? 0 : ret;
178	}
179	return -1;
180	}
181
182	static int stb6000_get_frequency(struct dvb_frontend fe, u32 frequency)
183	{
184	struct stb6000_priv *priv = fe->tuner_priv;
185	*frequency = priv->frequency;
186	return 0;
187	}
188
14c4bf3c	189	static const struct dvb_tuner_ops stb6000_tuner_ops = {
e4aab64c IL	190	.info = {
	191	.name = "ST STB6000",
	192	.frequency_min = 950000,
	193	.frequency_max = 2150000
	194	},
	195	.release = stb6000_release,
	196	.sleep = stb6000_sleep,
	197	.set_params = stb6000_set_params,
	198	.get_frequency = stb6000_get_frequency,
	199	};
	200
	201	struct dvb_frontend stb6000_attach(struct dvb_frontend fe, int addr,
	202	struct i2c_adapter *i2c)
	203	{
	204	struct stb6000_priv *priv = NULL;
ceab2fe8	205	u8 b0[] = { 0 };
e4aab64c IL	206	u8 b1[] = { 0, 0 };
	207	struct i2c_msg msg[2] = {
	208	{
	209	.addr = addr,
	210	.flags = 0,
ceab2fe8	211	.buf = b0,
e4aab64c IL	212	.len = 0
	213	}, {
	214	.addr = addr,
	215	.flags = I2C_M_RD,
	216	.buf = b1,
	217	.len = 2
	218	}
	219	};
	220	int ret;
	221
	222	dprintk("%s:\n", __func__);
	223
	224	if (fe->ops.i2c_gate_ctrl)
	225	fe->ops.i2c_gate_ctrl(fe, 1);
	226
	227	/* is some i2c device here ? */
	228	ret = i2c_transfer(i2c, msg, 2);
	229	if (fe->ops.i2c_gate_ctrl)
	230	fe->ops.i2c_gate_ctrl(fe, 0);
	231
	232	if (ret != 2)
	233	return NULL;
	234
	235	priv = kzalloc(sizeof(struct stb6000_priv), GFP_KERNEL);
	236	if (priv == NULL)
	237	return NULL;
	238
	239	priv->i2c_address = addr;
	240	priv->i2c = i2c;
	241
	242	memcpy(&fe->ops.tuner_ops, &stb6000_tuner_ops,
	243	sizeof(struct dvb_tuner_ops));
	244
	245	fe->tuner_priv = priv;
	246
	247	return fe;
	248	}
	249	EXPORT_SYMBOL(stb6000_attach);
	250
	251	module_param(debug, int, 0644);
	252	MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
	253
	254	MODULE_DESCRIPTION("DVB STB6000 driver");
	255	MODULE_AUTHOR("Igor M. Liplianin <liplianin@me.by>");
	256	MODULE_LICENSE("GPL");