media/tuners/it913x.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * ITE IT913X silicon tuner driver
0004  *
0005  *  Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com)
0006  *  IT9137 Copyright (C) ITE Tech Inc.
0007  */
0008
0009 #include "it913x.h"
0010 #include <linux/platform_device.h>
0011 #include <linux/regmap.h>
0012
0013 struct it913x_dev {
0014     struct platform_device *pdev;
0015     struct regmap *regmap;
0016     struct dvb_frontend *fe;
0017     u8 chip_ver:2;
0018     u8 role:2;
0019     u16 xtal;
0020     u8 fdiv;
0021     u8 clk_mode;
0022     u32 fn_min;
0023     bool active;
0024 };
0025
0026 static int it913x_init(struct dvb_frontend *fe)
0027 {
0028     struct it913x_dev *dev = fe->tuner_priv;
0029     struct platform_device *pdev = dev->pdev;
0030     int ret;
0031     unsigned int utmp;
0032     u8 iqik_m_cal, nv_val, buf[2];
0033     static const u8 nv[] = {48, 32, 24, 16, 12, 8, 6, 4, 2};
0034     unsigned long timeout;
0035
0036     dev_dbg(&pdev->dev, "role %u\n", dev->role);
0037
0038     ret = regmap_write(dev->regmap, 0x80ec4c, 0x68);
0039     if (ret)
0040         goto err;
0041
0042     usleep_range(10000, 100000);
0043
0044     ret = regmap_read(dev->regmap, 0x80ec86, &utmp);
0045     if (ret)
0046         goto err;
0047
0048     switch (utmp) {
0049     case 0:
0050         /* 12.000 MHz */
0051         dev->clk_mode = utmp;
0052         dev->xtal = 2000;
0053         dev->fdiv = 3;
0054         iqik_m_cal = 16;
0055         break;
0056     case 1:
0057         /* 20.480 MHz */
0058         dev->clk_mode = utmp;
0059         dev->xtal = 640;
0060         dev->fdiv = 1;
0061         iqik_m_cal = 6;
0062         break;
0063     default:
0064         dev_err(&pdev->dev, "unknown clock identifier %d\n", utmp);
0065         ret = -EINVAL;
0066         goto err;
0067     }
0068
0069     ret = regmap_read(dev->regmap, 0x80ed03,  &utmp);
0070     if (ret)
0071         goto err;
0072
0073     else if (utmp < ARRAY_SIZE(nv))
0074         nv_val = nv[utmp];
0075     else
0076         nv_val = 2;
0077
0078     #define TIMEOUT 50
0079     timeout = jiffies + msecs_to_jiffies(TIMEOUT);
0080     while (!time_after(jiffies, timeout)) {
0081         ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2);
0082         if (ret)
0083             goto err;
0084
0085         utmp = (buf[1] << 8) | (buf[0] << 0);
0086         if (utmp)
0087             break;
0088     }
0089
0090     dev_dbg(&pdev->dev, "r_fbc_m_bdry took %u ms, val %u\n",
0091             jiffies_to_msecs(jiffies) -
0092             (jiffies_to_msecs(timeout) - TIMEOUT), utmp);
0093
0094     dev->fn_min = dev->xtal * utmp;
0095     dev->fn_min /= (dev->fdiv * nv_val);
0096     dev->fn_min *= 1000;
0097     dev_dbg(&pdev->dev, "fn_min %u\n", dev->fn_min);
0098
0099     /*
0100      * Chip version BX never sets that flag so we just wait 50ms in that
0101      * case. It is possible poll BX similarly than AX and then timeout in
0102      * order to get 50ms delay, but that causes about 120 extra I2C
0103      * messages. As for now, we just wait and reduce IO.
0104      */
0105     if (dev->chip_ver == 1) {
0106         #define TIMEOUT 50
0107         timeout = jiffies + msecs_to_jiffies(TIMEOUT);
0108         while (!time_after(jiffies, timeout)) {
0109             ret = regmap_read(dev->regmap, 0x80ec82, &utmp);
0110             if (ret)
0111                 goto err;
0112
0113             if (utmp)
0114                 break;
0115         }
0116
0117         dev_dbg(&pdev->dev, "p_tsm_init_mode took %u ms, val %u\n",
0118                 jiffies_to_msecs(jiffies) -
0119                 (jiffies_to_msecs(timeout) - TIMEOUT), utmp);
0120     } else {
0121         msleep(50);
0122     }
0123
0124     ret = regmap_write(dev->regmap, 0x80ed81, iqik_m_cal);
0125     if (ret)
0126         goto err;
0127
0128     ret = regmap_write(dev->regmap, 0x80ec57, 0x00);
0129     if (ret)
0130         goto err;
0131
0132     ret = regmap_write(dev->regmap, 0x80ec58, 0x00);
0133     if (ret)
0134         goto err;
0135
0136     ret = regmap_write(dev->regmap, 0x80ec40, 0x01);
0137     if (ret)
0138         goto err;
0139
0140     dev->active = true;
0141
0142     return 0;
0143 err:
0144     dev_dbg(&pdev->dev, "failed %d\n", ret);
0145     return ret;
0146 }
0147
0148 static int it913x_sleep(struct dvb_frontend *fe)
0149 {
0150     struct it913x_dev *dev = fe->tuner_priv;
0151     struct platform_device *pdev = dev->pdev;
0152     int ret, len;
0153
0154     dev_dbg(&pdev->dev, "role %u\n", dev->role);
0155
0156     dev->active = false;
0157
0158     ret  = regmap_bulk_write(dev->regmap, 0x80ec40, "\x00", 1);
0159     if (ret)
0160         goto err;
0161
0162     /*
0163      * Writing '0x00' to master tuner register '0x80ec08' causes slave tuner
0164      * communication lost. Due to that, we cannot put master full sleep.
0165      */
0166     if (dev->role == IT913X_ROLE_DUAL_MASTER)
0167         len = 4;
0168     else
0169         len = 15;
0170
0171     dev_dbg(&pdev->dev, "role %u, len %d\n", dev->role, len);
0172
0173     ret = regmap_bulk_write(dev->regmap, 0x80ec02,
0174             "\x3f\x1f\x3f\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
0175             len);
0176     if (ret)
0177         goto err;
0178
0179     ret = regmap_bulk_write(dev->regmap, 0x80ec12, "\x00\x00\x00\x00", 4);
0180     if (ret)
0181         goto err;
0182
0183     ret = regmap_bulk_write(dev->regmap, 0x80ec17,
0184             "\x00\x00\x00\x00\x00\x00\x00\x00\x00", 9);
0185     if (ret)
0186         goto err;
0187
0188     ret = regmap_bulk_write(dev->regmap, 0x80ec22,
0189             "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 10);
0190     if (ret)
0191         goto err;
0192
0193     ret = regmap_bulk_write(dev->regmap, 0x80ec20, "\x00", 1);
0194     if (ret)
0195         goto err;
0196
0197     ret = regmap_bulk_write(dev->regmap, 0x80ec3f, "\x01", 1);
0198     if (ret)
0199         goto err;
0200
0201     return 0;
0202 err:
0203     dev_dbg(&pdev->dev, "failed %d\n", ret);
0204     return ret;
0205 }
0206
0207 static int it913x_set_params(struct dvb_frontend *fe)
0208 {
0209     struct it913x_dev *dev = fe->tuner_priv;
0210     struct platform_device *pdev = dev->pdev;
0211     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0212     int ret;
0213     unsigned int utmp;
0214     u32 pre_lo_freq, t_cal_freq;
0215     u16 iqik_m_cal, n_div;
0216     u8 u8tmp, n, l_band, lna_band;
0217
0218     dev_dbg(&pdev->dev, "role=%u, frequency %u, bandwidth_hz %u\n",
0219             dev->role, c->frequency, c->bandwidth_hz);
0220
0221     if (!dev->active) {
0222         ret = -EINVAL;
0223         goto err;
0224     }
0225
0226     if (c->frequency <=         74000000) {
0227         n_div = 48;
0228         n = 0;
0229     } else if (c->frequency <= 111000000) {
0230         n_div = 32;
0231         n = 1;
0232     } else if (c->frequency <= 148000000) {
0233         n_div = 24;
0234         n = 2;
0235     } else if (c->frequency <= 222000000) {
0236         n_div = 16;
0237         n = 3;
0238     } else if (c->frequency <= 296000000) {
0239         n_div = 12;
0240         n = 4;
0241     } else if (c->frequency <= 445000000) {
0242         n_div = 8;
0243         n = 5;
0244     } else if (c->frequency <= dev->fn_min) {
0245         n_div = 6;
0246         n = 6;
0247     } else if (c->frequency <= 950000000) {
0248         n_div = 4;
0249         n = 7;
0250     } else {
0251         n_div = 2;
0252         n = 0;
0253     }
0254
0255     ret = regmap_read(dev->regmap, 0x80ed81, &utmp);
0256     if (ret)
0257         goto err;
0258
0259     iqik_m_cal = utmp * n_div;
0260
0261     if (utmp < 0x20) {
0262         if (dev->clk_mode == 0)
0263             iqik_m_cal = (iqik_m_cal * 9) >> 5;
0264         else
0265             iqik_m_cal >>= 1;
0266     } else {
0267         iqik_m_cal = 0x40 - iqik_m_cal;
0268         if (dev->clk_mode == 0)
0269             iqik_m_cal = ~((iqik_m_cal * 9) >> 5);
0270         else
0271             iqik_m_cal = ~(iqik_m_cal >> 1);
0272     }
0273
0274     t_cal_freq = (c->frequency / 1000) * n_div * dev->fdiv;
0275     pre_lo_freq = t_cal_freq / dev->xtal;
0276     utmp = pre_lo_freq * dev->xtal;
0277
0278     if ((t_cal_freq - utmp) >= (dev->xtal >> 1))
0279         pre_lo_freq++;
0280
0281     pre_lo_freq += (u32) n << 13;
0282     /* Frequency OMEGA_IQIK_M_CAL_MID*/
0283     t_cal_freq = pre_lo_freq + (u32)iqik_m_cal;
0284     dev_dbg(&pdev->dev, "t_cal_freq %u, pre_lo_freq %u\n",
0285             t_cal_freq, pre_lo_freq);
0286
0287     if (c->frequency <=         440000000) {
0288         l_band = 0;
0289         lna_band = 0;
0290     } else if (c->frequency <=  484000000) {
0291         l_band = 1;
0292         lna_band = 1;
0293     } else if (c->frequency <=  533000000) {
0294         l_band = 1;
0295         lna_band = 2;
0296     } else if (c->frequency <=  587000000) {
0297         l_band = 1;
0298         lna_band = 3;
0299     } else if (c->frequency <=  645000000) {
0300         l_band = 1;
0301         lna_band = 4;
0302     } else if (c->frequency <=  710000000) {
0303         l_band = 1;
0304         lna_band = 5;
0305     } else if (c->frequency <=  782000000) {
0306         l_band = 1;
0307         lna_band = 6;
0308     } else if (c->frequency <=  860000000) {
0309         l_band = 1;
0310         lna_band = 7;
0311     } else if (c->frequency <= 1492000000) {
0312         l_band = 1;
0313         lna_band = 0;
0314     } else if (c->frequency <= 1685000000) {
0315         l_band = 1;
0316         lna_band = 1;
0317     } else {
0318         ret = -EINVAL;
0319         goto err;
0320     }
0321
0322     /* XXX: latest windows driver does not set that at all */
0323     ret = regmap_write(dev->regmap, 0x80ee06, lna_band);
0324     if (ret)
0325         goto err;
0326
0327     if (c->bandwidth_hz <=      5000000)
0328         u8tmp = 0;
0329     else if (c->bandwidth_hz <= 6000000)
0330         u8tmp = 2;
0331     else if (c->bandwidth_hz <= 7000000)
0332         u8tmp = 4;
0333     else
0334         u8tmp = 6;       /* 8000000 */
0335
0336     ret = regmap_write(dev->regmap, 0x80ec56, u8tmp);
0337     if (ret)
0338         goto err;
0339
0340     /* XXX: latest windows driver sets different value (a8 != 68) */
0341     ret = regmap_write(dev->regmap, 0x80ec4c, 0xa0 | (l_band << 3));
0342     if (ret)
0343         goto err;
0344
0345     ret = regmap_write(dev->regmap, 0x80ec4d, (t_cal_freq >> 0) & 0xff);
0346     if (ret)
0347         goto err;
0348
0349     ret = regmap_write(dev->regmap, 0x80ec4e, (t_cal_freq >> 8) & 0xff);
0350     if (ret)
0351         goto err;
0352
0353     ret = regmap_write(dev->regmap, 0x80011e, (pre_lo_freq >> 0) & 0xff);
0354     if (ret)
0355         goto err;
0356
0357     ret = regmap_write(dev->regmap, 0x80011f, (pre_lo_freq >> 8) & 0xff);
0358     if (ret)
0359         goto err;
0360
0361     return 0;
0362 err:
0363     dev_dbg(&pdev->dev, "failed %d\n", ret);
0364     return ret;
0365 }
0366
0367 static const struct dvb_tuner_ops it913x_tuner_ops = {
0368     .info = {
0369         .name             = "ITE IT913X",
0370         .frequency_min_hz = 174 * MHz,
0371         .frequency_max_hz = 862 * MHz,
0372     },
0373
0374     .init = it913x_init,
0375     .sleep = it913x_sleep,
0376     .set_params = it913x_set_params,
0377 };
0378
0379 static int it913x_probe(struct platform_device *pdev)
0380 {
0381     struct it913x_platform_data *pdata = pdev->dev.platform_data;
0382     struct dvb_frontend *fe = pdata->fe;
0383     struct it913x_dev *dev;
0384     const struct platform_device_id *id = platform_get_device_id(pdev);
0385     int ret;
0386     char *chip_ver_str;
0387
0388     dev = kzalloc(sizeof(struct it913x_dev), GFP_KERNEL);
0389     if (dev == NULL) {
0390         ret = -ENOMEM;
0391         dev_err(&pdev->dev, "kzalloc() failed\n");
0392         goto err;
0393     }
0394
0395     dev->pdev = pdev;
0396     dev->regmap = pdata->regmap;
0397     dev->fe = pdata->fe;
0398     dev->chip_ver = id->driver_data;
0399     dev->role = pdata->role;
0400
0401     fe->tuner_priv = dev;
0402     memcpy(&fe->ops.tuner_ops, &it913x_tuner_ops,
0403             sizeof(struct dvb_tuner_ops));
0404     platform_set_drvdata(pdev, dev);
0405
0406     if (dev->chip_ver == 1)
0407         chip_ver_str = "AX";
0408     else if (dev->chip_ver == 2)
0409         chip_ver_str = "BX";
0410     else
0411         chip_ver_str = "??";
0412
0413     dev_info(&pdev->dev, "ITE IT913X %s successfully attached\n",
0414          chip_ver_str);
0415     dev_dbg(&pdev->dev, "chip_ver %u, role %u\n", dev->chip_ver, dev->role);
0416     return 0;
0417 err:
0418     dev_dbg(&pdev->dev, "failed %d\n", ret);
0419     return ret;
0420 }
0421
0422 static int it913x_remove(struct platform_device *pdev)
0423 {
0424     struct it913x_dev *dev = platform_get_drvdata(pdev);
0425     struct dvb_frontend *fe = dev->fe;
0426
0427     dev_dbg(&pdev->dev, "\n");
0428
0429     memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
0430     fe->tuner_priv = NULL;
0431     kfree(dev);
0432
0433     return 0;
0434 }
0435
0436 static const struct platform_device_id it913x_id_table[] = {
0437     {"it9133ax-tuner", 1},
0438     {"it9133bx-tuner", 2},
0439     {},
0440 };
0441 MODULE_DEVICE_TABLE(platform, it913x_id_table);
0442
0443 static struct platform_driver it913x_driver = {
0444     .driver = {
0445         .name   = "it913x",
0446         .suppress_bind_attrs    = true,
0447     },
0448     .probe      = it913x_probe,
0449     .remove     = it913x_remove,
0450     .id_table   = it913x_id_table,
0451 };
0452
0453 module_platform_driver(it913x_driver);
0454
0455 MODULE_DESCRIPTION("ITE IT913X silicon tuner driver");
0456 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
0457 MODULE_LICENSE("GPL");