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

/*
	Driver for ST STV0288 demodulator
	Copyright (C) 2006 Georg Acher, BayCom GmbH, acher (at) baycom (dot) de
		for Reel Multimedia
	Copyright (C) 2008 TurboSight.com, Bob Liu <bob@turbosight.com>
	Copyright (C) 2008 Igor M. Liplianin <liplianin@me.by>
		Removed stb6000 specific tuner code and revised some
		procedures.
	2010-09-01 Josef Pavlik <josef@pavlik.it>
		Fixed diseqc_msg, diseqc_burst and set_tone problems

	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/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <asm/div64.h>

#include "dvb_frontend.h"
#include "stv0288.h"

struct stv0288_state {
	struct i2c_adapter *i2c;
	const struct stv0288_config *config;
	struct dvb_frontend frontend;

	u8 initialised:1;
	u32 tuner_frequency;
	u32 symbol_rate;
	fe_code_rate_t fec_inner;
	int errmode;
};

#define STATUS_BER 0
#define STATUS_UCBLOCKS 1

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


static int stv0288_writeregI(struct stv0288_state *state, u8 reg, u8 data)
{
	int ret;
	u8 buf[] = { reg, data };
	struct i2c_msg msg = {
		.addr = state->config->demod_address,
		.flags = 0,
		.buf = buf,
		.len = 2
	};

	ret = i2c_transfer(state->i2c, &msg, 1);

	if (ret != 1)
		dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
			"ret == %i)\n", __func__, reg, data, ret);

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

static int stv0288_write(struct dvb_frontend *fe, const u8 buf[], int len)
{
	struct stv0288_state *state = fe->demodulator_priv;

	if (len != 2)
		return -EINVAL;

	return stv0288_writeregI(state, buf[0], buf[1]);
}

static u8 stv0288_readreg(struct stv0288_state *state, u8 reg)
{
	int ret;
	u8 b0[] = { reg };
	u8 b1[] = { 0 };
	struct i2c_msg msg[] = {
		{
			.addr = state->config->demod_address,
			.flags = 0,
			.buf = b0,
			.len = 1
		}, {
			.addr = state->config->demod_address,
			.flags = I2C_M_RD,
			.buf = b1,
			.len = 1
		}
	};

	ret = i2c_transfer(state->i2c, msg, 2);

	if (ret != 2)
		dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n",
				__func__, reg, ret);

	return b1[0];
}

static int stv0288_set_symbolrate(struct dvb_frontend *fe, u32 srate)
{
	struct stv0288_state *state = fe->demodulator_priv;
	unsigned int temp;
	unsigned char b[3];

	if ((srate < 1000000) || (srate > 45000000))
		return -EINVAL;

	temp = (unsigned int)srate / 1000;

		temp = temp * 32768;
		temp = temp / 25;
		temp = temp / 125;
		b[0] = (unsigned char)((temp >> 12) & 0xff);
		b[1] = (unsigned char)((temp >> 4) & 0xff);
		b[2] = (unsigned char)((temp << 4) & 0xf0);
		stv0288_writeregI(state, 0x28, 0x80); /* SFRH */
		stv0288_writeregI(state, 0x29, 0); /* SFRM */
		stv0288_writeregI(state, 0x2a, 0); /* SFRL */

		stv0288_writeregI(state, 0x28, b[0]);
		stv0288_writeregI(state, 0x29, b[1]);
		stv0288_writeregI(state, 0x2a, b[2]);
		dprintk("stv0288: stv0288_set_symbolrate\n");

	return 0;
}

static int stv0288_send_diseqc_msg(struct dvb_frontend *fe,
				    struct dvb_diseqc_master_cmd *m)
{
	struct stv0288_state *state = fe->demodulator_priv;

	int i;

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

	stv0288_writeregI(state, 0x09, 0);
	msleep(30);
	stv0288_writeregI(state, 0x05, 0x12);/* modulated mode, single shot */

	for (i = 0; i < m->msg_len; i++) {
		if (stv0288_writeregI(state, 0x06, m->msg[i]))
			return -EREMOTEIO;
	}
	msleep(m->msg_len*12);
	return 0;
}

static int stv0288_send_diseqc_burst(struct dvb_frontend *fe,
						fe_sec_mini_cmd_t burst)
{
	struct stv0288_state *state = fe->demodulator_priv;

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

	if (stv0288_writeregI(state, 0x05, 0x03))/* burst mode, single shot */
		return -EREMOTEIO;

	if (stv0288_writeregI(state, 0x06, burst == SEC_MINI_A ? 0x00 : 0xff))
		return -EREMOTEIO;

	msleep(15);
	if (stv0288_writeregI(state, 0x05, 0x12))
		return -EREMOTEIO;

	return 0;
}

static int stv0288_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
{
	struct stv0288_state *state = fe->demodulator_priv;

	switch (tone) {
	case SEC_TONE_ON:
		if (stv0288_writeregI(state, 0x05, 0x10))/* cont carrier */
			return -EREMOTEIO;
	break;

	case SEC_TONE_OFF:
		if (stv0288_writeregI(state, 0x05, 0x12))/* burst mode off*/
			return -EREMOTEIO;
	break;

	default:
		return -EINVAL;
	}
	return 0;
}

static u8 stv0288_inittab[] = {
	0x01, 0x15,
	0x02, 0x20,
	0x09, 0x0,
	0x0a, 0x4,
	0x0b, 0x0,
	0x0c, 0x0,
	0x0d, 0x0,
	0x0e, 0xd4,
	0x0f, 0x30,
	0x11, 0x80,
	0x12, 0x03,
	0x13, 0x48,
	0x14, 0x84,
	0x15, 0x45,
	0x16, 0xb7,
	0x17, 0x9c,
	0x18, 0x0,
	0x19, 0xa6,
	0x1a, 0x88,
	0x1b, 0x8f,
	0x1c, 0xf0,
	0x20, 0x0b,
	0x21, 0x54,
	0x22, 0x0,
	0x23, 0x0,
	0x2b, 0xff,
	0x2c, 0xf7,
	0x30, 0x0,
	0x31, 0x1e,
	0x32, 0x14,
	0x33, 0x0f,
	0x34, 0x09,
	0x35, 0x0c,
	0x36, 0x05,
	0x37, 0x2f,
	0x38, 0x16,
	0x39, 0xbe,
	0x3a, 0x0,
	0x3b, 0x13,
	0x3c, 0x11,
	0x3d, 0x30,
	0x40, 0x63,
	0x41, 0x04,
	0x42, 0x60,
	0x43, 0x00,
	0x44, 0x00,
	0x45, 0x00,
	0x46, 0x00,
	0x47, 0x00,
	0x4a, 0x00,
	0x50, 0x10,
	0x51, 0x38,
	0x52, 0x21,
	0x58, 0x54,
	0x59, 0x86,
	0x5a, 0x0,
	0x5b, 0x9b,
	0x5c, 0x08,
	0x5d, 0x7f,
	0x5e, 0x0,
	0x5f, 0xff,
	0x70, 0x0,
	0x71, 0x0,
	0x72, 0x0,
	0x74, 0x0,
	0x75, 0x0,
	0x76, 0x0,
	0x81, 0x0,
	0x82, 0x3f,
	0x83, 0x3f,
	0x84, 0x0,
	0x85, 0x0,
	0x88, 0x0,
	0x89, 0x0,
	0x8a, 0x0,
	0x8b, 0x0,
	0x8c, 0x0,
	0x90, 0x0,
	0x91, 0x0,
	0x92, 0x0,
	0x93, 0x0,
	0x94, 0x1c,
	0x97, 0x0,
	0xa0, 0x48,
	0xa1, 0x0,
	0xb0, 0xb8,
	0xb1, 0x3a,
	0xb2, 0x10,
	0xb3, 0x82,
	0xb4, 0x80,
	0xb5, 0x82,
	0xb6, 0x82,
	0xb7, 0x82,
	0xb8, 0x20,
	0xb9, 0x0,
	0xf0, 0x0,
	0xf1, 0x0,
	0xf2, 0xc0,
	0x51, 0x36,
	0x52, 0x09,
	0x53, 0x94,
	0x54, 0x62,
	0x55, 0x29,
	0x56, 0x64,
	0x57, 0x2b,
	0xff, 0xff,
};

static int stv0288_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t volt)
{
	dprintk("%s: %s\n", __func__,
		volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
		volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");

	return 0;
}

static int stv0288_init(struct dvb_frontend *fe)
{
	struct stv0288_state *state = fe->demodulator_priv;
	int i;
	u8 reg;
	u8 val;

	dprintk("stv0288: init chip\n");
	stv0288_writeregI(state, 0x41, 0x04);
	msleep(50);

	/* we have default inittab */
	if (state->config->inittab == NULL) {
		for (i = 0; !(stv0288_inittab[i] == 0xff &&
				stv0288_inittab[i + 1] == 0xff); i += 2)
			stv0288_writeregI(state, stv0288_inittab[i],
					stv0288_inittab[i + 1]);
	} else {
		for (i = 0; ; i += 2)  {
			reg = state->config->inittab[i];
			val = state->config->inittab[i+1];
			if (reg == 0xff && val == 0xff)
				break;
			stv0288_writeregI(state, reg, val);
		}
	}
	return 0;
}

static int stv0288_read_status(struct dvb_frontend *fe, fe_status_t *status)
{
	struct stv0288_state *state = fe->demodulator_priv;

	u8 sync = stv0288_readreg(state, 0x24);
	if (sync == 255)
		sync = 0;

	dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);

	*status = 0;
	if (sync & 0x80)
		*status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
	if (sync & 0x10)
		*status |= FE_HAS_VITERBI;
	if (sync & 0x08) {
		*status |= FE_HAS_LOCK;
		dprintk("stv0288 has locked\n");
	}

	return 0;
}

static int stv0288_read_ber(struct dvb_frontend *fe, u32 *ber)
{
	struct stv0288_state *state = fe->demodulator_priv;

	if (state->errmode != STATUS_BER)
		return 0;
	*ber = (stv0288_readreg(state, 0x26) << 8) |
					stv0288_readreg(state, 0x27);
	dprintk("stv0288_read_ber %d\n", *ber);

	return 0;
}


static int stv0288_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
{
	struct stv0288_state *state = fe->demodulator_priv;

	s32 signal =  0xffff - ((stv0288_readreg(state, 0x10) << 8));


	signal = signal * 5 / 4;
	*strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal;
	dprintk("stv0288_read_signal_strength %d\n", *strength);

	return 0;
}
static int stv0288_sleep(struct dvb_frontend *fe)
{
	struct stv0288_state *state = fe->demodulator_priv;

	stv0288_writeregI(state, 0x41, 0x84);
	state->initialised = 0;

	return 0;
}
static int stv0288_read_snr(struct dvb_frontend *fe, u16 *snr)
{
	struct stv0288_state *state = fe->demodulator_priv;

	s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8)
			   | stv0288_readreg(state, 0x2e));
	xsnr = 3 * (xsnr - 0xa100);
	*snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr;
	dprintk("stv0288_read_snr %d\n", *snr);

	return 0;
}

static int stv0288_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
{
	struct stv0288_state *state = fe->demodulator_priv;

	if (state->errmode != STATUS_BER)
		return 0;
	*ucblocks = (stv0288_readreg(state, 0x26) << 8) |
					stv0288_readreg(state, 0x27);
	dprintk("stv0288_read_ber %d\n", *ucblocks);

	return 0;
}

static int stv0288_set_property(struct dvb_frontend *fe, struct dtv_property *p)
{
	dprintk("%s(..)\n", __func__);
	return 0;
}

static int stv0288_get_property(struct dvb_frontend *fe, struct dtv_property *p)
{
	dprintk("%s(..)\n", __func__);
	return 0;
}

static int stv0288_set_frontend(struct dvb_frontend *fe,
					struct dvb_frontend_parameters *dfp)
{
	struct stv0288_state *state = fe->demodulator_priv;
	struct dtv_frontend_properties *c = &fe->dtv_property_cache;

	char tm;
	unsigned char tda[3];

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

	if (c->delivery_system != SYS_DVBS) {
			dprintk("%s: unsupported delivery "
				"system selected (%d)\n",
				__func__, c->delivery_system);
			return -EOPNOTSUPP;
	}

	if (state->config->set_ts_params)
		state->config->set_ts_params(fe, 0);

	/* only frequency & symbol_rate are used for tuner*/
	dfp->frequency = c->frequency;
	dfp->u.qpsk.symbol_rate = c->symbol_rate;
	if (fe->ops.tuner_ops.set_params) {
		fe->ops.tuner_ops.set_params(fe, dfp);
		if (fe->ops.i2c_gate_ctrl)
			fe->ops.i2c_gate_ctrl(fe, 0);
	}

	udelay(10);
	stv0288_set_symbolrate(fe, c->symbol_rate);
	/* Carrier lock control register */
	stv0288_writeregI(state, 0x15, 0xc5);

	tda[0] = 0x2b; /* CFRM */
	tda[2] = 0x0; /* CFRL */
	for (tm = -6; tm < 7;) {
		/* Viterbi status */
		if (stv0288_readreg(state, 0x24) & 0x8)
			break;

		tda[2] += 40;
		if (tda[2] < 40)
			tm++;
		tda[1] = (unsigned char)tm;
		stv0288_writeregI(state, 0x2b, tda[1]);
		stv0288_writeregI(state, 0x2c, tda[2]);
		udelay(30);
	}

	state->tuner_frequency = c->frequency;
	state->fec_inner = FEC_AUTO;
	state->symbol_rate = c->symbol_rate;

	return 0;
}

static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
{
	struct stv0288_state *state = fe->demodulator_priv;

	if (enable)
		stv0288_writeregI(state, 0x01, 0xb5);
	else
		stv0288_writeregI(state, 0x01, 0x35);

	udelay(1);

	return 0;
}

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

static struct dvb_frontend_ops stv0288_ops = {

	.info = {
		.name			= "ST STV0288 DVB-S",
		.type			= FE_QPSK,
		.frequency_min		= 950000,
		.frequency_max		= 2150000,
		.frequency_stepsize	= 1000,	 /* kHz for QPSK frontends */
		.frequency_tolerance	= 0,
		.symbol_rate_min	= 1000000,
		.symbol_rate_max	= 45000000,
		.symbol_rate_tolerance	= 500,	/* ppm */
		.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_QPSK |
		      FE_CAN_FEC_AUTO
	},

	.release = stv0288_release,
	.init = stv0288_init,
	.sleep = stv0288_sleep,
	.write = stv0288_write,
	.i2c_gate_ctrl = stv0288_i2c_gate_ctrl,
	.read_status = stv0288_read_status,
	.read_ber = stv0288_read_ber,
	.read_signal_strength = stv0288_read_signal_strength,
	.read_snr = stv0288_read_snr,
	.read_ucblocks = stv0288_read_ucblocks,
	.diseqc_send_master_cmd = stv0288_send_diseqc_msg,
	.diseqc_send_burst = stv0288_send_diseqc_burst,
	.set_tone = stv0288_set_tone,
	.set_voltage = stv0288_set_voltage,

	.set_property = stv0288_set_property,
	.get_property = stv0288_get_property,
	.set_frontend = stv0288_set_frontend,
};

struct dvb_frontend *stv0288_attach(const struct stv0288_config *config,
				    struct i2c_adapter *i2c)
{
	struct stv0288_state *state = NULL;
	int id;

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

	/* setup the state */
	state->config = config;
	state->i2c = i2c;
	state->initialised = 0;
	state->tuner_frequency = 0;
	state->symbol_rate = 0;
	state->fec_inner = 0;
	state->errmode = STATUS_BER;

	stv0288_writeregI(state, 0x41, 0x04);
	msleep(200);
	id = stv0288_readreg(state, 0x00);
	dprintk("stv0288 id %x\n", id);

	/* register 0x00 contains 0x11 for STV0288  */
	if (id != 0x11)
		goto error;

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

error:
	kfree(state);

	return NULL;
}
EXPORT_SYMBOL(stv0288_attach);

module_param(debug_legacy_dish_switch, int, 0444);
MODULE_PARM_DESC(debug_legacy_dish_switch,
		"Enable timing analysis for Dish Network legacy switches");

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

MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver");
MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin");
MODULE_LICENSE("GPL");
Commit	Line	Data
e4aab64c IL	1	/*
	2	Driver for ST STV0288 demodulator
	3	Copyright (C) 2006 Georg Acher, BayCom GmbH, acher (at) baycom (dot) de
	4	for Reel Multimedia
	5	Copyright (C) 2008 TurboSight.com, Bob Liu <bob@turbosight.com>
	6	Copyright (C) 2008 Igor M. Liplianin <liplianin@me.by>
	7	Removed stb6000 specific tuner code and revised some
	8	procedures.
352a587c MP	9	2010-09-01 Josef Pavlik <josef@pavlik.it>
352a587c MP	10	Fixed diseqc_msg, diseqc_burst and set_tone problems
e4aab64c IL	11
	12	This program is free software; you can redistribute it and/or modify
	13	it under the terms of the GNU General Public License as published by
	14	the Free Software Foundation; either version 2 of the License, or
	15	(at your option) any later version.
	16
	17	This program is distributed in the hope that it will be useful,
	18	but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	GNU General Public License for more details.
	21
	22	You should have received a copy of the GNU General Public License
	23	along with this program; if not, write to the Free Software
	24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	25
	26	*/
	27
	28	#include <linux/init.h>
	29	#include <linux/kernel.h>
	30	#include <linux/module.h>
	31	#include <linux/string.h>
	32	#include <linux/slab.h>
	33	#include <linux/jiffies.h>
	34	#include <asm/div64.h>
	35
	36	#include "dvb_frontend.h"
	37	#include "stv0288.h"
	38
	39	struct stv0288_state {
	40	struct i2c_adapter *i2c;
	41	const struct stv0288_config *config;
	42	struct dvb_frontend frontend;
	43
	44	u8 initialised:1;
	45	u32 tuner_frequency;
	46	u32 symbol_rate;
	47	fe_code_rate_t fec_inner;
	48	int errmode;
	49	};
	50
	51	#define STATUS_BER 0
	52	#define STATUS_UCBLOCKS 1
	53
	54	static int debug;
	55	static int debug_legacy_dish_switch;
	56	#define dprintk(args...) \
	57	do { \
	58	if (debug) \
	59	printk(KERN_DEBUG "stv0288: " args); \
	60	} while (0)
	61
	62
	63	static int stv0288_writeregI(struct stv0288_state *state, u8 reg, u8 data)
	64	{
	65	int ret;
	66	u8 buf[] = { reg, data };
	67	struct i2c_msg msg = {
	68	.addr = state->config->demod_address,
	69	.flags = 0,
	70	.buf = buf,
	71	.len = 2
	72	};
	73
	74	ret = i2c_transfer(state->i2c, &msg, 1);
75
76	if (ret != 1)
77	dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
78	"ret == %i)\n", __func__, reg, data, ret);
79
80	return (ret != 1) ? -EREMOTEIO : 0;
81	}
82
2e4e98e7	83	static int stv0288_write(struct dvb_frontend *fe, const u8 buf[], int len)
e4aab64c IL	84	{
	85	struct stv0288_state *state = fe->demodulator_priv;
	86
	87	if (len != 2)
	88	return -EINVAL;
	89
	90	return stv0288_writeregI(state, buf[0], buf[1]);
	91	}
	92
	93	static u8 stv0288_readreg(struct stv0288_state *state, u8 reg)
	94	{
	95	int ret;
	96	u8 b0[] = { reg };
	97	u8 b1[] = { 0 };
	98	struct i2c_msg msg[] = {
	99	{
	100	.addr = state->config->demod_address,
	101	.flags = 0,
	102	.buf = b0,
	103	.len = 1
	104	}, {
	105	.addr = state->config->demod_address,
	106	.flags = I2C_M_RD,
	107	.buf = b1,
	108	.len = 1
	109	}
	110	};
	111
	112	ret = i2c_transfer(state->i2c, msg, 2);
	113
	114	if (ret != 2)
	115	dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n",
	116	__func__, reg, ret);
	117
	118	return b1[0];
	119	}
	120
	121	static int stv0288_set_symbolrate(struct dvb_frontend *fe, u32 srate)
	122	{
	123	struct stv0288_state *state = fe->demodulator_priv;
	124	unsigned int temp;
	125	unsigned char b[3];
	126
	127	if ((srate < 1000000) \|\| (srate > 45000000))
	128	return -EINVAL;
	129
	130	temp = (unsigned int)srate / 1000;
	131
	132	temp = temp * 32768;
	133	temp = temp / 25;
	134	temp = temp / 125;
	135	b[0] = (unsigned char)((temp >> 12) & 0xff);
	136	b[1] = (unsigned char)((temp >> 4) & 0xff);
	137	b[2] = (unsigned char)((temp << 4) & 0xf0);
	138	stv0288_writeregI(state, 0x28, 0x80); /* SFRH */
	139	stv0288_writeregI(state, 0x29, 0); /* SFRM */
	140	stv0288_writeregI(state, 0x2a, 0); /* SFRL */
	141
	142	stv0288_writeregI(state, 0x28, b[0]);
	143	stv0288_writeregI(state, 0x29, b[1]);
	144	stv0288_writeregI(state, 0x2a, b[2]);
	145	dprintk("stv0288: stv0288_set_symbolrate\n");
	146
	147	return 0;
148	}
149
150	static int stv0288_send_diseqc_msg(struct dvb_frontend *fe,
151	struct dvb_diseqc_master_cmd *m)
152	{
153	struct stv0288_state *state = fe->demodulator_priv;
154
155	int i;
156
157	dprintk("%s\n", __func__);
158
159	stv0288_writeregI(state, 0x09, 0);
160	msleep(30);
352a587c	161	stv0288_writeregI(state, 0x05, 0x12);/* modulated mode, single shot */
e4aab64c IL	162
	163	for (i = 0; i < m->msg_len; i++) {
	164	if (stv0288_writeregI(state, 0x06, m->msg[i]))
	165	return -EREMOTEIO;
e4aab64c	166	}
352a587c	167	msleep(m->msg_len*12);
e4aab64c IL	168	return 0;
	169	}
	170
	171	static int stv0288_send_diseqc_burst(struct dvb_frontend *fe,
	172	fe_sec_mini_cmd_t burst)
	173	{
	174	struct stv0288_state *state = fe->demodulator_priv;
	175
	176	dprintk("%s\n", __func__);
	177
352a587c	178	if (stv0288_writeregI(state, 0x05, 0x03))/* burst mode, single shot */
e4aab64c IL	179	return -EREMOTEIO;
	180
	181	if (stv0288_writeregI(state, 0x06, burst == SEC_MINI_A ? 0x00 : 0xff))
	182	return -EREMOTEIO;
	183
352a587c MP	184	msleep(15);
352a587c MP	185	if (stv0288_writeregI(state, 0x05, 0x12))
e4aab64c IL	186	return -EREMOTEIO;
	187
	188	return 0;
	189	}
	190
	191	static int stv0288_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
	192	{
	193	struct stv0288_state *state = fe->demodulator_priv;
	194
	195	switch (tone) {
	196	case SEC_TONE_ON:
352a587c	197	if (stv0288_writeregI(state, 0x05, 0x10))/* cont carrier */
e4aab64c	198	return -EREMOTEIO;
352a587c	199	break;
e4aab64c IL	200
e4aab64c IL	201	case SEC_TONE_OFF:
352a587c	202	if (stv0288_writeregI(state, 0x05, 0x12))/* burst mode off*/
e4aab64c	203	return -EREMOTEIO;
352a587c	204	break;
e4aab64c IL	205
	206	default:
	207	return -EINVAL;
	208	}
352a587c	209	return 0;
e4aab64c IL	210	}
	211
	212	static u8 stv0288_inittab[] = {
	213	0x01, 0x15,
	214	0x02, 0x20,
	215	0x09, 0x0,
	216	0x0a, 0x4,
	217	0x0b, 0x0,
	218	0x0c, 0x0,
	219	0x0d, 0x0,
	220	0x0e, 0xd4,
	221	0x0f, 0x30,
	222	0x11, 0x80,
	223	0x12, 0x03,
	224	0x13, 0x48,
	225	0x14, 0x84,
	226	0x15, 0x45,
	227	0x16, 0xb7,
	228	0x17, 0x9c,
	229	0x18, 0x0,
	230	0x19, 0xa6,
	231	0x1a, 0x88,
	232	0x1b, 0x8f,
	233	0x1c, 0xf0,
	234	0x20, 0x0b,
	235	0x21, 0x54,
	236	0x22, 0x0,
	237	0x23, 0x0,
	238	0x2b, 0xff,
	239	0x2c, 0xf7,
	240	0x30, 0x0,
	241	0x31, 0x1e,
	242	0x32, 0x14,
	243	0x33, 0x0f,
	244	0x34, 0x09,
	245	0x35, 0x0c,
	246	0x36, 0x05,
	247	0x37, 0x2f,
	248	0x38, 0x16,
	249	0x39, 0xbe,
	250	0x3a, 0x0,
	251	0x3b, 0x13,
	252	0x3c, 0x11,
	253	0x3d, 0x30,
	254	0x40, 0x63,
	255	0x41, 0x04,
	256	0x42, 0x60,
	257	0x43, 0x00,
	258	0x44, 0x00,
	259	0x45, 0x00,
	260	0x46, 0x00,
	261	0x47, 0x00,
	262	0x4a, 0x00,
	263	0x50, 0x10,
	264	0x51, 0x38,
	265	0x52, 0x21,
	266	0x58, 0x54,
	267	0x59, 0x86,
	268	0x5a, 0x0,
	269	0x5b, 0x9b,
	270	0x5c, 0x08,
	271	0x5d, 0x7f,
	272	0x5e, 0x0,
	273	0x5f, 0xff,
274	0x70, 0x0,
275	0x71, 0x0,
276	0x72, 0x0,
277	0x74, 0x0,
278	0x75, 0x0,
279	0x76, 0x0,
280	0x81, 0x0,
281	0x82, 0x3f,
282	0x83, 0x3f,
283	0x84, 0x0,
284	0x85, 0x0,
285	0x88, 0x0,
286	0x89, 0x0,
287	0x8a, 0x0,
288	0x8b, 0x0,
289	0x8c, 0x0,
290	0x90, 0x0,
291	0x91, 0x0,
292	0x92, 0x0,
293	0x93, 0x0,
294	0x94, 0x1c,
295	0x97, 0x0,
296	0xa0, 0x48,
297	0xa1, 0x0,
298	0xb0, 0xb8,
299	0xb1, 0x3a,
300	0xb2, 0x10,
301	0xb3, 0x82,
302	0xb4, 0x80,
303	0xb5, 0x82,
304	0xb6, 0x82,
305	0xb7, 0x82,
306	0xb8, 0x20,
307	0xb9, 0x0,
308	0xf0, 0x0,
309	0xf1, 0x0,
310	0xf2, 0xc0,
311	0x51, 0x36,
312	0x52, 0x09,
313	0x53, 0x94,
314	0x54, 0x62,
315	0x55, 0x29,
316	0x56, 0x64,
317	0x57, 0x2b,
318	0xff, 0xff,
319	};
320
321	static int stv0288_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t volt)
322	{
323	dprintk("%s: %s\n", __func__,
324	volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
325	volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
326
327	return 0;
328	}
329
330	static int stv0288_init(struct dvb_frontend *fe)
331	{
332	struct stv0288_state *state = fe->demodulator_priv;
333	int i;
de9be0ea IL	334	u8 reg;
de9be0ea IL	335	u8 val;
e4aab64c IL	336
	337	dprintk("stv0288: init chip\n");
	338	stv0288_writeregI(state, 0x41, 0x04);
	339	msleep(50);
	340
de9be0ea IL	341	/* we have default inittab */
	342	if (state->config->inittab == NULL) {
	343	for (i = 0; !(stv0288_inittab[i] == 0xff &&
e4aab64c	344	stv0288_inittab[i + 1] == 0xff); i += 2)
de9be0ea IL	345	stv0288_writeregI(state, stv0288_inittab[i],
	346	stv0288_inittab[i + 1]);
	347	} else {
	348	for (i = 0; ; i += 2) {
	349	reg = state->config->inittab[i];
	350	val = state->config->inittab[i+1];
	351	if (reg == 0xff && val == 0xff)
	352	break;
	353	stv0288_writeregI(state, reg, val);
	354	}
	355	}
e4aab64c IL	356	return 0;
	357	}
	358
	359	static int stv0288_read_status(struct dvb_frontend fe, fe_status_t status)
	360	{
	361	struct stv0288_state *state = fe->demodulator_priv;
	362
	363	u8 sync = stv0288_readreg(state, 0x24);
	364	if (sync == 255)
	365	sync = 0;
	366
	367	dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);
	368
	369	*status = 0;
b50b3a1a MP	370	if (sync & 0x80)
	371	*status \|= FE_HAS_CARRIER \| FE_HAS_SIGNAL;
	372	if (sync & 0x10)
	373	*status \|= FE_HAS_VITERBI;
	374	if (sync & 0x08) {
e4aab64c IL	375	*status \|= FE_HAS_LOCK;
	376	dprintk("stv0288 has locked\n");
	377	}
	378
	379	return 0;
	380	}
	381
	382	static int stv0288_read_ber(struct dvb_frontend fe, u32 ber)
	383	{
	384	struct stv0288_state *state = fe->demodulator_priv;
	385
	386	if (state->errmode != STATUS_BER)
	387	return 0;
	388	*ber = (stv0288_readreg(state, 0x26) << 8) \|
	389	stv0288_readreg(state, 0x27);
	390	dprintk("stv0288_read_ber %d\n", *ber);
	391
	392	return 0;
	393	}
	394
	395
	396	static int stv0288_read_signal_strength(struct dvb_frontend fe, u16 strength)
	397	{
	398	struct stv0288_state *state = fe->demodulator_priv;
	399
	400	s32 signal = 0xffff - ((stv0288_readreg(state, 0x10) << 8));
	401
	402
	403	signal = signal * 5 / 4;
	404	*strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal;
	405	dprintk("stv0288_read_signal_strength %d\n", *strength);
	406
	407	return 0;
	408	}
	409	static int stv0288_sleep(struct dvb_frontend *fe)
	410	{
	411	struct stv0288_state *state = fe->demodulator_priv;
	412
	413	stv0288_writeregI(state, 0x41, 0x84);
	414	state->initialised = 0;
	415
	416	return 0;
	417	}
	418	static int stv0288_read_snr(struct dvb_frontend fe, u16 snr)
	419	{
	420	struct stv0288_state *state = fe->demodulator_priv;
	421
	422	s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8)
	423	\| stv0288_readreg(state, 0x2e));
	424	xsnr = 3 * (xsnr - 0xa100);
	425	*snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr;
	426	dprintk("stv0288_read_snr %d\n", *snr);
	427
	428	return 0;
	429	}
	430
	431	static int stv0288_read_ucblocks(struct dvb_frontend fe, u32 ucblocks)
	432	{
	433	struct stv0288_state *state = fe->demodulator_priv;
	434
	435	if (state->errmode != STATUS_BER)
	436	return 0;
	437	*ucblocks = (stv0288_readreg(state, 0x26) << 8) \|
	438	stv0288_readreg(state, 0x27);
439	dprintk("stv0288_read_ber %d\n", *ucblocks);
440
441	return 0;
442	}
443
444	static int stv0288_set_property(struct dvb_frontend fe, struct dtv_property p)
445	{
446	dprintk("%s(..)\n", __func__);
447	return 0;
448	}
449
450	static int stv0288_get_property(struct dvb_frontend fe, struct dtv_property p)
451	{
452	dprintk("%s(..)\n", __func__);
453	return 0;
454	}
455
456	static int stv0288_set_frontend(struct dvb_frontend *fe,
457	struct dvb_frontend_parameters *dfp)
458	{
459	struct stv0288_state *state = fe->demodulator_priv;
460	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
461
462	char tm;
463	unsigned char tda[3];
464
465	dprintk("%s : FE_SET_FRONTEND\n", __func__);
466
467	if (c->delivery_system != SYS_DVBS) {
468	dprintk("%s: unsupported delivery "
469	"system selected (%d)\n",
470	__func__, c->delivery_system);
471	return -EOPNOTSUPP;
472	}
473
474	if (state->config->set_ts_params)
475	state->config->set_ts_params(fe, 0);
476
477	/* only frequency & symbol_rate are used for tuner*/
478	dfp->frequency = c->frequency;
479	dfp->u.qpsk.symbol_rate = c->symbol_rate;
480	if (fe->ops.tuner_ops.set_params) {
481	fe->ops.tuner_ops.set_params(fe, dfp);
482	if (fe->ops.i2c_gate_ctrl)
483	fe->ops.i2c_gate_ctrl(fe, 0);
484	}
485
486	udelay(10);
487	stv0288_set_symbolrate(fe, c->symbol_rate);
488	/* Carrier lock control register */
489	stv0288_writeregI(state, 0x15, 0xc5);
490
491	tda[0] = 0x2b; /* CFRM */
492	tda[2] = 0x0; /* CFRL */
493	for (tm = -6; tm < 7;) {
494	/* Viterbi status */
be96624a	495	if (stv0288_readreg(state, 0x24) & 0x8)
e4aab64c IL	496	break;
	497
	498	tda[2] += 40;
	499	if (tda[2] < 40)
	500	tm++;
	501	tda[1] = (unsigned char)tm;
	502	stv0288_writeregI(state, 0x2b, tda[1]);
	503	stv0288_writeregI(state, 0x2c, tda[2]);
	504	udelay(30);
	505	}
	506
	507	state->tuner_frequency = c->frequency;
	508	state->fec_inner = FEC_AUTO;
	509	state->symbol_rate = c->symbol_rate;
	510
	511	return 0;
	512	}
	513
	514	static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
	515	{
	516	struct stv0288_state *state = fe->demodulator_priv;
	517
	518	if (enable)
	519	stv0288_writeregI(state, 0x01, 0xb5);
	520	else
	521	stv0288_writeregI(state, 0x01, 0x35);
	522
	523	udelay(1);
	524
	525	return 0;
	526	}
	527
	528	static void stv0288_release(struct dvb_frontend *fe)
	529	{
	530	struct stv0288_state *state = fe->demodulator_priv;
	531	kfree(state);
	532	}
	533
	534	static struct dvb_frontend_ops stv0288_ops = {
	535
	536	.info = {
	537	.name = "ST STV0288 DVB-S",
	538	.type = FE_QPSK,
	539	.frequency_min = 950000,
	540	.frequency_max = 2150000,
	541	.frequency_stepsize = 1000, /* kHz for QPSK frontends */
	542	.frequency_tolerance = 0,
	543	.symbol_rate_min = 1000000,
	544	.symbol_rate_max = 45000000,
	545	.symbol_rate_tolerance = 500, /* ppm */
	546	.caps = FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
	547	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \|
	548	FE_CAN_QPSK \|
	549	FE_CAN_FEC_AUTO
	550	},
	551
	552	.release = stv0288_release,
	553	.init = stv0288_init,
	554	.sleep = stv0288_sleep,
	555	.write = stv0288_write,
	556	.i2c_gate_ctrl = stv0288_i2c_gate_ctrl,
	557	.read_status = stv0288_read_status,
	558	.read_ber = stv0288_read_ber,
	559	.read_signal_strength = stv0288_read_signal_strength,
560	.read_snr = stv0288_read_snr,
561	.read_ucblocks = stv0288_read_ucblocks,
562	.diseqc_send_master_cmd = stv0288_send_diseqc_msg,
563	.diseqc_send_burst = stv0288_send_diseqc_burst,
564	.set_tone = stv0288_set_tone,
565	.set_voltage = stv0288_set_voltage,
566
567	.set_property = stv0288_set_property,
568	.get_property = stv0288_get_property,
569	.set_frontend = stv0288_set_frontend,
570	};
571
572	struct dvb_frontend stv0288_attach(const struct stv0288_config config,
573	struct i2c_adapter *i2c)
574	{
575	struct stv0288_state *state = NULL;
576	int id;
577
578	/* allocate memory for the internal state */
084e24ac	579	state = kzalloc(sizeof(struct stv0288_state), GFP_KERNEL);
e4aab64c IL	580	if (state == NULL)
	581	goto error;
	582
	583	/* setup the state */
	584	state->config = config;
	585	state->i2c = i2c;
	586	state->initialised = 0;
	587	state->tuner_frequency = 0;
	588	state->symbol_rate = 0;
	589	state->fec_inner = 0;
	590	state->errmode = STATUS_BER;
	591
	592	stv0288_writeregI(state, 0x41, 0x04);
	593	msleep(200);
	594	id = stv0288_readreg(state, 0x00);
	595	dprintk("stv0288 id %x\n", id);
	596
	597	/* register 0x00 contains 0x11 for STV0288 */
	598	if (id != 0x11)
	599	goto error;
	600
	601	/* create dvb_frontend */
	602	memcpy(&state->frontend.ops, &stv0288_ops,
	603	sizeof(struct dvb_frontend_ops));
	604	state->frontend.demodulator_priv = state;
	605	return &state->frontend;
	606
	607	error:
	608	kfree(state);
	609
	610	return NULL;
	611	}
	612	EXPORT_SYMBOL(stv0288_attach);
	613
	614	module_param(debug_legacy_dish_switch, int, 0444);
	615	MODULE_PARM_DESC(debug_legacy_dish_switch,
	616	"Enable timing analysis for Dish Network legacy switches");
	617
	618	module_param(debug, int, 0644);
	619	MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
	620
	621	MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver");
	622	MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin");
	623	MODULE_LICENSE("GPL");
	624