[mirror_ubuntu-artful-kernel.git] / drivers / media / tuners / it913x.c

/*
 * ITE IT913X silicon tuner driver
 *
 *  Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com)
 *  IT9137 Copyright (C) ITE Tech Inc.
 *
 *  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.
 */

#include "it913x.h"
#include <linux/platform_device.h>
#include <linux/regmap.h>

struct it913x_dev {
	struct platform_device *pdev;
	struct regmap *regmap;
	struct dvb_frontend *fe;
	u8 chip_ver:2;
	u8 role:2;
	u16 xtal;
	u8 fdiv;
	u8 clk_mode;
	u32 fn_min;
	bool active;
};

static int it913x_init(struct dvb_frontend *fe)
{
	struct it913x_dev *dev = fe->tuner_priv;
	struct platform_device *pdev = dev->pdev;
	int ret;
	unsigned int utmp;
	u8 iqik_m_cal, nv_val, buf[2];
	static const u8 nv[] = {48, 32, 24, 16, 12, 8, 6, 4, 2};
	unsigned long timeout;

	dev_dbg(&pdev->dev, "role %u\n", dev->role);

	ret = regmap_write(dev->regmap, 0x80ec4c, 0x68);
	if (ret)
		goto err;

	usleep_range(10000, 100000);

	ret = regmap_read(dev->regmap, 0x80ec86, &utmp);
	if (ret)
		goto err;

	switch (utmp) {
	case 0:
		/* 12.000 MHz */
		dev->clk_mode = utmp;
		dev->xtal = 2000;
		dev->fdiv = 3;
		iqik_m_cal = 16;
		break;
	case 1:
		/* 20.480 MHz */
		dev->clk_mode = utmp;
		dev->xtal = 640;
		dev->fdiv = 1;
		iqik_m_cal = 6;
		break;
	default:
		dev_err(&pdev->dev, "unknown clock identifier %d\n", utmp);
		goto err;
	}

	ret = regmap_read(dev->regmap, 0x80ed03,  &utmp);
	if (ret)
		goto err;

	else if (utmp < ARRAY_SIZE(nv))
		nv_val = nv[utmp];
	else
		nv_val = 2;

	#define TIMEOUT 50
	timeout = jiffies + msecs_to_jiffies(TIMEOUT);
	while (!time_after(jiffies, timeout)) {
		ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2);
		if (ret)
			goto err;

		utmp = (buf[1] << 8) | (buf[0] << 0);
		if (utmp)
			break;
	}

	dev_dbg(&pdev->dev, "r_fbc_m_bdry took %u ms, val %u\n",
			jiffies_to_msecs(jiffies) -
			(jiffies_to_msecs(timeout) - TIMEOUT), utmp);

	dev->fn_min = dev->xtal * utmp;
	dev->fn_min /= (dev->fdiv * nv_val);
	dev->fn_min *= 1000;
	dev_dbg(&pdev->dev, "fn_min %u\n", dev->fn_min);

	/*
	 * Chip version BX never sets that flag so we just wait 50ms in that
	 * case. It is possible poll BX similarly than AX and then timeout in
	 * order to get 50ms delay, but that causes about 120 extra I2C
	 * messages. As for now, we just wait and reduce IO.
	 */
	if (dev->chip_ver == 1) {
		#define TIMEOUT 50
		timeout = jiffies + msecs_to_jiffies(TIMEOUT);
		while (!time_after(jiffies, timeout)) {
			ret = regmap_read(dev->regmap, 0x80ec82, &utmp);
			if (ret)
				goto err;

			if (utmp)
				break;
		}

		dev_dbg(&pdev->dev, "p_tsm_init_mode took %u ms, val %u\n",
				jiffies_to_msecs(jiffies) -
				(jiffies_to_msecs(timeout) - TIMEOUT), utmp);
	} else {
		msleep(50);
	}

	ret = regmap_write(dev->regmap, 0x80ed81, iqik_m_cal);
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80ec57, 0x00);
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80ec58, 0x00);
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80ec40, 0x01);
	if (ret)
		goto err;

	dev->active = true;

	return 0;
err:
	dev_dbg(&pdev->dev, "failed %d\n", ret);
	return ret;
}

static int it913x_sleep(struct dvb_frontend *fe)
{
	struct it913x_dev *dev = fe->tuner_priv;
	struct platform_device *pdev = dev->pdev;
	int ret, len;

	dev_dbg(&pdev->dev, "role %u\n", dev->role);

	dev->active = false;

	ret  = regmap_bulk_write(dev->regmap, 0x80ec40, "\x00", 1);
	if (ret)
		goto err;

	/*
	 * Writing '0x00' to master tuner register '0x80ec08' causes slave tuner
	 * communication lost. Due to that, we cannot put master full sleep.
	 */
	if (dev->role == IT913X_ROLE_DUAL_MASTER)
		len = 4;
	else
		len = 15;

	dev_dbg(&pdev->dev, "role %u, len %d\n", dev->role, len);

	ret = regmap_bulk_write(dev->regmap, 0x80ec02,
			"\x3f\x1f\x3f\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
			len);
	if (ret)
		goto err;

	ret = regmap_bulk_write(dev->regmap, 0x80ec12, "\x00\x00\x00\x00", 4);
	if (ret)
		goto err;

	ret = regmap_bulk_write(dev->regmap, 0x80ec17,
			"\x00\x00\x00\x00\x00\x00\x00\x00\x00", 9);
	if (ret)
		goto err;

	ret = regmap_bulk_write(dev->regmap, 0x80ec22,
			"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 10);
	if (ret)
		goto err;

	ret = regmap_bulk_write(dev->regmap, 0x80ec20, "\x00", 1);
	if (ret)
		goto err;

	ret = regmap_bulk_write(dev->regmap, 0x80ec3f, "\x01", 1);
	if (ret)
		goto err;

	return 0;
err:
	dev_dbg(&pdev->dev, "failed %d\n", ret);
	return ret;
}

static int it913x_set_params(struct dvb_frontend *fe)
{
	struct it913x_dev *dev = fe->tuner_priv;
	struct platform_device *pdev = dev->pdev;
	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
	int ret;
	unsigned int utmp;
	u32 pre_lo_freq, t_cal_freq;
	u16 iqik_m_cal, n_div;
	u8 u8tmp, n, l_band, lna_band;

	dev_dbg(&pdev->dev, "role=%u, frequency %u, bandwidth_hz %u\n",
			dev->role, c->frequency, c->bandwidth_hz);

	if (!dev->active) {
		ret = -EINVAL;
		goto err;
	}

	if (c->frequency <=         74000000) {
		n_div = 48;
		n = 0;
	} else if (c->frequency <= 111000000) {
		n_div = 32;
		n = 1;
	} else if (c->frequency <= 148000000) {
		n_div = 24;
		n = 2;
	} else if (c->frequency <= 222000000) {
		n_div = 16;
		n = 3;
	} else if (c->frequency <= 296000000) {
		n_div = 12;
		n = 4;
	} else if (c->frequency <= 445000000) {
		n_div = 8;
		n = 5;
	} else if (c->frequency <= dev->fn_min) {
		n_div = 6;
		n = 6;
	} else if (c->frequency <= 950000000) {
		n_div = 4;
		n = 7;
	} else {
		n_div = 2;
		n = 0;
	}

	ret = regmap_read(dev->regmap, 0x80ed81, &utmp);
	if (ret)
		goto err;

	iqik_m_cal = utmp * n_div;

	if (utmp < 0x20) {
		if (dev->clk_mode == 0)
			iqik_m_cal = (iqik_m_cal * 9) >> 5;
		else
			iqik_m_cal >>= 1;
	} else {
		iqik_m_cal = 0x40 - iqik_m_cal;
		if (dev->clk_mode == 0)
			iqik_m_cal = ~((iqik_m_cal * 9) >> 5);
		else
			iqik_m_cal = ~(iqik_m_cal >> 1);
	}

	t_cal_freq = (c->frequency / 1000) * n_div * dev->fdiv;
	pre_lo_freq = t_cal_freq / dev->xtal;
	utmp = pre_lo_freq * dev->xtal;

	if ((t_cal_freq - utmp) >= (dev->xtal >> 1))
		pre_lo_freq++;

	pre_lo_freq += (u32) n << 13;
	/* Frequency OMEGA_IQIK_M_CAL_MID*/
	t_cal_freq = pre_lo_freq + (u32)iqik_m_cal;
	dev_dbg(&pdev->dev, "t_cal_freq %u, pre_lo_freq %u\n",
			t_cal_freq, pre_lo_freq);

	if (c->frequency <=         440000000) {
		l_band = 0;
		lna_band = 0;
	} else if (c->frequency <=  484000000) {
		l_band = 1;
		lna_band = 1;
	} else if (c->frequency <=  533000000) {
		l_band = 1;
		lna_band = 2;
	} else if (c->frequency <=  587000000) {
		l_band = 1;
		lna_band = 3;
	} else if (c->frequency <=  645000000) {
		l_band = 1;
		lna_band = 4;
	} else if (c->frequency <=  710000000) {
		l_band = 1;
		lna_band = 5;
	} else if (c->frequency <=  782000000) {
		l_band = 1;
		lna_band = 6;
	} else if (c->frequency <=  860000000) {
		l_band = 1;
		lna_band = 7;
	} else if (c->frequency <= 1492000000) {
		l_band = 1;
		lna_band = 0;
	} else if (c->frequency <= 1685000000) {
		l_band = 1;
		lna_band = 1;
	} else {
		ret = -EINVAL;
		goto err;
	}

	/* XXX: latest windows driver does not set that at all */
	ret = regmap_write(dev->regmap, 0x80ee06, lna_band);
	if (ret)
		goto err;

	if (c->bandwidth_hz <=      5000000)
		u8tmp = 0;
	else if (c->bandwidth_hz <= 6000000)
		u8tmp = 2;
	else if (c->bandwidth_hz <= 7000000)
		u8tmp = 4;
	else
		u8tmp = 6;       /* 8000000 */

	ret = regmap_write(dev->regmap, 0x80ec56, u8tmp);
	if (ret)
		goto err;

	/* XXX: latest windows driver sets different value (a8 != 68) */
	ret = regmap_write(dev->regmap, 0x80ec4c, 0xa0 | (l_band << 3));
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80ec4d, (t_cal_freq >> 0) & 0xff);
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80ec4e, (t_cal_freq >> 8) & 0xff);
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80011e, (pre_lo_freq >> 0) & 0xff);
	if (ret)
		goto err;

	ret = regmap_write(dev->regmap, 0x80011f, (pre_lo_freq >> 8) & 0xff);
	if (ret)
		goto err;

	return 0;
err:
	dev_dbg(&pdev->dev, "failed %d\n", ret);
	return ret;
}

static const struct dvb_tuner_ops it913x_tuner_ops = {
	.info = {
		.name           = "ITE IT913X",
		.frequency_min  = 174000000,
		.frequency_max  = 862000000,
	},

	.init = it913x_init,
	.sleep = it913x_sleep,
	.set_params = it913x_set_params,
};

static int it913x_probe(struct platform_device *pdev)
{
	struct it913x_platform_data *pdata = pdev->dev.platform_data;
	struct dvb_frontend *fe = pdata->fe;
	struct it913x_dev *dev;
	const struct platform_device_id *id = platform_get_device_id(pdev);
	int ret;
	char *chip_ver_str;

	dev = kzalloc(sizeof(struct it913x_dev), GFP_KERNEL);
	if (dev == NULL) {
		ret = -ENOMEM;
		dev_err(&pdev->dev, "kzalloc() failed\n");
		goto err;
	}

	dev->pdev = pdev;
	dev->regmap = pdata->regmap;
	dev->fe = pdata->fe;
	dev->chip_ver = id->driver_data;
	dev->role = pdata->role;

	fe->tuner_priv = dev;
	memcpy(&fe->ops.tuner_ops, &it913x_tuner_ops,
			sizeof(struct dvb_tuner_ops));
	platform_set_drvdata(pdev, dev);

	if (dev->chip_ver == 1)
		chip_ver_str = "AX";
	else if (dev->chip_ver == 2)
		chip_ver_str = "BX";
	else
		chip_ver_str = "??";

	dev_info(&pdev->dev, "ITE IT913X %s successfully attached\n",
		 chip_ver_str);
	dev_dbg(&pdev->dev, "chip_ver %u, role %u\n", dev->chip_ver, dev->role);
	return 0;
err:
	dev_dbg(&pdev->dev, "failed %d\n", ret);
	return ret;
}

static int it913x_remove(struct platform_device *pdev)
{
	struct it913x_dev *dev = platform_get_drvdata(pdev);
	struct dvb_frontend *fe = dev->fe;

	dev_dbg(&pdev->dev, "\n");

	memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
	fe->tuner_priv = NULL;
	kfree(dev);

	return 0;
}

static const struct platform_device_id it913x_id_table[] = {
	{"it9133ax-tuner", 1},
	{"it9133bx-tuner", 2},
	{},
};
MODULE_DEVICE_TABLE(platform, it913x_id_table);

static struct platform_driver it913x_driver = {
	.driver = {
		.name	= "it913x",
		.suppress_bind_attrs	= true,
	},
	.probe		= it913x_probe,
	.remove		= it913x_remove,
	.id_table	= it913x_id_table,
};

module_platform_driver(it913x_driver);

MODULE_DESCRIPTION("ITE IT913X silicon tuner driver");
MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
MODULE_LICENSE("GPL");
Commit	Line	Data
88b38bef	1	/*
17027b96	2	* ITE IT913X silicon tuner driver
88b38bef AP	3	*
	4	* Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com)
	5	* IT9137 Copyright (C) ITE Tech Inc.
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	*
	16	* GNU General Public License for more details.
88b38bef AP	17	*/
88b38bef AP	18
3d2f18d3	19	#include "it913x.h"
675ee801	20	#include <linux/platform_device.h>
3d2f18d3	21	#include <linux/regmap.h>
88b38bef	22
a71b65e8	23	struct it913x_dev {
675ee801	24	struct platform_device *pdev;
d2dbc00c	25	struct regmap *regmap;
3b2a5e8c	26	struct dvb_frontend *fe;
676c350f AP	27	u8 chip_ver:2;
676c350f AP	28	u8 role:2;
17027b96 AP	29	u16 xtal;
	30	u8 fdiv;
	31	u8 clk_mode;
	32	u32 fn_min;
	33	bool active;
88b38bef AP	34	};
88b38bef AP	35
42432b3c	36	static int it913x_init(struct dvb_frontend *fe)
88b38bef	37	{
a71b65e8	38	struct it913x_dev *dev = fe->tuner_priv;
675ee801	39	struct platform_device *pdev = dev->pdev;
5190ff3e	40	int ret;
17027b96 AP	41	unsigned int utmp;
	42	u8 iqik_m_cal, nv_val, buf[2];
	43	static const u8 nv[] = {48, 32, 24, 16, 12, 8, 6, 4, 2};
5190ff3e	44	unsigned long timeout;
88b38bef	45
675ee801	46	dev_dbg(&pdev->dev, "role %u\n", dev->role);
17027b96 AP	47
	48	ret = regmap_write(dev->regmap, 0x80ec4c, 0x68);
	49	if (ret)
	50	goto err;
	51
	52	usleep_range(10000, 100000);
	53
	54	ret = regmap_read(dev->regmap, 0x80ec86, &utmp);
	55	if (ret)
	56	goto err;
	57
	58	switch (utmp) {
88b38bef	59	case 0:
17027b96 AP	60	/* 12.000 MHz */
	61	dev->clk_mode = utmp;
	62	dev->xtal = 2000;
	63	dev->fdiv = 3;
	64	iqik_m_cal = 16;
88b38bef	65	break;
88b38bef	66	case 1:
17027b96 AP	67	/* 20.480 MHz */
	68	dev->clk_mode = utmp;
	69	dev->xtal = 640;
	70	dev->fdiv = 1;
	71	iqik_m_cal = 6;
88b38bef	72	break;
17027b96	73	default:
675ee801	74	dev_err(&pdev->dev, "unknown clock identifier %d\n", utmp);
17027b96	75	goto err;
88b38bef AP	76	}
88b38bef AP	77
17027b96 AP	78	ret = regmap_read(dev->regmap, 0x80ed03, &utmp);
	79	if (ret)
	80	goto err;
88b38bef	81
17027b96 AP	82	else if (utmp < ARRAY_SIZE(nv))
17027b96 AP	83	nv_val = nv[utmp];
88b38bef AP	84	else
	85	nv_val = 2;
	86
5190ff3e AP	87	#define TIMEOUT 50
	88	timeout = jiffies + msecs_to_jiffies(TIMEOUT);
	89	while (!time_after(jiffies, timeout)) {
17027b96	90	ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2);
d2dbc00c	91	if (ret)
17027b96 AP	92	goto err;
	93
	94	utmp = (buf[1] << 8) \| (buf[0] << 0);
	95	if (utmp)
	96	break;
88b38bef	97	}
88b38bef	98
675ee801	99	dev_dbg(&pdev->dev, "r_fbc_m_bdry took %u ms, val %u\n",
5190ff3e AP	100	jiffies_to_msecs(jiffies) -
5190ff3e AP	101	(jiffies_to_msecs(timeout) - TIMEOUT), utmp);
17027b96 AP	102
	103	dev->fn_min = dev->xtal * utmp;
	104	dev->fn_min /= (dev->fdiv * nv_val);
	105	dev->fn_min *= 1000;
675ee801	106	dev_dbg(&pdev->dev, "fn_min %u\n", dev->fn_min);
17027b96	107
5190ff3e AP	108	/*
	109	* Chip version BX never sets that flag so we just wait 50ms in that
	110	* case. It is possible poll BX similarly than AX and then timeout in
	111	* order to get 50ms delay, but that causes about 120 extra I2C
	112	* messages. As for now, we just wait and reduce IO.
	113	*/
17027b96	114	if (dev->chip_ver == 1) {
5190ff3e AP	115	#define TIMEOUT 50
	116	timeout = jiffies + msecs_to_jiffies(TIMEOUT);
	117	while (!time_after(jiffies, timeout)) {
17027b96 AP	118	ret = regmap_read(dev->regmap, 0x80ec82, &utmp);
	119	if (ret)
	120	goto err;
	121
	122	if (utmp)
88b38bef	123	break;
88b38bef	124	}
17027b96	125
675ee801	126	dev_dbg(&pdev->dev, "p_tsm_init_mode took %u ms, val %u\n",
5190ff3e AP	127	jiffies_to_msecs(jiffies) -
5190ff3e AP	128	(jiffies_to_msecs(timeout) - TIMEOUT), utmp);
17027b96 AP	129	} else {
17027b96 AP	130	msleep(50);
88b38bef AP	131	}
88b38bef AP	132
17027b96 AP	133	ret = regmap_write(dev->regmap, 0x80ed81, iqik_m_cal);
	134	if (ret)
	135	goto err;
	136
	137	ret = regmap_write(dev->regmap, 0x80ec57, 0x00);
	138	if (ret)
	139	goto err;
	140
	141	ret = regmap_write(dev->regmap, 0x80ec58, 0x00);
	142	if (ret)
	143	goto err;
	144
	145	ret = regmap_write(dev->regmap, 0x80ec40, 0x01);
	146	if (ret)
	147	goto err;
	148
	149	dev->active = true;
d19812eb	150
17027b96 AP	151	return 0;
17027b96 AP	152	err:
675ee801	153	dev_dbg(&pdev->dev, "failed %d\n", ret);
17027b96	154	return ret;
88b38bef AP	155	}
88b38bef AP	156
676c350f AP	157	static int it913x_sleep(struct dvb_frontend *fe)
	158	{
	159	struct it913x_dev *dev = fe->tuner_priv;
675ee801	160	struct platform_device *pdev = dev->pdev;
676c350f AP	161	int ret, len;
676c350f AP	162
675ee801	163	dev_dbg(&pdev->dev, "role %u\n", dev->role);
17027b96 AP	164
17027b96 AP	165	dev->active = false;
676c350f AP	166
	167	ret = regmap_bulk_write(dev->regmap, 0x80ec40, "\x00", 1);
	168	if (ret)
	169	goto err;
	170
	171	/*
	172	* Writing '0x00' to master tuner register '0x80ec08' causes slave tuner
	173	* communication lost. Due to that, we cannot put master full sleep.
	174	*/
	175	if (dev->role == IT913X_ROLE_DUAL_MASTER)
	176	len = 4;
	177	else
	178	len = 15;
	179
675ee801	180	dev_dbg(&pdev->dev, "role %u, len %d\n", dev->role, len);
676c350f AP	181
	182	ret = regmap_bulk_write(dev->regmap, 0x80ec02,
	183	"\x3f\x1f\x3f\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
	184	len);
	185	if (ret)
	186	goto err;
	187
	188	ret = regmap_bulk_write(dev->regmap, 0x80ec12, "\x00\x00\x00\x00", 4);
	189	if (ret)
	190	goto err;
	191
	192	ret = regmap_bulk_write(dev->regmap, 0x80ec17,
	193	"\x00\x00\x00\x00\x00\x00\x00\x00\x00", 9);
	194	if (ret)
	195	goto err;
	196
	197	ret = regmap_bulk_write(dev->regmap, 0x80ec22,
	198	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 10);
	199	if (ret)
	200	goto err;
	201
	202	ret = regmap_bulk_write(dev->regmap, 0x80ec20, "\x00", 1);
	203	if (ret)
	204	goto err;
	205
	206	ret = regmap_bulk_write(dev->regmap, 0x80ec3f, "\x01", 1);
	207	if (ret)
	208	goto err;
	209
	210	return 0;
	211	err:
675ee801	212	dev_dbg(&pdev->dev, "failed %d\n", ret);
676c350f AP	213	return ret;
	214	}
	215
17027b96	216	static int it913x_set_params(struct dvb_frontend *fe)
88b38bef	217	{
a71b65e8	218	struct it913x_dev *dev = fe->tuner_priv;
675ee801	219	struct platform_device *pdev = dev->pdev;
17027b96	220	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
8da55c94	221	int ret;
17027b96 AP	222	unsigned int utmp;
	223	u32 pre_lo_freq, t_cal_freq;
	224	u16 iqik_m_cal, n_div;
	225	u8 u8tmp, n, l_band, lna_band;
3d2f18d3	226
675ee801	227	dev_dbg(&pdev->dev, "role=%u, frequency %u, bandwidth_hz %u\n",
17027b96	228	dev->role, c->frequency, c->bandwidth_hz);
3d2f18d3	229
17027b96 AP	230	if (!dev->active) {
17027b96 AP	231	ret = -EINVAL;
3d2f18d3	232	goto err;
17027b96	233	}
88b38bef	234
17027b96	235	if (c->frequency <= 74000000) {
88b38bef AP	236	n_div = 48;
88b38bef AP	237	n = 0;
17027b96	238	} else if (c->frequency <= 111000000) {
88b38bef AP	239	n_div = 32;
88b38bef AP	240	n = 1;
17027b96	241	} else if (c->frequency <= 148000000) {
88b38bef AP	242	n_div = 24;
88b38bef AP	243	n = 2;
17027b96	244	} else if (c->frequency <= 222000000) {
88b38bef AP	245	n_div = 16;
88b38bef AP	246	n = 3;
17027b96	247	} else if (c->frequency <= 296000000) {
88b38bef AP	248	n_div = 12;
88b38bef AP	249	n = 4;
17027b96	250	} else if (c->frequency <= 445000000) {
88b38bef AP	251	n_div = 8;
88b38bef AP	252	n = 5;
17027b96	253	} else if (c->frequency <= dev->fn_min) {
88b38bef AP	254	n_div = 6;
88b38bef AP	255	n = 6;
17027b96	256	} else if (c->frequency <= 950000000) {
88b38bef AP	257	n_div = 4;
88b38bef AP	258	n = 7;
17027b96	259	} else {
88b38bef AP	260	n_div = 2;
88b38bef AP	261	n = 0;
17027b96 AP	262	}
	263
	264	ret = regmap_read(dev->regmap, 0x80ed81, &utmp);
	265	if (ret)
	266	goto err;
88b38bef	267
17027b96	268	iqik_m_cal = utmp * n_div;
88b38bef	269
17027b96 AP	270	if (utmp < 0x20) {
17027b96 AP	271	if (dev->clk_mode == 0)
88b38bef AP	272	iqik_m_cal = (iqik_m_cal * 9) >> 5;
	273	else
	274	iqik_m_cal >>= 1;
	275	} else {
	276	iqik_m_cal = 0x40 - iqik_m_cal;
17027b96	277	if (dev->clk_mode == 0)
88b38bef AP	278	iqik_m_cal = ~((iqik_m_cal * 9) >> 5);
	279	else
	280	iqik_m_cal = ~(iqik_m_cal >> 1);
	281	}
	282
17027b96 AP	283	t_cal_freq = (c->frequency / 1000) * n_div * dev->fdiv;
	284	pre_lo_freq = t_cal_freq / dev->xtal;
	285	utmp = pre_lo_freq * dev->xtal;
88b38bef	286
17027b96 AP	287	if ((t_cal_freq - utmp) >= (dev->xtal >> 1))
17027b96 AP	288	pre_lo_freq++;
88b38bef	289
17027b96	290	pre_lo_freq += (u32) n << 13;
88b38bef	291	/* Frequency OMEGA_IQIK_M_CAL_MID*/
17027b96	292	t_cal_freq = pre_lo_freq + (u32)iqik_m_cal;
675ee801	293	dev_dbg(&pdev->dev, "t_cal_freq %u, pre_lo_freq %u\n",
17027b96	294	t_cal_freq, pre_lo_freq);
88b38bef	295
17027b96 AP	296	if (c->frequency <= 440000000) {
	297	l_band = 0;
	298	lna_band = 0;
	299	} else if (c->frequency <= 484000000) {
	300	l_band = 1;
	301	lna_band = 1;
	302	} else if (c->frequency <= 533000000) {
	303	l_band = 1;
	304	lna_band = 2;
	305	} else if (c->frequency <= 587000000) {
	306	l_band = 1;
	307	lna_band = 3;
	308	} else if (c->frequency <= 645000000) {
	309	l_band = 1;
	310	lna_band = 4;
	311	} else if (c->frequency <= 710000000) {
	312	l_band = 1;
	313	lna_band = 5;
	314	} else if (c->frequency <= 782000000) {
	315	l_band = 1;
	316	lna_band = 6;
	317	} else if (c->frequency <= 860000000) {
	318	l_band = 1;
	319	lna_band = 7;
	320	} else if (c->frequency <= 1492000000) {
	321	l_band = 1;
	322	lna_band = 0;
	323	} else if (c->frequency <= 1685000000) {
	324	l_band = 1;
	325	lna_band = 1;
	326	} else {
	327	ret = -EINVAL;
	328	goto err;
	329	}
	330
	331	/* XXX: latest windows driver does not set that at all */
	332	ret = regmap_write(dev->regmap, 0x80ee06, lna_band);
3d2f18d3 AP	333	if (ret)
	334	goto err;
	335
17027b96 AP	336	if (c->bandwidth_hz <= 5000000)
	337	u8tmp = 0;
	338	else if (c->bandwidth_hz <= 6000000)
	339	u8tmp = 2;
	340	else if (c->bandwidth_hz <= 7000000)
	341	u8tmp = 4;
	342	else
	343	u8tmp = 6; /* 8000000 */
	344
	345	ret = regmap_write(dev->regmap, 0x80ec56, u8tmp);
	346	if (ret)
	347	goto err;
	348
	349	/* XXX: latest windows driver sets different value (a8 != 68) */
	350	ret = regmap_write(dev->regmap, 0x80ec4c, 0xa0 \| (l_band << 3));
3d2f18d3 AP	351	if (ret)
3d2f18d3 AP	352	goto err;
88b38bef	353
17027b96 AP	354	ret = regmap_write(dev->regmap, 0x80ec4d, (t_cal_freq >> 0) & 0xff);
	355	if (ret)
	356	goto err;
88b38bef	357
17027b96	358	ret = regmap_write(dev->regmap, 0x80ec4e, (t_cal_freq >> 8) & 0xff);
3d2f18d3 AP	359	if (ret)
3d2f18d3 AP	360	goto err;
88b38bef	361
17027b96 AP	362	ret = regmap_write(dev->regmap, 0x80011e, (pre_lo_freq >> 0) & 0xff);
	363	if (ret)
	364	goto err;
	365
	366	ret = regmap_write(dev->regmap, 0x80011f, (pre_lo_freq >> 8) & 0xff);
3d2f18d3 AP	367	if (ret)
3d2f18d3 AP	368	goto err;
88b38bef	369
3d2f18d3 AP	370	return 0;
3d2f18d3 AP	371	err:
675ee801	372	dev_dbg(&pdev->dev, "failed %d\n", ret);
3d2f18d3	373	return ret;
88b38bef AP	374	}
88b38bef AP	375
88b38bef AP	376	static const struct dvb_tuner_ops it913x_tuner_ops = {
88b38bef AP	377	.info = {
17027b96	378	.name = "ITE IT913X",
88b38bef AP	379	.frequency_min = 174000000,
	380	.frequency_max = 862000000,
	381	},
	382
42432b3c AP	383	.init = it913x_init,
42432b3c AP	384	.sleep = it913x_sleep,
17027b96	385	.set_params = it913x_set_params,
88b38bef AP	386	};
88b38bef AP	387
675ee801	388	static int it913x_probe(struct platform_device *pdev)
88b38bef	389	{
675ee801 AP	390	struct it913x_platform_data *pdata = pdev->dev.platform_data;
675ee801 AP	391	struct dvb_frontend *fe = pdata->fe;
a71b65e8	392	struct it913x_dev *dev;
8efb34b2	393	const struct platform_device_id *id = platform_get_device_id(pdev);
01b461bb	394	int ret;
3b2a5e8c	395	char *chip_ver_str;
88b38bef	396
a71b65e8 AP	397	dev = kzalloc(sizeof(struct it913x_dev), GFP_KERNEL);
a71b65e8 AP	398	if (dev == NULL) {
3b2a5e8c	399	ret = -ENOMEM;
675ee801	400	dev_err(&pdev->dev, "kzalloc() failed\n");
3b2a5e8c	401	goto err;
88b38bef AP	402	}
88b38bef AP	403
675ee801 AP	404	dev->pdev = pdev;
	405	dev->regmap = pdata->regmap;
	406	dev->fe = pdata->fe;
8efb34b2	407	dev->chip_ver = id->driver_data;
675ee801	408	dev->role = pdata->role;
44af747f	409
a71b65e8	410	fe->tuner_priv = dev;
88b38bef AP	411	memcpy(&fe->ops.tuner_ops, &it913x_tuner_ops,
88b38bef AP	412	sizeof(struct dvb_tuner_ops));
675ee801	413	platform_set_drvdata(pdev, dev);
3b2a5e8c	414
a71b65e8	415	if (dev->chip_ver == 1)
3b2a5e8c	416	chip_ver_str = "AX";
a71b65e8	417	else if (dev->chip_ver == 2)
3b2a5e8c AP	418	chip_ver_str = "BX";
	419	else
	420	chip_ver_str = "??";
	421
675ee801 AP	422	dev_info(&pdev->dev, "ITE IT913X %s successfully attached\n",
	423	chip_ver_str);
	424	dev_dbg(&pdev->dev, "chip_ver %u, role %u\n", dev->chip_ver, dev->role);
3b2a5e8c AP	425	return 0;
3b2a5e8c AP	426	err:
675ee801	427	dev_dbg(&pdev->dev, "failed %d\n", ret);
3b2a5e8c AP	428	return ret;
3b2a5e8c AP	429	}
88b38bef	430
675ee801	431	static int it913x_remove(struct platform_device *pdev)
3b2a5e8c	432	{
675ee801	433	struct it913x_dev *dev = platform_get_drvdata(pdev);
a71b65e8	434	struct dvb_frontend *fe = dev->fe;
3b2a5e8c	435
675ee801	436	dev_dbg(&pdev->dev, "\n");
3b2a5e8c AP	437
	438	memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
	439	fe->tuner_priv = NULL;
a71b65e8	440	kfree(dev);
3b2a5e8c AP	441
3b2a5e8c AP	442	return 0;
88b38bef	443	}
3b2a5e8c	444
8efb34b2 AP	445	static const struct platform_device_id it913x_id_table[] = {
	446	{"it9133ax-tuner", 1},
	447	{"it9133bx-tuner", 2},
	448	{},
	449	};
	450	MODULE_DEVICE_TABLE(platform, it913x_id_table);
	451
675ee801	452	static struct platform_driver it913x_driver = {
3b2a5e8c	453	.driver = {
3b2a5e8c	454	.name = "it913x",
d8d86366	455	.suppress_bind_attrs = true,
3b2a5e8c AP	456	},
	457	.probe = it913x_probe,
	458	.remove = it913x_remove,
8efb34b2	459	.id_table = it913x_id_table,
3b2a5e8c AP	460	};
3b2a5e8c AP	461
675ee801	462	module_platform_driver(it913x_driver);
88b38bef	463
17027b96	464	MODULE_DESCRIPTION("ITE IT913X silicon tuner driver");
88b38bef AP	465	MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
88b38bef AP	466	MODULE_LICENSE("GPL");