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