drivers/media/tuners/it913x.c

   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");