[GitHub/mt8127/android_kernel_alcatel_ttab.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 dvb_frontend_parameters *params)
{
	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 = params->frequency / 1000;
	bandwidth = params->u.qpsk.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 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
	78	static int stb6000_set_params(struct dvb_frontend *fe,
	79	struct dvb_frontend_parameters *params)
	80	{
	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
96	freq_mhz = params->frequency / 1000;
97	bandwidth = params->u.qpsk.symbol_rate / 1000000;
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
189	static struct dvb_tuner_ops stb6000_tuner_ops = {
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");