[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / dvb-frontends / tda8261.c

/*
	TDA8261 8PSK/QPSK tuner driver
	Copyright (C) Manu Abraham (abraham.manu@gmail.com)

	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/slab.h>

#include "dvb_frontend.h"
#include "tda8261.h"

struct tda8261_state {
	struct dvb_frontend		*fe;
	struct i2c_adapter		*i2c;
	const struct tda8261_config	*config;

	/* state cache */
	u32 frequency;
	u32 bandwidth;
};

static int tda8261_read(struct tda8261_state *state, u8 *buf)
{
	const struct tda8261_config *config = state->config;
	int err = 0;
	struct i2c_msg msg = { .addr	= config->addr, .flags = I2C_M_RD,.buf = buf,  .len = 1 };

	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1)
		pr_err("%s: read error, err=%d\n", __func__, err);

	return err;
}

static int tda8261_write(struct tda8261_state *state, u8 *buf)
{
	const struct tda8261_config *config = state->config;
	int err = 0;
	struct i2c_msg msg = { .addr = config->addr, .flags = 0, .buf = buf, .len = 4 };

	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1)
		pr_err("%s: write error, err=%d\n", __func__, err);

	return err;
}

static int tda8261_get_status(struct dvb_frontend *fe, u32 *status)
{
	struct tda8261_state *state = fe->tuner_priv;
	u8 result = 0;
	int err = 0;

	*status = 0;

	if ((err = tda8261_read(state, &result)) < 0) {
		pr_err("%s: I/O Error\n", __func__);
		return err;
	}
	if ((result >> 6) & 0x01) {
		pr_debug("%s: Tuner Phase Locked\n", __func__);
		*status = 1;
	}

	return err;
}

static const u32 div_tab[] = { 2000, 1000,  500,  250,  125 }; /* kHz */
static const u8  ref_div[] = { 0x00, 0x01, 0x02, 0x05, 0x07 };

static int tda8261_get_state(struct dvb_frontend *fe,
			     enum tuner_param param,
			     struct tuner_state *tstate)
{
	struct tda8261_state *state = fe->tuner_priv;
	int err = 0;

	switch (param) {
	case DVBFE_TUNER_FREQUENCY:
		tstate->frequency = state->frequency;
		break;
	case DVBFE_TUNER_BANDWIDTH:
		tstate->bandwidth = 40000000; /* FIXME! need to calculate Bandwidth */
		break;
	default:
		pr_err("%s: Unknown parameter (param=%d)\n", __func__, param);
		err = -EINVAL;
		break;
	}

	return err;
}

static int tda8261_set_state(struct dvb_frontend *fe,
			     enum tuner_param param,
			     struct tuner_state *tstate)
{
	struct tda8261_state *state = fe->tuner_priv;
	const struct tda8261_config *config = state->config;
	u32 frequency, N, status = 0;
	u8 buf[4];
	int err = 0;

	if (param & DVBFE_TUNER_FREQUENCY) {
		/**
		 * N = Max VCO Frequency / Channel Spacing
		 * Max VCO Frequency = VCO frequency + (channel spacing - 1)
		 * (to account for half channel spacing on either side)
		 */
		frequency = tstate->frequency;
		if ((frequency < 950000) || (frequency > 2150000)) {
			pr_warn("%s: Frequency beyond limits, frequency=%d\n", __func__, frequency);
			return -EINVAL;
		}
		N = (frequency + (div_tab[config->step_size] - 1)) / div_tab[config->step_size];
		pr_debug("%s: Step size=%d, Divider=%d, PG=0x%02x (%d)\n",
			__func__, config->step_size, div_tab[config->step_size], N, N);

		buf[0] = (N >> 8) & 0xff;
		buf[1] = N & 0xff;
		buf[2] = (0x01 << 7) | ((ref_div[config->step_size] & 0x07) << 1);

		if (frequency < 1450000)
			buf[3] = 0x00;
		else if (frequency < 2000000)
			buf[3] = 0x40;
		else if (frequency < 2150000)
			buf[3] = 0x80;

		/* Set params */
		if ((err = tda8261_write(state, buf)) < 0) {
			pr_err("%s: I/O Error\n", __func__);
			return err;
		}
		/* sleep for some time */
		pr_debug("%s: Waiting to Phase LOCK\n", __func__);
		msleep(20);
		/* check status */
		if ((err = tda8261_get_status(fe, &status)) < 0) {
			pr_err("%s: I/O Error\n", __func__);
			return err;
		}
		if (status == 1) {
			pr_debug("%s: Tuner Phase locked: status=%d\n", __func__, status);
			state->frequency = frequency; /* cache successful state */
		} else {
			pr_debug("%s: No Phase lock: status=%d\n", __func__, status);
		}
	} else {
		pr_err("%s: Unknown parameter (param=%d)\n", __func__, param);
		return -EINVAL;
	}

	return 0;
}

static int tda8261_release(struct dvb_frontend *fe)
{
	struct tda8261_state *state = fe->tuner_priv;

	fe->tuner_priv = NULL;
	kfree(state);
	return 0;
}

static struct dvb_tuner_ops tda8261_ops = {

	.info = {
		.name		= "TDA8261",
//		.tuner_name	= NULL,
		.frequency_min	=  950000,
		.frequency_max	= 2150000,
		.frequency_step = 0
	},

	.set_state	= tda8261_set_state,
	.get_state	= tda8261_get_state,
	.get_status	= tda8261_get_status,
	.release	= tda8261_release
};

struct dvb_frontend *tda8261_attach(struct dvb_frontend *fe,
				    const struct tda8261_config *config,
				    struct i2c_adapter *i2c)
{
	struct tda8261_state *state = NULL;

	if ((state = kzalloc(sizeof (struct tda8261_state), GFP_KERNEL)) == NULL)
		goto exit;

	state->config		= config;
	state->i2c		= i2c;
	state->fe		= fe;
	fe->tuner_priv		= state;
	fe->ops.tuner_ops	= tda8261_ops;

	fe->ops.tuner_ops.info.frequency_step = div_tab[config->step_size];
//	fe->ops.tuner_ops.tuner_name	 = &config->buf;

//	printk("%s: Attaching %s TDA8261 8PSK/QPSK tuner\n",
//		__func__, fe->ops.tuner_ops.tuner_name);
	pr_info("%s: Attaching TDA8261 8PSK/QPSK tuner\n", __func__);

	return fe;

exit:
	kfree(state);
	return NULL;
}

EXPORT_SYMBOL(tda8261_attach);

MODULE_AUTHOR("Manu Abraham");
MODULE_DESCRIPTION("TDA8261 8PSK/QPSK Tuner");
MODULE_LICENSE("GPL");
Commit	Line	Data
00360205 MA	1	/*
	2	TDA8261 8PSK/QPSK tuner driver
	3	Copyright (C) Manu Abraham (abraham.manu@gmail.com)
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	18	*/
	19
	20
	21	#include <linux/init.h>
	22	#include <linux/kernel.h>
	23	#include <linux/module.h>
5a0e3ad6	24	#include <linux/slab.h>
00360205 MA	25
	26	#include "dvb_frontend.h"
	27	#include "tda8261.h"
	28
	29	struct tda8261_state {
41e1151b MA	30	struct dvb_frontend *fe;
	31	struct i2c_adapter *i2c;
	32	const struct tda8261_config *config;
00360205 MA	33
	34	/* state cache */
	35	u32 frequency;
	36	u32 bandwidth;
	37	};
	38
	39	static int tda8261_read(struct tda8261_state state, u8 buf)
	40	{
41e1151b	41	const struct tda8261_config *config = state->config;
00360205	42	int err = 0;
225ee0ca	43	struct i2c_msg msg = { .addr = config->addr, .flags = I2C_M_RD,.buf = buf, .len = 1 };
00360205	44
c7d85a2d	45	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1)
eb2e2652	46	pr_err("%s: read error, err=%d\n", __func__, err);
00360205 MA	47
	48	return err;
	49	}
	50
	51	static int tda8261_write(struct tda8261_state state, u8 buf)
	52	{
41e1151b	53	const struct tda8261_config *config = state->config;
00360205 MA	54	int err = 0;
	55	struct i2c_msg msg = { .addr = config->addr, .flags = 0, .buf = buf, .len = 4 };
	56
	57	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1)
eb2e2652	58	pr_err("%s: write error, err=%d\n", __func__, err);
00360205 MA	59
	60	return err;
	61	}
	62
	63	static int tda8261_get_status(struct dvb_frontend fe, u32 status)
	64	{
	65	struct tda8261_state *state = fe->tuner_priv;
	66	u8 result = 0;
	67	int err = 0;
	68
f6e63827 MA	69	*status = 0;
f6e63827 MA	70
00360205	71	if ((err = tda8261_read(state, &result)) < 0) {
eb2e2652	72	pr_err("%s: I/O Error\n", __func__);
00360205 MA	73	return err;
	74	}
	75	if ((result >> 6) & 0x01) {
eb2e2652	76	pr_debug("%s: Tuner Phase Locked\n", __func__);
00360205 MA	77	*status = 1;
	78	}
	79
	80	return err;
	81	}
	82
	83	static const u32 div_tab[] = { 2000, 1000, 500, 250, 125 }; /* kHz */
	84	static const u8 ref_div[] = { 0x00, 0x01, 0x02, 0x05, 0x07 };
	85
	86	static int tda8261_get_state(struct dvb_frontend *fe,
	87	enum tuner_param param,
	88	struct tuner_state *tstate)
	89	{
	90	struct tda8261_state *state = fe->tuner_priv;
	91	int err = 0;
	92
	93	switch (param) {
	94	case DVBFE_TUNER_FREQUENCY:
	95	tstate->frequency = state->frequency;
	96	break;
	97	case DVBFE_TUNER_BANDWIDTH:
1e3d8abe	98	tstate->bandwidth = 40000000; /* FIXME! need to calculate Bandwidth */
00360205 MA	99	break;
00360205 MA	100	default:
eb2e2652	101	pr_err("%s: Unknown parameter (param=%d)\n", __func__, param);
00360205 MA	102	err = -EINVAL;
	103	break;
	104	}
	105
	106	return err;
	107	}
	108
	109	static int tda8261_set_state(struct dvb_frontend *fe,
	110	enum tuner_param param,
	111	struct tuner_state *tstate)
	112	{
	113	struct tda8261_state *state = fe->tuner_priv;
41e1151b	114	const struct tda8261_config *config = state->config;
00360205 MA	115	u32 frequency, N, status = 0;
	116	u8 buf[4];
	117	int err = 0;
	118
	119	if (param & DVBFE_TUNER_FREQUENCY) {
	120	/**
	121	* N = Max VCO Frequency / Channel Spacing
	122	* Max VCO Frequency = VCO frequency + (channel spacing - 1)
	123	* (to account for half channel spacing on either side)
	124	*/
	125	frequency = tstate->frequency;
cf6efeb6	126	if ((frequency < 950000) \|\| (frequency > 2150000)) {
eb2e2652	127	pr_warn("%s: Frequency beyond limits, frequency=%d\n", __func__, frequency);
cf6efeb6 MA	128	return -EINVAL;
cf6efeb6 MA	129	}
00360205	130	N = (frequency + (div_tab[config->step_size] - 1)) / div_tab[config->step_size];
eb2e2652	131	pr_debug("%s: Step size=%d, Divider=%d, PG=0x%02x (%d)\n",
c7d85a2d MA	132	__func__, config->step_size, div_tab[config->step_size], N, N);
c7d85a2d MA	133
00360205 MA	134	buf[0] = (N >> 8) & 0xff;
00360205 MA	135	buf[1] = N & 0xff;
c7d85a2d	136	buf[2] = (0x01 << 7) \| ((ref_div[config->step_size] & 0x07) << 1);
cf6efeb6 MA	137
	138	if (frequency < 1450000)
	139	buf[3] = 0x00;
114323ed	140	else if (frequency < 2000000)
cf6efeb6	141	buf[3] = 0x40;
114323ed	142	else if (frequency < 2150000)
cf6efeb6 MA	143	buf[3] = 0x80;
cf6efeb6 MA	144
00360205	145	/* Set params */
00360205	146	if ((err = tda8261_write(state, buf)) < 0) {
eb2e2652	147	pr_err("%s: I/O Error\n", __func__);
00360205 MA	148	return err;
	149	}
	150	/* sleep for some time */
eb2e2652	151	pr_debug("%s: Waiting to Phase LOCK\n", __func__);
c7d85a2d	152	msleep(20);
00360205 MA	153	/* check status */
00360205 MA	154	if ((err = tda8261_get_status(fe, &status)) < 0) {
eb2e2652	155	pr_err("%s: I/O Error\n", __func__);
00360205 MA	156	return err;
00360205 MA	157	}
0b8f15dc	158	if (status == 1) {
eb2e2652	159	pr_debug("%s: Tuner Phase locked: status=%d\n", __func__, status);
c7d85a2d	160	state->frequency = frequency; /* cache successful state */
0b8f15dc	161	} else {
eb2e2652	162	pr_debug("%s: No Phase lock: status=%d\n", __func__, status);
0b8f15dc	163	}
00360205	164	} else {
eb2e2652	165	pr_err("%s: Unknown parameter (param=%d)\n", __func__, param);
00360205 MA	166	return -EINVAL;
	167	}
	168
	169	return 0;
	170	}
	171
	172	static int tda8261_release(struct dvb_frontend *fe)
	173	{
	174	struct tda8261_state *state = fe->tuner_priv;
	175
	176	fe->tuner_priv = NULL;
	177	kfree(state);
	178	return 0;
	179	}
	180
	181	static struct dvb_tuner_ops tda8261_ops = {
	182
	183	.info = {
	184	.name = "TDA8261",
	185	// .tuner_name = NULL,
	186	.frequency_min = 950000,
	187	.frequency_max = 2150000,
	188	.frequency_step = 0
	189	},
	190
	191	.set_state = tda8261_set_state,
	192	.get_state = tda8261_get_state,
f6e63827	193	.get_status = tda8261_get_status,
00360205 MA	194	.release = tda8261_release
	195	};
	196
	197	struct dvb_frontend tda8261_attach(struct dvb_frontend fe,
41e1151b	198	const struct tda8261_config *config,
00360205 MA	199	struct i2c_adapter *i2c)
	200	{
	201	struct tda8261_state *state = NULL;
	202
	203	if ((state = kzalloc(sizeof (struct tda8261_state), GFP_KERNEL)) == NULL)
	204	goto exit;
	205
	206	state->config = config;
	207	state->i2c = i2c;
	208	state->fe = fe;
	209	fe->tuner_priv = state;
	210	fe->ops.tuner_ops = tda8261_ops;
	211
	212	fe->ops.tuner_ops.info.frequency_step = div_tab[config->step_size];
	213	// fe->ops.tuner_ops.tuner_name = &config->buf;
	214
	215	// printk("%s: Attaching %s TDA8261 8PSK/QPSK tuner\n",
	216	// __func__, fe->ops.tuner_ops.tuner_name);
eb2e2652	217	pr_info("%s: Attaching TDA8261 8PSK/QPSK tuner\n", __func__);
00360205	218
00360205 MA	219	return fe;
	220
	221	exit:
	222	kfree(state);
	223	return NULL;
	224	}
	225
	226	EXPORT_SYMBOL(tda8261_attach);
00360205 MA	227
	228	MODULE_AUTHOR("Manu Abraham");
	229	MODULE_DESCRIPTION("TDA8261 8PSK/QPSK Tuner");
	230	MODULE_LICENSE("GPL");