Loading...
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 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;
143err:
144 dev_dbg(&pdev->dev, "failed %d\n", ret);
145 return ret;
146}
147
148static 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;
202err:
203 dev_dbg(&pdev->dev, "failed %d\n", ret);
204 return ret;
205}
206
207static 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;
362err:
363 dev_dbg(&pdev->dev, "failed %d\n", ret);
364 return ret;
365}
366
367static 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
379static 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;
417err:
418 dev_dbg(&pdev->dev, "failed %d\n", ret);
419 return ret;
420}
421
422static 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
434static const struct platform_device_id it913x_id_table[] = {
435 {"it9133ax-tuner", 1},
436 {"it9133bx-tuner", 2},
437 {},
438};
439MODULE_DEVICE_TABLE(platform, it913x_id_table);
440
441static 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
451module_platform_driver(it913x_driver);
452
453MODULE_DESCRIPTION("ITE IT913X silicon tuner driver");
454MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
455MODULE_LICENSE("GPL");
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 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.=
21 */
22
23#include "it913x.h"
24#include <linux/regmap.h>
25
26struct it913x_dev {
27 struct i2c_client *client;
28 struct regmap *regmap;
29 struct dvb_frontend *fe;
30 u8 chip_ver:2;
31 u8 role:2;
32 u16 xtal;
33 u8 fdiv;
34 u8 clk_mode;
35 u32 fn_min;
36 bool active;
37};
38
39static int it913x_init(struct dvb_frontend *fe)
40{
41 struct it913x_dev *dev = fe->tuner_priv;
42 int ret;
43 unsigned int utmp;
44 u8 iqik_m_cal, nv_val, buf[2];
45 static const u8 nv[] = {48, 32, 24, 16, 12, 8, 6, 4, 2};
46 unsigned long timeout;
47
48 dev_dbg(&dev->client->dev, "role %u\n", dev->role);
49
50 ret = regmap_write(dev->regmap, 0x80ec4c, 0x68);
51 if (ret)
52 goto err;
53
54 usleep_range(10000, 100000);
55
56 ret = regmap_read(dev->regmap, 0x80ec86, &utmp);
57 if (ret)
58 goto err;
59
60 switch (utmp) {
61 case 0:
62 /* 12.000 MHz */
63 dev->clk_mode = utmp;
64 dev->xtal = 2000;
65 dev->fdiv = 3;
66 iqik_m_cal = 16;
67 break;
68 case 1:
69 /* 20.480 MHz */
70 dev->clk_mode = utmp;
71 dev->xtal = 640;
72 dev->fdiv = 1;
73 iqik_m_cal = 6;
74 break;
75 default:
76 dev_err(&dev->client->dev, "unknown clock identifier %d\n", utmp);
77 goto err;
78 }
79
80 ret = regmap_read(dev->regmap, 0x80ed03, &utmp);
81 if (ret)
82 goto err;
83
84 else if (utmp < ARRAY_SIZE(nv))
85 nv_val = nv[utmp];
86 else
87 nv_val = 2;
88
89 #define TIMEOUT 50
90 timeout = jiffies + msecs_to_jiffies(TIMEOUT);
91 while (!time_after(jiffies, timeout)) {
92 ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2);
93 if (ret)
94 goto err;
95
96 utmp = (buf[1] << 8) | (buf[0] << 0);
97 if (utmp)
98 break;
99 }
100
101 dev_dbg(&dev->client->dev, "r_fbc_m_bdry took %u ms, val %u\n",
102 jiffies_to_msecs(jiffies) -
103 (jiffies_to_msecs(timeout) - TIMEOUT), utmp);
104
105 dev->fn_min = dev->xtal * utmp;
106 dev->fn_min /= (dev->fdiv * nv_val);
107 dev->fn_min *= 1000;
108 dev_dbg(&dev->client->dev, "fn_min %u\n", dev->fn_min);
109
110 /*
111 * Chip version BX never sets that flag so we just wait 50ms in that
112 * case. It is possible poll BX similarly than AX and then timeout in
113 * order to get 50ms delay, but that causes about 120 extra I2C
114 * messages. As for now, we just wait and reduce IO.
115 */
116 if (dev->chip_ver == 1) {
117 #define TIMEOUT 50
118 timeout = jiffies + msecs_to_jiffies(TIMEOUT);
119 while (!time_after(jiffies, timeout)) {
120 ret = regmap_read(dev->regmap, 0x80ec82, &utmp);
121 if (ret)
122 goto err;
123
124 if (utmp)
125 break;
126 }
127
128 dev_dbg(&dev->client->dev, "p_tsm_init_mode took %u ms, val %u\n",
129 jiffies_to_msecs(jiffies) -
130 (jiffies_to_msecs(timeout) - TIMEOUT), utmp);
131 } else {
132 msleep(50);
133 }
134
135 ret = regmap_write(dev->regmap, 0x80ed81, iqik_m_cal);
136 if (ret)
137 goto err;
138
139 ret = regmap_write(dev->regmap, 0x80ec57, 0x00);
140 if (ret)
141 goto err;
142
143 ret = regmap_write(dev->regmap, 0x80ec58, 0x00);
144 if (ret)
145 goto err;
146
147 ret = regmap_write(dev->regmap, 0x80ec40, 0x01);
148 if (ret)
149 goto err;
150
151 dev->active = true;
152
153 return 0;
154err:
155 dev_dbg(&dev->client->dev, "failed %d\n", ret);
156 return ret;
157}
158
159static int it913x_sleep(struct dvb_frontend *fe)
160{
161 struct it913x_dev *dev = fe->tuner_priv;
162 int ret, len;
163
164 dev_dbg(&dev->client->dev, "role %u\n", dev->role);
165
166 dev->active = false;
167
168 ret = regmap_bulk_write(dev->regmap, 0x80ec40, "\x00", 1);
169 if (ret)
170 goto err;
171
172 /*
173 * Writing '0x00' to master tuner register '0x80ec08' causes slave tuner
174 * communication lost. Due to that, we cannot put master full sleep.
175 */
176 if (dev->role == IT913X_ROLE_DUAL_MASTER)
177 len = 4;
178 else
179 len = 15;
180
181 dev_dbg(&dev->client->dev, "role %u, len %d\n", dev->role, len);
182
183 ret = regmap_bulk_write(dev->regmap, 0x80ec02,
184 "\x3f\x1f\x3f\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
185 len);
186 if (ret)
187 goto err;
188
189 ret = regmap_bulk_write(dev->regmap, 0x80ec12, "\x00\x00\x00\x00", 4);
190 if (ret)
191 goto err;
192
193 ret = regmap_bulk_write(dev->regmap, 0x80ec17,
194 "\x00\x00\x00\x00\x00\x00\x00\x00\x00", 9);
195 if (ret)
196 goto err;
197
198 ret = regmap_bulk_write(dev->regmap, 0x80ec22,
199 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 10);
200 if (ret)
201 goto err;
202
203 ret = regmap_bulk_write(dev->regmap, 0x80ec20, "\x00", 1);
204 if (ret)
205 goto err;
206
207 ret = regmap_bulk_write(dev->regmap, 0x80ec3f, "\x01", 1);
208 if (ret)
209 goto err;
210
211 return 0;
212err:
213 dev_dbg(&dev->client->dev, "failed %d\n", ret);
214 return ret;
215}
216
217static int it913x_set_params(struct dvb_frontend *fe)
218{
219 struct it913x_dev *dev = fe->tuner_priv;
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(&dev->client->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(&dev->client->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;
371err:
372 dev_dbg(&dev->client->dev, "failed %d\n", ret);
373 return ret;
374}
375
376static const struct dvb_tuner_ops it913x_tuner_ops = {
377 .info = {
378 .name = "ITE IT913X",
379 .frequency_min = 174000000,
380 .frequency_max = 862000000,
381 },
382
383 .init = it913x_init,
384 .sleep = it913x_sleep,
385 .set_params = it913x_set_params,
386};
387
388static int it913x_probe(struct i2c_client *client,
389 const struct i2c_device_id *id)
390{
391 struct it913x_config *cfg = client->dev.platform_data;
392 struct dvb_frontend *fe = cfg->fe;
393 struct it913x_dev *dev;
394 int ret;
395 char *chip_ver_str;
396 static const struct regmap_config regmap_config = {
397 .reg_bits = 24,
398 .val_bits = 8,
399 };
400
401 dev = kzalloc(sizeof(struct it913x_dev), GFP_KERNEL);
402 if (dev == NULL) {
403 ret = -ENOMEM;
404 dev_err(&client->dev, "kzalloc() failed\n");
405 goto err;
406 }
407
408 dev->client = client;
409 dev->fe = cfg->fe;
410 dev->chip_ver = cfg->chip_ver;
411 dev->role = cfg->role;
412 dev->regmap = regmap_init_i2c(client, ®map_config);
413 if (IS_ERR(dev->regmap)) {
414 ret = PTR_ERR(dev->regmap);
415 goto err_kfree;
416 }
417
418 fe->tuner_priv = dev;
419 memcpy(&fe->ops.tuner_ops, &it913x_tuner_ops,
420 sizeof(struct dvb_tuner_ops));
421 i2c_set_clientdata(client, dev);
422
423 if (dev->chip_ver == 1)
424 chip_ver_str = "AX";
425 else if (dev->chip_ver == 2)
426 chip_ver_str = "BX";
427 else
428 chip_ver_str = "??";
429
430 dev_info(&dev->client->dev, "ITE IT913X %s successfully attached\n",
431 chip_ver_str);
432 dev_dbg(&dev->client->dev, "chip_ver %u, role %u\n",
433 dev->chip_ver, dev->role);
434 return 0;
435
436err_kfree:
437 kfree(dev);
438err:
439 dev_dbg(&client->dev, "failed %d\n", ret);
440 return ret;
441}
442
443static int it913x_remove(struct i2c_client *client)
444{
445 struct it913x_dev *dev = i2c_get_clientdata(client);
446 struct dvb_frontend *fe = dev->fe;
447
448 dev_dbg(&client->dev, "\n");
449
450 memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
451 fe->tuner_priv = NULL;
452 regmap_exit(dev->regmap);
453 kfree(dev);
454
455 return 0;
456}
457
458static const struct i2c_device_id it913x_id_table[] = {
459 {"it913x", 0},
460 {}
461};
462MODULE_DEVICE_TABLE(i2c, it913x_id_table);
463
464static struct i2c_driver it913x_driver = {
465 .driver = {
466 .name = "it913x",
467 },
468 .probe = it913x_probe,
469 .remove = it913x_remove,
470 .id_table = it913x_id_table,
471};
472
473module_i2c_driver(it913x_driver);
474
475MODULE_DESCRIPTION("ITE IT913X silicon tuner driver");
476MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
477MODULE_LICENSE("GPL");