| /* |
| * ITE IT913X silicon tuner driver |
| * |
| * Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com) |
| * IT9137 Copyright (C) ITE Tech Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * |
| * GNU General Public License for more details. |
| */ |
| |
| #include "it913x.h" |
| #include <linux/platform_device.h> |
| #include <linux/regmap.h> |
| |
| struct it913x_dev { |
| struct platform_device *pdev; |
| struct regmap *regmap; |
| struct dvb_frontend *fe; |
| u8 chip_ver:2; |
| u8 role:2; |
| u16 xtal; |
| u8 fdiv; |
| u8 clk_mode; |
| u32 fn_min; |
| bool active; |
| }; |
| |
| static int it913x_init(struct dvb_frontend *fe) |
| { |
| struct it913x_dev *dev = fe->tuner_priv; |
| struct platform_device *pdev = dev->pdev; |
| int ret; |
| unsigned int utmp; |
| u8 iqik_m_cal, nv_val, buf[2]; |
| static const u8 nv[] = {48, 32, 24, 16, 12, 8, 6, 4, 2}; |
| unsigned long timeout; |
| |
| dev_dbg(&pdev->dev, "role %u\n", dev->role); |
| |
| ret = regmap_write(dev->regmap, 0x80ec4c, 0x68); |
| if (ret) |
| goto err; |
| |
| usleep_range(10000, 100000); |
| |
| ret = regmap_read(dev->regmap, 0x80ec86, &utmp); |
| if (ret) |
| goto err; |
| |
| switch (utmp) { |
| case 0: |
| /* 12.000 MHz */ |
| dev->clk_mode = utmp; |
| dev->xtal = 2000; |
| dev->fdiv = 3; |
| iqik_m_cal = 16; |
| break; |
| case 1: |
| /* 20.480 MHz */ |
| dev->clk_mode = utmp; |
| dev->xtal = 640; |
| dev->fdiv = 1; |
| iqik_m_cal = 6; |
| break; |
| default: |
| dev_err(&pdev->dev, "unknown clock identifier %d\n", utmp); |
| goto err; |
| } |
| |
| ret = regmap_read(dev->regmap, 0x80ed03, &utmp); |
| if (ret) |
| goto err; |
| |
| else if (utmp < ARRAY_SIZE(nv)) |
| nv_val = nv[utmp]; |
| else |
| nv_val = 2; |
| |
| #define TIMEOUT 50 |
| timeout = jiffies + msecs_to_jiffies(TIMEOUT); |
| while (!time_after(jiffies, timeout)) { |
| ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2); |
| if (ret) |
| goto err; |
| |
| utmp = (buf[1] << 8) | (buf[0] << 0); |
| if (utmp) |
| break; |
| } |
| |
| dev_dbg(&pdev->dev, "r_fbc_m_bdry took %u ms, val %u\n", |
| jiffies_to_msecs(jiffies) - |
| (jiffies_to_msecs(timeout) - TIMEOUT), utmp); |
| |
| dev->fn_min = dev->xtal * utmp; |
| dev->fn_min /= (dev->fdiv * nv_val); |
| dev->fn_min *= 1000; |
| dev_dbg(&pdev->dev, "fn_min %u\n", dev->fn_min); |
| |
| /* |
| * Chip version BX never sets that flag so we just wait 50ms in that |
| * case. It is possible poll BX similarly than AX and then timeout in |
| * order to get 50ms delay, but that causes about 120 extra I2C |
| * messages. As for now, we just wait and reduce IO. |
| */ |
| if (dev->chip_ver == 1) { |
| #define TIMEOUT 50 |
| timeout = jiffies + msecs_to_jiffies(TIMEOUT); |
| while (!time_after(jiffies, timeout)) { |
| ret = regmap_read(dev->regmap, 0x80ec82, &utmp); |
| if (ret) |
| goto err; |
| |
| if (utmp) |
| break; |
| } |
| |
| dev_dbg(&pdev->dev, "p_tsm_init_mode took %u ms, val %u\n", |
| jiffies_to_msecs(jiffies) - |
| (jiffies_to_msecs(timeout) - TIMEOUT), utmp); |
| } else { |
| msleep(50); |
| } |
| |
| ret = regmap_write(dev->regmap, 0x80ed81, iqik_m_cal); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80ec57, 0x00); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80ec58, 0x00); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80ec40, 0x01); |
| if (ret) |
| goto err; |
| |
| dev->active = true; |
| |
| return 0; |
| err: |
| dev_dbg(&pdev->dev, "failed %d\n", ret); |
| return ret; |
| } |
| |
| static int it913x_sleep(struct dvb_frontend *fe) |
| { |
| struct it913x_dev *dev = fe->tuner_priv; |
| struct platform_device *pdev = dev->pdev; |
| int ret, len; |
| |
| dev_dbg(&pdev->dev, "role %u\n", dev->role); |
| |
| dev->active = false; |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec40, "\x00", 1); |
| if (ret) |
| goto err; |
| |
| /* |
| * Writing '0x00' to master tuner register '0x80ec08' causes slave tuner |
| * communication lost. Due to that, we cannot put master full sleep. |
| */ |
| if (dev->role == IT913X_ROLE_DUAL_MASTER) |
| len = 4; |
| else |
| len = 15; |
| |
| dev_dbg(&pdev->dev, "role %u, len %d\n", dev->role, len); |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec02, |
| "\x3f\x1f\x3f\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", |
| len); |
| if (ret) |
| goto err; |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec12, "\x00\x00\x00\x00", 4); |
| if (ret) |
| goto err; |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec17, |
| "\x00\x00\x00\x00\x00\x00\x00\x00\x00", 9); |
| if (ret) |
| goto err; |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec22, |
| "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 10); |
| if (ret) |
| goto err; |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec20, "\x00", 1); |
| if (ret) |
| goto err; |
| |
| ret = regmap_bulk_write(dev->regmap, 0x80ec3f, "\x01", 1); |
| if (ret) |
| goto err; |
| |
| return 0; |
| err: |
| dev_dbg(&pdev->dev, "failed %d\n", ret); |
| return ret; |
| } |
| |
| static int it913x_set_params(struct dvb_frontend *fe) |
| { |
| struct it913x_dev *dev = fe->tuner_priv; |
| struct platform_device *pdev = dev->pdev; |
| struct dtv_frontend_properties *c = &fe->dtv_property_cache; |
| int ret; |
| unsigned int utmp; |
| u32 pre_lo_freq, t_cal_freq; |
| u16 iqik_m_cal, n_div; |
| u8 u8tmp, n, l_band, lna_band; |
| |
| dev_dbg(&pdev->dev, "role=%u, frequency %u, bandwidth_hz %u\n", |
| dev->role, c->frequency, c->bandwidth_hz); |
| |
| if (!dev->active) { |
| ret = -EINVAL; |
| goto err; |
| } |
| |
| if (c->frequency <= 74000000) { |
| n_div = 48; |
| n = 0; |
| } else if (c->frequency <= 111000000) { |
| n_div = 32; |
| n = 1; |
| } else if (c->frequency <= 148000000) { |
| n_div = 24; |
| n = 2; |
| } else if (c->frequency <= 222000000) { |
| n_div = 16; |
| n = 3; |
| } else if (c->frequency <= 296000000) { |
| n_div = 12; |
| n = 4; |
| } else if (c->frequency <= 445000000) { |
| n_div = 8; |
| n = 5; |
| } else if (c->frequency <= dev->fn_min) { |
| n_div = 6; |
| n = 6; |
| } else if (c->frequency <= 950000000) { |
| n_div = 4; |
| n = 7; |
| } else { |
| n_div = 2; |
| n = 0; |
| } |
| |
| ret = regmap_read(dev->regmap, 0x80ed81, &utmp); |
| if (ret) |
| goto err; |
| |
| iqik_m_cal = utmp * n_div; |
| |
| if (utmp < 0x20) { |
| if (dev->clk_mode == 0) |
| iqik_m_cal = (iqik_m_cal * 9) >> 5; |
| else |
| iqik_m_cal >>= 1; |
| } else { |
| iqik_m_cal = 0x40 - iqik_m_cal; |
| if (dev->clk_mode == 0) |
| iqik_m_cal = ~((iqik_m_cal * 9) >> 5); |
| else |
| iqik_m_cal = ~(iqik_m_cal >> 1); |
| } |
| |
| t_cal_freq = (c->frequency / 1000) * n_div * dev->fdiv; |
| pre_lo_freq = t_cal_freq / dev->xtal; |
| utmp = pre_lo_freq * dev->xtal; |
| |
| if ((t_cal_freq - utmp) >= (dev->xtal >> 1)) |
| pre_lo_freq++; |
| |
| pre_lo_freq += (u32) n << 13; |
| /* Frequency OMEGA_IQIK_M_CAL_MID*/ |
| t_cal_freq = pre_lo_freq + (u32)iqik_m_cal; |
| dev_dbg(&pdev->dev, "t_cal_freq %u, pre_lo_freq %u\n", |
| t_cal_freq, pre_lo_freq); |
| |
| if (c->frequency <= 440000000) { |
| l_band = 0; |
| lna_band = 0; |
| } else if (c->frequency <= 484000000) { |
| l_band = 1; |
| lna_band = 1; |
| } else if (c->frequency <= 533000000) { |
| l_band = 1; |
| lna_band = 2; |
| } else if (c->frequency <= 587000000) { |
| l_band = 1; |
| lna_band = 3; |
| } else if (c->frequency <= 645000000) { |
| l_band = 1; |
| lna_band = 4; |
| } else if (c->frequency <= 710000000) { |
| l_band = 1; |
| lna_band = 5; |
| } else if (c->frequency <= 782000000) { |
| l_band = 1; |
| lna_band = 6; |
| } else if (c->frequency <= 860000000) { |
| l_band = 1; |
| lna_band = 7; |
| } else if (c->frequency <= 1492000000) { |
| l_band = 1; |
| lna_band = 0; |
| } else if (c->frequency <= 1685000000) { |
| l_band = 1; |
| lna_band = 1; |
| } else { |
| ret = -EINVAL; |
| goto err; |
| } |
| |
| /* XXX: latest windows driver does not set that at all */ |
| ret = regmap_write(dev->regmap, 0x80ee06, lna_band); |
| if (ret) |
| goto err; |
| |
| if (c->bandwidth_hz <= 5000000) |
| u8tmp = 0; |
| else if (c->bandwidth_hz <= 6000000) |
| u8tmp = 2; |
| else if (c->bandwidth_hz <= 7000000) |
| u8tmp = 4; |
| else |
| u8tmp = 6; /* 8000000 */ |
| |
| ret = regmap_write(dev->regmap, 0x80ec56, u8tmp); |
| if (ret) |
| goto err; |
| |
| /* XXX: latest windows driver sets different value (a8 != 68) */ |
| ret = regmap_write(dev->regmap, 0x80ec4c, 0xa0 | (l_band << 3)); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80ec4d, (t_cal_freq >> 0) & 0xff); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80ec4e, (t_cal_freq >> 8) & 0xff); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80011e, (pre_lo_freq >> 0) & 0xff); |
| if (ret) |
| goto err; |
| |
| ret = regmap_write(dev->regmap, 0x80011f, (pre_lo_freq >> 8) & 0xff); |
| if (ret) |
| goto err; |
| |
| return 0; |
| err: |
| dev_dbg(&pdev->dev, "failed %d\n", ret); |
| return ret; |
| } |
| |
| static const struct dvb_tuner_ops it913x_tuner_ops = { |
| .info = { |
| .name = "ITE IT913X", |
| .frequency_min = 174000000, |
| .frequency_max = 862000000, |
| }, |
| |
| .init = it913x_init, |
| .sleep = it913x_sleep, |
| .set_params = it913x_set_params, |
| }; |
| |
| static int it913x_probe(struct platform_device *pdev) |
| { |
| struct it913x_platform_data *pdata = pdev->dev.platform_data; |
| struct dvb_frontend *fe = pdata->fe; |
| struct it913x_dev *dev; |
| const struct platform_device_id *id = platform_get_device_id(pdev); |
| int ret; |
| char *chip_ver_str; |
| |
| dev = kzalloc(sizeof(struct it913x_dev), GFP_KERNEL); |
| if (dev == NULL) { |
| ret = -ENOMEM; |
| dev_err(&pdev->dev, "kzalloc() failed\n"); |
| goto err; |
| } |
| |
| dev->pdev = pdev; |
| dev->regmap = pdata->regmap; |
| dev->fe = pdata->fe; |
| dev->chip_ver = id->driver_data; |
| dev->role = pdata->role; |
| |
| fe->tuner_priv = dev; |
| memcpy(&fe->ops.tuner_ops, &it913x_tuner_ops, |
| sizeof(struct dvb_tuner_ops)); |
| platform_set_drvdata(pdev, dev); |
| |
| if (dev->chip_ver == 1) |
| chip_ver_str = "AX"; |
| else if (dev->chip_ver == 2) |
| chip_ver_str = "BX"; |
| else |
| chip_ver_str = "??"; |
| |
| dev_info(&pdev->dev, "ITE IT913X %s successfully attached\n", |
| chip_ver_str); |
| dev_dbg(&pdev->dev, "chip_ver %u, role %u\n", dev->chip_ver, dev->role); |
| return 0; |
| err: |
| dev_dbg(&pdev->dev, "failed %d\n", ret); |
| return ret; |
| } |
| |
| static int it913x_remove(struct platform_device *pdev) |
| { |
| struct it913x_dev *dev = platform_get_drvdata(pdev); |
| struct dvb_frontend *fe = dev->fe; |
| |
| dev_dbg(&pdev->dev, "\n"); |
| |
| memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops)); |
| fe->tuner_priv = NULL; |
| kfree(dev); |
| |
| return 0; |
| } |
| |
| static const struct platform_device_id it913x_id_table[] = { |
| {"it9133ax-tuner", 1}, |
| {"it9133bx-tuner", 2}, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(platform, it913x_id_table); |
| |
| static struct platform_driver it913x_driver = { |
| .driver = { |
| .name = "it913x", |
| .suppress_bind_attrs = true, |
| }, |
| .probe = it913x_probe, |
| .remove = it913x_remove, |
| .id_table = it913x_id_table, |
| }; |
| |
| module_platform_driver(it913x_driver); |
| |
| MODULE_DESCRIPTION("ITE IT913X silicon tuner driver"); |
| MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); |
| MODULE_LICENSE("GPL"); |
