[linux-2.6-block.git] / drivers / media / dvb / frontends / ec100.c

/*
 * E3C EC100 demodulator driver
 *
 * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
 *
 *    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 "dvb_frontend.h"
#include "ec100_priv.h"
#include "ec100.h"

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

struct ec100_state {
	struct i2c_adapter *i2c;
	struct dvb_frontend frontend;
	struct ec100_config config;

	u16 ber;
};

/* write single register */
static int ec100_write_reg(struct ec100_state *state, u8 reg, u8 val)
{
	u8 buf[2] = {reg, val};
	struct i2c_msg msg = {
		.addr = state->config.demod_address,
		.flags = 0,
		.len = 2,
		.buf = buf};

	if (i2c_transfer(state->i2c, &msg, 1) != 1) {
		warn("I2C write failed reg:%02x", reg);
		return -EREMOTEIO;
	}
	return 0;
}

/* read single register */
static int ec100_read_reg(struct ec100_state *state, u8 reg, u8 *val)
{
	struct i2c_msg msg[2] = {
		{
			.addr = state->config.demod_address,
			.flags = 0,
			.len = 1,
			.buf = &reg
		}, {
			.addr = state->config.demod_address,
			.flags = I2C_M_RD,
			.len = 1,
			.buf = val
		}
	};

	if (i2c_transfer(state->i2c, msg, 2) != 2) {
		warn("I2C read failed reg:%02x", reg);
		return -EREMOTEIO;
	}
	return 0;
}

static int ec100_set_frontend(struct dvb_frontend *fe,
	struct dvb_frontend_parameters *params)
{
	struct ec100_state *state = fe->demodulator_priv;
	int ret;
	u8 tmp, tmp2;

	deb_info("%s: freq:%d bw:%d\n", __func__, params->frequency,
		params->u.ofdm.bandwidth);

	/* program tuner */
	if (fe->ops.tuner_ops.set_params)
		fe->ops.tuner_ops.set_params(fe, params);

	ret = ec100_write_reg(state, 0x04, 0x06);
	if (ret)
		goto error;
	ret = ec100_write_reg(state, 0x67, 0x58);
	if (ret)
		goto error;
	ret = ec100_write_reg(state, 0x05, 0x18);
	if (ret)
		goto error;

	/* reg/bw |   6  |   7  |   8
	   -------+------+------+------
	   A 0x1b | 0xa1 | 0xe7 | 0x2c
	   A 0x1c | 0x55 | 0x63 | 0x72
	   -------+------+------+------
	   B 0x1b | 0xb7 | 0x00 | 0x49
	   B 0x1c | 0x55 | 0x64 | 0x72 */

	switch (params->u.ofdm.bandwidth) {
	case BANDWIDTH_6_MHZ:
		tmp = 0xb7;
		tmp2 = 0x55;
		break;
	case BANDWIDTH_7_MHZ:
		tmp = 0x00;
		tmp2 = 0x64;
		break;
	case BANDWIDTH_8_MHZ:
	default:
		tmp = 0x49;
		tmp2 = 0x72;
	}

	ret = ec100_write_reg(state, 0x1b, tmp);
	if (ret)
		goto error;
	ret = ec100_write_reg(state, 0x1c, tmp2);
	if (ret)
		goto error;

	ret = ec100_write_reg(state, 0x0c, 0xbb); /* if freq */
	if (ret)
		goto error;
	ret = ec100_write_reg(state, 0x0d, 0x31); /* if freq */
	if (ret)
		goto error;

	ret = ec100_write_reg(state, 0x08, 0x24);
	if (ret)
		goto error;

	ret = ec100_write_reg(state, 0x00, 0x00); /* go */
	if (ret)
		goto error;
	ret = ec100_write_reg(state, 0x00, 0x20); /* go */
	if (ret)
		goto error;

	return ret;
error:
	deb_info("%s: failed:%d\n", __func__, ret);
	return ret;
}

static int ec100_get_tune_settings(struct dvb_frontend *fe,
	struct dvb_frontend_tune_settings *fesettings)
{
	fesettings->min_delay_ms = 300;
	fesettings->step_size = 0;
	fesettings->max_drift = 0;

	return 0;
}

static int ec100_read_status(struct dvb_frontend *fe, fe_status_t *status)
{
	struct ec100_state *state = fe->demodulator_priv;
	int ret;
	u8 tmp;
	*status = 0;

	ret = ec100_read_reg(state, 0x42, &tmp);
	if (ret)
		goto error;

	if (tmp & 0x80) {
		/* bit7 set - have lock */
		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
			FE_HAS_SYNC | FE_HAS_LOCK;
	} else {
		ret = ec100_read_reg(state, 0x01, &tmp);
		if (ret)
			goto error;

		if (tmp & 0x10) {
			/* bit4 set - have signal */
			*status |= FE_HAS_SIGNAL;
			if (!(tmp & 0x01)) {
				/* bit0 clear - have ~valid signal */
				*status |= FE_HAS_CARRIER |  FE_HAS_VITERBI;
			}
		}
	}

	return ret;
error:
	deb_info("%s: failed:%d\n", __func__, ret);
	return ret;
}

static int ec100_read_ber(struct dvb_frontend *fe, u32 *ber)
{
	struct ec100_state *state = fe->demodulator_priv;
	int ret;
	u8 tmp, tmp2;
	u16 ber2;

	*ber = 0;

	ret = ec100_read_reg(state, 0x65, &tmp);
	if (ret)
		goto error;
	ret = ec100_read_reg(state, 0x66, &tmp2);
	if (ret)
		goto error;

	ber2 = (tmp2 << 8) | tmp;

	/* if counter overflow or clear */
	if (ber2 < state->ber)
		*ber = ber2;
	else
		*ber = ber2 - state->ber;

	state->ber = ber2;

	return ret;
error:
	deb_info("%s: failed:%d\n", __func__, ret);
	return ret;
}

static int ec100_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
{
	struct ec100_state *state = fe->demodulator_priv;
	int ret;
	u8 tmp;

	ret = ec100_read_reg(state, 0x24, &tmp);
	if (ret) {
		*strength = 0;
		goto error;
	}

	*strength = ((tmp << 8) | tmp);

	return ret;
error:
	deb_info("%s: failed:%d\n", __func__, ret);
	return ret;
}

static int ec100_read_snr(struct dvb_frontend *fe, u16 *snr)
{
	*snr = 0;
	return 0;
}

static int ec100_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
{
	*ucblocks = 0;
	return 0;
}

static void ec100_release(struct dvb_frontend *fe)
{
	struct ec100_state *state = fe->demodulator_priv;
	kfree(state);
}

static struct dvb_frontend_ops ec100_ops;

struct dvb_frontend *ec100_attach(const struct ec100_config *config,
	struct i2c_adapter *i2c)
{
	int ret;
	struct ec100_state *state = NULL;
	u8 tmp;

	/* allocate memory for the internal state */
	state = kzalloc(sizeof(struct ec100_state), GFP_KERNEL);
	if (state == NULL)
		goto error;

	/* setup the state */
	state->i2c = i2c;
	memcpy(&state->config, config, sizeof(struct ec100_config));

	/* check if the demod is there */
	ret = ec100_read_reg(state, 0x33, &tmp);
	if (ret || tmp != 0x0b)
		goto error;

	/* create dvb_frontend */
	memcpy(&state->frontend.ops, &ec100_ops,
		sizeof(struct dvb_frontend_ops));
	state->frontend.demodulator_priv = state;

	return &state->frontend;
error:
	kfree(state);
	return NULL;
}
EXPORT_SYMBOL(ec100_attach);

static struct dvb_frontend_ops ec100_ops = {
	.info = {
		.name = "E3C EC100 DVB-T",
		.type = FE_OFDM,
		.caps =
			FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
			FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
			FE_CAN_QPSK | FE_CAN_QAM_16 |
			FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
			FE_CAN_TRANSMISSION_MODE_AUTO |
			FE_CAN_GUARD_INTERVAL_AUTO |
			FE_CAN_HIERARCHY_AUTO |
			FE_CAN_MUTE_TS
	},

	.release = ec100_release,
	.set_frontend = ec100_set_frontend,
	.get_tune_settings = ec100_get_tune_settings,
	.read_status = ec100_read_status,
	.read_ber = ec100_read_ber,
	.read_signal_strength = ec100_read_signal_strength,
	.read_snr = ec100_read_snr,
	.read_ucblocks = ec100_read_ucblocks,
};

MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
MODULE_DESCRIPTION("E3C EC100 DVB-T demodulator driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
a15c7b42 AP	1	/*
	2	* E3C EC100 demodulator driver
	3	*
	4	* Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
	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	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*
	20	*/
	21
	22	#include "dvb_frontend.h"
	23	#include "ec100_priv.h"
	24	#include "ec100.h"
	25
	26	int ec100_debug;
	27	module_param_named(debug, ec100_debug, int, 0644);
	28	MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
	29
	30	struct ec100_state {
	31	struct i2c_adapter *i2c;
	32	struct dvb_frontend frontend;
	33	struct ec100_config config;
	34
	35	u16 ber;
	36	};
	37
	38	/* write single register */
	39	static int ec100_write_reg(struct ec100_state *state, u8 reg, u8 val)
	40	{
	41	u8 buf[2] = {reg, val};
	42	struct i2c_msg msg = {
	43	.addr = state->config.demod_address,
	44	.flags = 0,
	45	.len = 2,
	46	.buf = buf};
	47
	48	if (i2c_transfer(state->i2c, &msg, 1) != 1) {
	49	warn("I2C write failed reg:%02x", reg);
	50	return -EREMOTEIO;
	51	}
	52	return 0;
	53	}
	54
	55	/* read single register */
	56	static int ec100_read_reg(struct ec100_state state, u8 reg, u8 val)
	57	{
	58	struct i2c_msg msg[2] = {
	59	{
	60	.addr = state->config.demod_address,
	61	.flags = 0,
	62	.len = 1,
	63	.buf = &reg
	64	}, {
65	.addr = state->config.demod_address,
66	.flags = I2C_M_RD,
67	.len = 1,
68	.buf = val
69	}
70	};
71
72	if (i2c_transfer(state->i2c, msg, 2) != 2) {
73	warn("I2C read failed reg:%02x", reg);
74	return -EREMOTEIO;
75	}
76	return 0;
77	}
78
79	static int ec100_set_frontend(struct dvb_frontend *fe,
80	struct dvb_frontend_parameters *params)
81	{
82	struct ec100_state *state = fe->demodulator_priv;
83	int ret;
84	u8 tmp, tmp2;
85
86	deb_info("%s: freq:%d bw:%d\n", __func__, params->frequency,
87	params->u.ofdm.bandwidth);
88
89	/* program tuner */
90	if (fe->ops.tuner_ops.set_params)
91	fe->ops.tuner_ops.set_params(fe, params);
92
93	ret = ec100_write_reg(state, 0x04, 0x06);
94	if (ret)
95	goto error;
96	ret = ec100_write_reg(state, 0x67, 0x58);
97	if (ret)
98	goto error;
99	ret = ec100_write_reg(state, 0x05, 0x18);
100	if (ret)
101	goto error;
102
103	/* reg/bw \| 6 \| 7 \| 8
104	-------+------+------+------
105	A 0x1b \| 0xa1 \| 0xe7 \| 0x2c
106	A 0x1c \| 0x55 \| 0x63 \| 0x72
107	-------+------+------+------
108	B 0x1b \| 0xb7 \| 0x00 \| 0x49
109	B 0x1c \| 0x55 \| 0x64 \| 0x72 */
110
111	switch (params->u.ofdm.bandwidth) {
112	case BANDWIDTH_6_MHZ:
113	tmp = 0xb7;
114	tmp2 = 0x55;
115	break;
116	case BANDWIDTH_7_MHZ:
117	tmp = 0x00;
118	tmp2 = 0x64;
119	break;
120	case BANDWIDTH_8_MHZ:
121	default:
122	tmp = 0x49;
123	tmp2 = 0x72;
124	}
125
126	ret = ec100_write_reg(state, 0x1b, tmp);
127	if (ret)
128	goto error;
129	ret = ec100_write_reg(state, 0x1c, tmp2);
130	if (ret)
131	goto error;
132
133	ret = ec100_write_reg(state, 0x0c, 0xbb); /* if freq */
134	if (ret)
135	goto error;
136	ret = ec100_write_reg(state, 0x0d, 0x31); /* if freq */
137	if (ret)
138	goto error;
139
140	ret = ec100_write_reg(state, 0x08, 0x24);
141	if (ret)
142	goto error;
143
144	ret = ec100_write_reg(state, 0x00, 0x00); /* go */
145	if (ret)
146	goto error;
147	ret = ec100_write_reg(state, 0x00, 0x20); /* go */
148	if (ret)
149	goto error;
150
151	return ret;
152	error:
153	deb_info("%s: failed:%d\n", __func__, ret);
154	return ret;
155	}
156
157	static int ec100_get_tune_settings(struct dvb_frontend *fe,
158	struct dvb_frontend_tune_settings *fesettings)
159	{
160	fesettings->min_delay_ms = 300;
161	fesettings->step_size = 0;
162	fesettings->max_drift = 0;
163
164	return 0;
165	}
166
167	static int ec100_read_status(struct dvb_frontend fe, fe_status_t status)
168	{
169	struct ec100_state *state = fe->demodulator_priv;
170	int ret;
171	u8 tmp;
172	*status = 0;
173
174	ret = ec100_read_reg(state, 0x42, &tmp);
175	if (ret)
176	goto error;
177
178	if (tmp & 0x80) {
179	/* bit7 set - have lock */
180	*status \|= FE_HAS_SIGNAL \| FE_HAS_CARRIER \| FE_HAS_VITERBI \|
181	FE_HAS_SYNC \| FE_HAS_LOCK;
182	} else {
183	ret = ec100_read_reg(state, 0x01, &tmp);
184	if (ret)
185	goto error;
186
187	if (tmp & 0x10) {
188	/* bit4 set - have signal */
189	*status \|= FE_HAS_SIGNAL;
190	if (!(tmp & 0x01)) {
191	/* bit0 clear - have ~valid signal */
192	*status \|= FE_HAS_CARRIER \| FE_HAS_VITERBI;
193	}
194	}
195	}
196
197	return ret;
198	error:
199	deb_info("%s: failed:%d\n", __func__, ret);
200	return ret;
201	}
202
203	static int ec100_read_ber(struct dvb_frontend fe, u32 ber)
204	{
205	struct ec100_state *state = fe->demodulator_priv;
206	int ret;
207	u8 tmp, tmp2;
208	u16 ber2;
209
210	*ber = 0;
211
212	ret = ec100_read_reg(state, 0x65, &tmp);
213	if (ret)
214	goto error;
215	ret = ec100_read_reg(state, 0x66, &tmp2);
216	if (ret)
217	goto error;
218
219	ber2 = (tmp2 << 8) \| tmp;
220
221	/* if counter overflow or clear */
222	if (ber2 < state->ber)
223	*ber = ber2;
224	else
225	*ber = ber2 - state->ber;
226
227	state->ber = ber2;
228
229	return ret;
230	error:
231	deb_info("%s: failed:%d\n", __func__, ret);
232	return ret;
233	}
234
235	static int ec100_read_signal_strength(struct dvb_frontend fe, u16 strength)
236	{
237	struct ec100_state *state = fe->demodulator_priv;
238	int ret;
239	u8 tmp;
240
241	ret = ec100_read_reg(state, 0x24, &tmp);
242	if (ret) {
243	*strength = 0;
244	goto error;
245	}
246
247	*strength = ((tmp << 8) \| tmp);
248
249	return ret;
250	error:
251	deb_info("%s: failed:%d\n", __func__, ret);
252	return ret;
253	}
254
255	static int ec100_read_snr(struct dvb_frontend fe, u16 snr)
256	{
257	*snr = 0;
258	return 0;
259	}
260
261	static int ec100_read_ucblocks(struct dvb_frontend fe, u32 ucblocks)
262	{
263	*ucblocks = 0;
264	return 0;
265	}
266
267	static void ec100_release(struct dvb_frontend *fe)
268	{
269	struct ec100_state *state = fe->demodulator_priv;
270	kfree(state);
271	}
272
273	static struct dvb_frontend_ops ec100_ops;
274
275	struct dvb_frontend ec100_attach(const struct ec100_config config,
276	struct i2c_adapter *i2c)
277	{
278	int ret;
279	struct ec100_state *state = NULL;
280	u8 tmp;
281
282	/* allocate memory for the internal state */
283	state = kzalloc(sizeof(struct ec100_state), GFP_KERNEL);
284	if (state == NULL)
285	goto error;
286
287	/* setup the state */
288	state->i2c = i2c;
289	memcpy(&state->config, config, sizeof(struct ec100_config));
290
291	/* check if the demod is there */
292	ret = ec100_read_reg(state, 0x33, &tmp);
293	if (ret \|\| tmp != 0x0b)
294	goto error;
295
296	/* create dvb_frontend */
297	memcpy(&state->frontend.ops, &ec100_ops,
298	sizeof(struct dvb_frontend_ops));
299	state->frontend.demodulator_priv = state;
300
301	return &state->frontend;
302	error:
303	kfree(state);
304	return NULL;
305	}
306	EXPORT_SYMBOL(ec100_attach);
307
308	static struct dvb_frontend_ops ec100_ops = {
309	.info = {
310	.name = "E3C EC100 DVB-T",
311	.type = FE_OFDM,
312	.caps =
313	FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
314	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|
315	FE_CAN_QPSK \| FE_CAN_QAM_16 \|
316	FE_CAN_QAM_64 \| FE_CAN_QAM_AUTO \|
317	FE_CAN_TRANSMISSION_MODE_AUTO \|
318	FE_CAN_GUARD_INTERVAL_AUTO \|
319	FE_CAN_HIERARCHY_AUTO \|
320	FE_CAN_MUTE_TS
321	},
322
323	.release = ec100_release,
324	.set_frontend = ec100_set_frontend,
325	.get_tune_settings = ec100_get_tune_settings,
326	.read_status = ec100_read_status,
327	.read_ber = ec100_read_ber,
328	.read_signal_strength = ec100_read_signal_strength,
329	.read_snr = ec100_read_snr,
330	.read_ucblocks = ec100_read_ucblocks,
331	};
332
333	MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
334	MODULE_DESCRIPTION("E3C EC100 DVB-T demodulator driver");
335	MODULE_LICENSE("GPL");