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