drivers/media/tuners/e4000.c

   1 /*
   2  * Elonics E4000 silicon tuner driver
   3  *
   4  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License along
  17  *    with this program; if not, write to the Free Software Foundation, Inc.,
  18  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include "e4000_priv.h"
  22
  23 /* Max transfer size done by I2C transfer functions */
  24 #define MAX_XFER_SIZE  64
  25
  26 /* write multiple registers */
  27 static int e4000_wr_regs(struct e4000_priv *priv, u8 reg, u8 *val, int len)
  28 {
  29         int ret;
  30         u8 buf[MAX_XFER_SIZE];
  31         struct i2c_msg msg[1] = {
  32                 {
  33                         .addr = priv->cfg->i2c_addr,
  34                         .flags = 0,
  35                         .len = 1 + len,
  36                         .buf = buf,
  37                 }
  38         };
  39
  40         if (1 + len > sizeof(buf)) {
  41                 dev_warn(&priv->i2c->dev,
  42                          "%s: i2c wr reg=%04x: len=%d is too big!\n",
  43                          KBUILD_MODNAME, reg, len);
  44                 return -EINVAL;
  45         }
  46
  47         buf[0] = reg;
  48         memcpy(&buf[1], val, len);
  49
  50         ret = i2c_transfer(priv->i2c, msg, 1);
  51         if (ret == 1) {
  52                 ret = 0;
  53         } else {
  54                 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \
  55                                 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
  56                 ret = -EREMOTEIO;
  57         }
  58         return ret;
  59 }
  60
  61 /* read multiple registers */
  62 static int e4000_rd_regs(struct e4000_priv *priv, u8 reg, u8 *val, int len)
  63 {
  64         int ret;
  65         u8 buf[MAX_XFER_SIZE];
  66         struct i2c_msg msg[2] = {
  67                 {
  68                         .addr = priv->cfg->i2c_addr,
  69                         .flags = 0,
  70                         .len = 1,
  71                         .buf = &reg,
  72                 }, {
  73                         .addr = priv->cfg->i2c_addr,
  74                         .flags = I2C_M_RD,
  75                         .len = len,
  76                         .buf = buf,
  77                 }
  78         };
  79
  80         if (len > sizeof(buf)) {
  81                 dev_warn(&priv->i2c->dev,
  82                          "%s: i2c rd reg=%04x: len=%d is too big!\n",
  83                          KBUILD_MODNAME, reg, len);
  84                 return -EINVAL;
  85         }
  86
  87         ret = i2c_transfer(priv->i2c, msg, 2);
  88         if (ret == 2) {
  89                 memcpy(val, buf, len);
  90                 ret = 0;
  91         } else {
  92                 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%02x " \
  93                                 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
  94                 ret = -EREMOTEIO;
  95         }
  96
  97         return ret;
  98 }
  99
 100 /* write single register */
 101 static int e4000_wr_reg(struct e4000_priv *priv, u8 reg, u8 val)
 102 {
 103         return e4000_wr_regs(priv, reg, &val, 1);
 104 }
 105
 106 /* read single register */
 107 static int e4000_rd_reg(struct e4000_priv *priv, u8 reg, u8 *val)
 108 {
 109         return e4000_rd_regs(priv, reg, val, 1);
 110 }
 111
 112 static int e4000_init(struct dvb_frontend *fe)
 113 {
 114         struct e4000_priv *priv = fe->tuner_priv;
 115         int ret;
 116
 117         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 118
 119         if (fe->ops.i2c_gate_ctrl)
 120                 fe->ops.i2c_gate_ctrl(fe, 1);
 121
 122         /* dummy I2C to ensure I2C wakes up */
 123         ret = e4000_wr_reg(priv, 0x02, 0x40);
 124
 125         /* reset */
 126         ret = e4000_wr_reg(priv, 0x00, 0x01);
 127         if (ret < 0)
 128                 goto err;
 129
 130         /* disable output clock */
 131         ret = e4000_wr_reg(priv, 0x06, 0x00);
 132         if (ret < 0)
 133                 goto err;
 134
 135         ret = e4000_wr_reg(priv, 0x7a, 0x96);
 136         if (ret < 0)
 137                 goto err;
 138
 139         /* configure gains */
 140         ret = e4000_wr_regs(priv, 0x7e, "\x01\xfe", 2);
 141         if (ret < 0)
 142                 goto err;
 143
 144         ret = e4000_wr_reg(priv, 0x82, 0x00);
 145         if (ret < 0)
 146                 goto err;
 147
 148         ret = e4000_wr_reg(priv, 0x24, 0x05);
 149         if (ret < 0)
 150                 goto err;
 151
 152         ret = e4000_wr_regs(priv, 0x87, "\x20\x01", 2);
 153         if (ret < 0)
 154                 goto err;
 155
 156         ret = e4000_wr_regs(priv, 0x9f, "\x7f\x07", 2);
 157         if (ret < 0)
 158                 goto err;
 159
 160         /*
 161          * TODO: Implement DC offset control correctly.
 162          * DC offsets has quite much effect for received signal quality in case
 163          * of direct conversion tuners (Zero-IF). Surely we will now lose few
 164          * decimals or even decibels from SNR...
 165          */
 166         /* DC offset control */
 167         ret = e4000_wr_reg(priv, 0x2d, 0x0c);
 168         if (ret < 0)
 169                 goto err;
 170
 171         /* gain control */
 172         ret = e4000_wr_reg(priv, 0x1a, 0x17);
 173         if (ret < 0)
 174                 goto err;
 175
 176         ret = e4000_wr_reg(priv, 0x1f, 0x1a);
 177         if (ret < 0)
 178                 goto err;
 179
 180         if (fe->ops.i2c_gate_ctrl)
 181                 fe->ops.i2c_gate_ctrl(fe, 0);
 182
 183         return 0;
 184 err:
 185         if (fe->ops.i2c_gate_ctrl)
 186                 fe->ops.i2c_gate_ctrl(fe, 0);
 187
 188         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 189         return ret;
 190 }
 191
 192 static int e4000_sleep(struct dvb_frontend *fe)
 193 {
 194         struct e4000_priv *priv = fe->tuner_priv;
 195         int ret;
 196
 197         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 198
 199         if (fe->ops.i2c_gate_ctrl)
 200                 fe->ops.i2c_gate_ctrl(fe, 1);
 201
 202         ret = e4000_wr_reg(priv, 0x00, 0x00);
 203         if (ret < 0)
 204                 goto err;
 205
 206         if (fe->ops.i2c_gate_ctrl)
 207                 fe->ops.i2c_gate_ctrl(fe, 0);
 208
 209         return 0;
 210 err:
 211         if (fe->ops.i2c_gate_ctrl)
 212                 fe->ops.i2c_gate_ctrl(fe, 0);
 213
 214         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 215         return ret;
 216 }
 217
 218 static int e4000_set_params(struct dvb_frontend *fe)
 219 {
 220         struct e4000_priv *priv = fe->tuner_priv;
 221         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 222         int ret, i, sigma_delta;
 223         unsigned int f_VCO;
 224         u8 buf[5];
 225
 226         dev_dbg(&priv->i2c->dev, "%s: delivery_system=%d frequency=%d " \
 227                         "bandwidth_hz=%d\n", __func__,
 228                         c->delivery_system, c->frequency, c->bandwidth_hz);
 229
 230         if (fe->ops.i2c_gate_ctrl)
 231                 fe->ops.i2c_gate_ctrl(fe, 1);
 232
 233         /* gain control manual */
 234         ret = e4000_wr_reg(priv, 0x1a, 0x00);
 235         if (ret < 0)
 236                 goto err;
 237
 238         /* PLL */
 239         for (i = 0; i < ARRAY_SIZE(e4000_pll_lut); i++) {
 240                 if (c->frequency <= e4000_pll_lut[i].freq)
 241                         break;
 242         }
 243
 244         if (i == ARRAY_SIZE(e4000_pll_lut))
 245                 goto err;
 246
 247         /*
 248          * Note: Currently f_VCO overflows when c->frequency is 1 073 741 824 Hz
 249          * or more.
 250          */
 251         f_VCO = c->frequency * e4000_pll_lut[i].mul;
 252         sigma_delta = 0x10000UL * (f_VCO % priv->cfg->clock) / priv->cfg->clock;
 253         buf[0] = f_VCO / priv->cfg->clock;
 254         buf[1] = (sigma_delta >> 0) & 0xff;
 255         buf[2] = (sigma_delta >> 8) & 0xff;
 256         buf[3] = 0x00;
 257         buf[4] = e4000_pll_lut[i].div;
 258
 259         dev_dbg(&priv->i2c->dev, "%s: f_VCO=%u pll div=%d sigma_delta=%04x\n",
 260                         __func__, f_VCO, buf[0], sigma_delta);
 261
 262         ret = e4000_wr_regs(priv, 0x09, buf, 5);
 263         if (ret < 0)
 264                 goto err;
 265
 266         /* LNA filter (RF filter) */
 267         for (i = 0; i < ARRAY_SIZE(e400_lna_filter_lut); i++) {
 268                 if (c->frequency <= e400_lna_filter_lut[i].freq)
 269                         break;
 270         }
 271
 272         if (i == ARRAY_SIZE(e400_lna_filter_lut))
 273                 goto err;
 274
 275         ret = e4000_wr_reg(priv, 0x10, e400_lna_filter_lut[i].val);
 276         if (ret < 0)
 277                 goto err;
 278
 279         /* IF filters */
 280         for (i = 0; i < ARRAY_SIZE(e4000_if_filter_lut); i++) {
 281                 if (c->bandwidth_hz <= e4000_if_filter_lut[i].freq)
 282                         break;
 283         }
 284
 285         if (i == ARRAY_SIZE(e4000_if_filter_lut))
 286                 goto err;
 287
 288         buf[0] = e4000_if_filter_lut[i].reg11_val;
 289         buf[1] = e4000_if_filter_lut[i].reg12_val;
 290
 291         ret = e4000_wr_regs(priv, 0x11, buf, 2);
 292         if (ret < 0)
 293                 goto err;
 294
 295         /* frequency band */
 296         for (i = 0; i < ARRAY_SIZE(e4000_band_lut); i++) {
 297                 if (c->frequency <= e4000_band_lut[i].freq)
 298                         break;
 299         }
 300
 301         if (i == ARRAY_SIZE(e4000_band_lut))
 302                 goto err;
 303
 304         ret = e4000_wr_reg(priv, 0x07, e4000_band_lut[i].reg07_val);
 305         if (ret < 0)
 306                 goto err;
 307
 308         ret = e4000_wr_reg(priv, 0x78, e4000_band_lut[i].reg78_val);
 309         if (ret < 0)
 310                 goto err;
 311
 312         /* gain control auto */
 313         ret = e4000_wr_reg(priv, 0x1a, 0x17);
 314         if (ret < 0)
 315                 goto err;
 316
 317         if (fe->ops.i2c_gate_ctrl)
 318                 fe->ops.i2c_gate_ctrl(fe, 0);
 319
 320         return 0;
 321 err:
 322         if (fe->ops.i2c_gate_ctrl)
 323                 fe->ops.i2c_gate_ctrl(fe, 0);
 324
 325         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 326         return ret;
 327 }
 328
 329 static int e4000_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
 330 {
 331         struct e4000_priv *priv = fe->tuner_priv;
 332
 333         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 334
 335         *frequency = 0; /* Zero-IF */
 336
 337         return 0;
 338 }
 339
 340 static int e4000_release(struct dvb_frontend *fe)
 341 {
 342         struct e4000_priv *priv = fe->tuner_priv;
 343
 344         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 345
 346         kfree(fe->tuner_priv);
 347
 348         return 0;
 349 }
 350
 351 static const struct dvb_tuner_ops e4000_tuner_ops = {
 352         .info = {
 353                 .name           = "Elonics E4000",
 354                 .frequency_min  = 174000000,
 355                 .frequency_max  = 862000000,
 356         },
 357
 358         .release = e4000_release,
 359
 360         .init = e4000_init,
 361         .sleep = e4000_sleep,
 362         .set_params = e4000_set_params,
 363
 364         .get_if_frequency = e4000_get_if_frequency,
 365 };
 366
 367 struct dvb_frontend *e4000_attach(struct dvb_frontend *fe,
 368                 struct i2c_adapter *i2c, const struct e4000_config *cfg)
 369 {
 370         struct e4000_priv *priv;
 371         int ret;
 372         u8 chip_id;
 373
 374         if (fe->ops.i2c_gate_ctrl)
 375                 fe->ops.i2c_gate_ctrl(fe, 1);
 376
 377         priv = kzalloc(sizeof(struct e4000_priv), GFP_KERNEL);
 378         if (!priv) {
 379                 ret = -ENOMEM;
 380                 dev_err(&i2c->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
 381                 goto err;
 382         }
 383
 384         priv->cfg = cfg;
 385         priv->i2c = i2c;
 386
 387         /* check if the tuner is there */
 388         ret = e4000_rd_reg(priv, 0x02, &chip_id);
 389         if (ret < 0)
 390                 goto err;
 391
 392         dev_dbg(&priv->i2c->dev, "%s: chip_id=%02x\n", __func__, chip_id);
 393
 394         if (chip_id != 0x40)
 395                 goto err;
 396
 397         /* put sleep as chip seems to be in normal mode by default */
 398         ret = e4000_wr_reg(priv, 0x00, 0x00);
 399         if (ret < 0)
 400                 goto err;
 401
 402         dev_info(&priv->i2c->dev,
 403                         "%s: Elonics E4000 successfully identified\n",
 404                         KBUILD_MODNAME);
 405
 406         fe->tuner_priv = priv;
 407         memcpy(&fe->ops.tuner_ops, &e4000_tuner_ops,
 408                         sizeof(struct dvb_tuner_ops));
 409
 410         if (fe->ops.i2c_gate_ctrl)
 411                 fe->ops.i2c_gate_ctrl(fe, 0);
 412
 413         return fe;
 414 err:
 415         if (fe->ops.i2c_gate_ctrl)
 416                 fe->ops.i2c_gate_ctrl(fe, 0);
 417
 418         dev_dbg(&i2c->dev, "%s: failed=%d\n", __func__, ret);
 419         kfree(priv);
 420         return NULL;
 421 }
 422 EXPORT_SYMBOL(e4000_attach);
 423
 424 MODULE_DESCRIPTION("Elonics E4000 silicon tuner driver");
 425 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 426 MODULE_LICENSE("GPL");