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