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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
	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


*/

#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 <media/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;
	enum fe_code_rate 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;

	stv0288_writeregI(state, 0x22, 0);
	stv0288_writeregI(state, 0x23, 0);
	stv0288_writeregI(state, 0x2b, 0xff);
	stv0288_writeregI(state, 0x2c, 0xf7);

	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,
				     enum fe_sec_mini_cmd 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, enum fe_sec_tone_mode 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, 0x20,
	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,
			       enum fe_sec_voltage 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, enum fe_status *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_frontend(struct dvb_frontend *fe)
{
	struct stv0288_state *state = fe->demodulator_priv;
	struct dtv_frontend_properties *c = &fe->dtv_property_cache;

	char tm;
	unsigned char tda[3];
	u8 reg, time_out = 0;

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