?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Don't clone maps from parent when synthesizing forks
[linux/fpc-iii.git] / drivers / media / tuners / it913x.c
blobb5eb39921e955bbe86ac1b6a3184ee2c3293a6e1
1 /*
2 * ITE IT913X silicon tuner driver
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.
17 */
18
19 #include "it913x.h"
20 #include <linux/platform_device.h>
21 #include <linux/regmap.h>
22
23 struct it913x_dev {
24 struct platform_device *pdev;
25 struct regmap *regmap;
26 struct dvb_frontend *fe;
27 u8 chip_ver:2;
28 u8 role:2;
29 u16 xtal;
30 u8 fdiv;
31 u8 clk_mode;
32 u32 fn_min;
33 bool active;
34 };
35
36 static int it913x_init(struct dvb_frontend *fe)
37 {
38 struct it913x_dev *dev = fe->tuner_priv;
39 struct platform_device *pdev = dev->pdev;
40 int ret;
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};
44 unsigned long timeout;
45
46 dev_dbg(&pdev->dev, "role %u\n", dev->role);
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) {
59 case 0:
60 /* 12.000 MHz */
61 dev->clk_mode = utmp;
62 dev->xtal = 2000;
63 dev->fdiv = 3;
64 iqik_m_cal = 16;
65 break;
66 case 1:
67 /* 20.480 MHz */
68 dev->clk_mode = utmp;
69 dev->xtal = 640;
70 dev->fdiv = 1;
71 iqik_m_cal = 6;
72 break;
73 default:
74 dev_err(&pdev->dev, "unknown clock identifier %d\n", utmp);
75 goto err;
76 }
77
78 ret = regmap_read(dev->regmap, 0x80ed03, &utmp);
79 if (ret)
80 goto err;
81
82 else if (utmp < ARRAY_SIZE(nv))
83 nv_val = nv[utmp];
84 else
85 nv_val = 2;
86
87 #define TIMEOUT 50
88 timeout = jiffies + msecs_to_jiffies(TIMEOUT);
89 while (!time_after(jiffies, timeout)) {
90 ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2);
91 if (ret)
92 goto err;
93
94 utmp = (buf[1] << 8) | (buf[0] << 0);
95 if (utmp)
96 break;
97 }
98
99 dev_dbg(&pdev->dev, "r_fbc_m_bdry took %u ms, val %u\n",
100 jiffies_to_msecs(jiffies) -
101 (jiffies_to_msecs(timeout) - TIMEOUT), utmp);
102
103 dev->fn_min = dev->xtal * utmp;
104 dev->fn_min /= (dev->fdiv * nv_val);
105 dev->fn_min *= 1000;
106 dev_dbg(&pdev->dev, "fn_min %u\n", dev->fn_min);
107
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 */
114 if (dev->chip_ver == 1) {
115 #define TIMEOUT 50
116 timeout = jiffies + msecs_to_jiffies(TIMEOUT);
117 while (!time_after(jiffies, timeout)) {
118 ret = regmap_read(dev->regmap, 0x80ec82, &utmp);
119 if (ret)
120 goto err;
121
122 if (utmp)
123 break;
124 }
125
126 dev_dbg(&pdev->dev, "p_tsm_init_mode took %u ms, val %u\n",
127 jiffies_to_msecs(jiffies) -
128 (jiffies_to_msecs(timeout) - TIMEOUT), utmp);
129 } else {
130 msleep(50);
131 }
132
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;
150
151 return 0;
152 err:
153 dev_dbg(&pdev->dev, "failed %d\n", ret);
154 return ret;
155 }
156
157 static int it913x_sleep(struct dvb_frontend *fe)
158 {
159 struct it913x_dev *dev = fe->tuner_priv;
160 struct platform_device *pdev = dev->pdev;
161 int ret, len;
162
163 dev_dbg(&pdev->dev, "role %u\n", dev->role);
164
165 dev->active = false;
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
180 dev_dbg(&pdev->dev, "role %u, len %d\n", dev->role, len);
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:
212 dev_dbg(&pdev->dev, "failed %d\n", ret);
213 return ret;
214 }
215
216 static int it913x_set_params(struct dvb_frontend *fe)
217 {
218 struct it913x_dev *dev = fe->tuner_priv;
219 struct platform_device *pdev = dev->pdev;
220 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
221 int ret;
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;
226
227 dev_dbg(&pdev->dev, "role=%u, frequency %u, bandwidth_hz %u\n",
228 dev->role, c->frequency, c->bandwidth_hz);
229
230 if (!dev->active) {
231 ret = -EINVAL;
232 goto err;
233 }
234
235 if (c->frequency <= 74000000) {
236 n_div = 48;
237 n = 0;
238 } else if (c->frequency <= 111000000) {
239 n_div = 32;
240 n = 1;
241 } else if (c->frequency <= 148000000) {
242 n_div = 24;
243 n = 2;
244 } else if (c->frequency <= 222000000) {
245 n_div = 16;
246 n = 3;
247 } else if (c->frequency <= 296000000) {
248 n_div = 12;
249 n = 4;
250 } else if (c->frequency <= 445000000) {
251 n_div = 8;
252 n = 5;
253 } else if (c->frequency <= dev->fn_min) {
254 n_div = 6;
255 n = 6;
256 } else if (c->frequency <= 950000000) {
257 n_div = 4;
258 n = 7;
259 } else {
260 n_div = 2;
261 n = 0;
262 }
263
264 ret = regmap_read(dev->regmap, 0x80ed81, &utmp);
265 if (ret)
266 goto err;
267
268 iqik_m_cal = utmp * n_div;
269
270 if (utmp < 0x20) {
271 if (dev->clk_mode == 0)
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;
277 if (dev->clk_mode == 0)
278 iqik_m_cal = ~((iqik_m_cal * 9) >> 5);
279 else
280 iqik_m_cal = ~(iqik_m_cal >> 1);
281 }
282
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;
286
287 if ((t_cal_freq - utmp) >= (dev->xtal >> 1))
288 pre_lo_freq++;
289
290 pre_lo_freq += (u32) n << 13;
291 /* Frequency OMEGA_IQIK_M_CAL_MID*/
292 t_cal_freq = pre_lo_freq + (u32)iqik_m_cal;
293 dev_dbg(&pdev->dev, "t_cal_freq %u, pre_lo_freq %u\n",
294 t_cal_freq, pre_lo_freq);
295
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);
333 if (ret)
334 goto err;
335
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));
351 if (ret)
352 goto err;
353
354 ret = regmap_write(dev->regmap, 0x80ec4d, (t_cal_freq >> 0) & 0xff);
355 if (ret)
356 goto err;
357
358 ret = regmap_write(dev->regmap, 0x80ec4e, (t_cal_freq >> 8) & 0xff);
359 if (ret)
360 goto err;
361
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);
367 if (ret)
368 goto err;
369
370 return 0;
371 err:
372 dev_dbg(&pdev->dev, "failed %d\n", ret);
373 return ret;
374 }
375
376 static const struct dvb_tuner_ops it913x_tuner_ops = {
377 .info = {
378 .name = "ITE IT913X",
379 .frequency_min_hz = 174 * MHz,
380 .frequency_max_hz = 862 * MHz,
381 },
382
383 .init = it913x_init,
384 .sleep = it913x_sleep,
385 .set_params = it913x_set_params,
386 };
387
388 static int it913x_probe(struct platform_device *pdev)
389 {
390 struct it913x_platform_data *pdata = pdev->dev.platform_data;
391 struct dvb_frontend *fe = pdata->fe;
392 struct it913x_dev *dev;
393 const struct platform_device_id *id = platform_get_device_id(pdev);
394 int ret;
395 char *chip_ver_str;
396
397 dev = kzalloc(sizeof(struct it913x_dev), GFP_KERNEL);
398 if (dev == NULL) {
399 ret = -ENOMEM;
400 dev_err(&pdev->dev, "kzalloc() failed\n");
401 goto err;
402 }
403
404 dev->pdev = pdev;
405 dev->regmap = pdata->regmap;
406 dev->fe = pdata->fe;
407 dev->chip_ver = id->driver_data;
408 dev->role = pdata->role;
409
410 fe->tuner_priv = dev;
411 memcpy(&fe->ops.tuner_ops, &it913x_tuner_ops,
412 sizeof(struct dvb_tuner_ops));
413 platform_set_drvdata(pdev, dev);
414
415 if (dev->chip_ver == 1)
416 chip_ver_str = "AX";
417 else if (dev->chip_ver == 2)
418 chip_ver_str = "BX";
419 else
420 chip_ver_str = "??";
421
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);
425 return 0;
426 err:
427 dev_dbg(&pdev->dev, "failed %d\n", ret);
428 return ret;
429 }
430
431 static int it913x_remove(struct platform_device *pdev)
432 {
433 struct it913x_dev *dev = platform_get_drvdata(pdev);
434 struct dvb_frontend *fe = dev->fe;
435
436 dev_dbg(&pdev->dev, "\n");
437
438 memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
439 fe->tuner_priv = NULL;
440 kfree(dev);
441
442 return 0;
443 }
444
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
452 static struct platform_driver it913x_driver = {
453 .driver = {
454 .name = "it913x",
455 .suppress_bind_attrs = true,
456 },
457 .probe = it913x_probe,
458 .remove = it913x_remove,
459 .id_table = it913x_id_table,
460 };
461
462 module_platform_driver(it913x_driver);
463
464 MODULE_DESCRIPTION("ITE IT913X silicon tuner driver");
465 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
466 MODULE_LICENSE("GPL");
Linux with added FPC-III support