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 26 struct 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 39 static 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; 154 err: 155 dev_dbg(&dev->client->dev, "failed %d\n", ret); 156 return ret; 157 } 158 159 static 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; 212 err: 213 dev_dbg(&dev->client->dev, "failed %d\n", ret); 214 return ret; 215 } 216 217 static 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; 371 err: 372 dev_dbg(&dev->client->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 = 174000000, 380 .frequency_max = 862000000, 381 }, 382 383 .init = it913x_init, 384 .sleep = it913x_sleep, 385 .set_params = it913x_set_params, 386 }; 387 388 static 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 436 err_kfree: 437 kfree(dev); 438 err: 439 dev_dbg(&client->dev, "failed %d\n", ret); 440 return ret; 441 } 442 443 static 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 458 static const struct i2c_device_id it913x_id_table[] = { 459 {"it913x", 0}, 460 {} 461 }; 462 MODULE_DEVICE_TABLE(i2c, it913x_id_table); 463 464 static struct i2c_driver it913x_driver = { 465 .driver = { 466 .owner = THIS_MODULE, 467 .name = "it913x", 468 }, 469 .probe = it913x_probe, 470 .remove = it913x_remove, 471 .id_table = it913x_id_table, 472 }; 473 474 module_i2c_driver(it913x_driver); 475 476 MODULE_DESCRIPTION("ITE IT913X silicon tuner driver"); 477 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 478 MODULE_LICENSE("GPL"); 479