drivers/media/tuners/tda18218.c

   1 /*
   2  * NXP TDA18218HN silicon tuner driver
   3  *
   4  * Copyright (C) 2010 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
  17  *    along with this program; if not, write to the Free Software
  18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include "tda18218_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 tda18218_wr_regs(struct tda18218_priv *priv, u8 reg, u8 *val, u8 len)
  28 {
  29         int ret = 0, len2, remaining;
  30         u8 buf[MAX_XFER_SIZE];
  31         struct i2c_msg msg[1] = {
  32                 {
  33                         .addr = priv->cfg->i2c_address,
  34                         .flags = 0,
  35                         .buf = buf,
  36                 }
  37         };
  38
  39         if (1 + len > sizeof(buf)) {
  40                 dev_warn(&priv->i2c->dev,
  41                          "%s: i2c wr reg=%04x: len=%d is too big!\n",
  42                          KBUILD_MODNAME, reg, len);
  43                 return -EINVAL;
  44         }
  45
  46         for (remaining = len; remaining > 0;
  47                         remaining -= (priv->cfg->i2c_wr_max - 1)) {
  48                 len2 = remaining;
  49                 if (len2 > (priv->cfg->i2c_wr_max - 1))
  50                         len2 = (priv->cfg->i2c_wr_max - 1);
  51
  52                 msg[0].len = 1 + len2;
  53                 buf[0] = reg + len - remaining;
  54                 memcpy(&buf[1], &val[len - remaining], len2);
  55
  56                 ret = i2c_transfer(priv->i2c, msg, 1);
  57                 if (ret != 1)
  58                         break;
  59         }
  60
  61         if (ret == 1) {
  62                 ret = 0;
  63         } else {
  64                 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \
  65                                 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
  66                 ret = -EREMOTEIO;
  67         }
  68
  69         return ret;
  70 }
  71
  72 /* read multiple registers */
  73 static int tda18218_rd_regs(struct tda18218_priv *priv, u8 reg, u8 *val, u8 len)
  74 {
  75         int ret;
  76         u8 buf[MAX_XFER_SIZE]; /* we must start read always from reg 0x00 */
  77         struct i2c_msg msg[2] = {
  78                 {
  79                         .addr = priv->cfg->i2c_address,
  80                         .flags = 0,
  81                         .len = 1,
  82                         .buf = "\x00",
  83                 }, {
  84                         .addr = priv->cfg->i2c_address,
  85                         .flags = I2C_M_RD,
  86                         .len = reg + len,
  87                         .buf = buf,
  88                 }
  89         };
  90
  91         if (reg + len > sizeof(buf)) {
  92                 dev_warn(&priv->i2c->dev,
  93                          "%s: i2c wr reg=%04x: len=%d is too big!\n",
  94                          KBUILD_MODNAME, reg, len);
  95                 return -EINVAL;
  96         }
  97
  98         ret = i2c_transfer(priv->i2c, msg, 2);
  99         if (ret == 2) {
 100                 memcpy(val, &buf[reg], len);
 101                 ret = 0;
 102         } else {
 103                 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%02x " \
 104                                 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
 105                 ret = -EREMOTEIO;
 106         }
 107
 108         return ret;
 109 }
 110
 111 /* write single register */
 112 static int tda18218_wr_reg(struct tda18218_priv *priv, u8 reg, u8 val)
 113 {
 114         return tda18218_wr_regs(priv, reg, &val, 1);
 115 }
 116
 117 /* read single register */
 118
 119 static int tda18218_rd_reg(struct tda18218_priv *priv, u8 reg, u8 *val)
 120 {
 121         return tda18218_rd_regs(priv, reg, val, 1);
 122 }
 123
 124 static int tda18218_set_params(struct dvb_frontend *fe)
 125 {
 126         struct tda18218_priv *priv = fe->tuner_priv;
 127         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 128         u32 bw = c->bandwidth_hz;
 129         int ret;
 130         u8 buf[3], i, BP_Filter, LP_Fc;
 131         u32 LO_Frac;
 132         /* TODO: find out correct AGC algorithm */
 133         u8 agc[][2] = {
 134                 { R20_AGC11, 0x60 },
 135                 { R23_AGC21, 0x02 },
 136                 { R20_AGC11, 0xa0 },
 137                 { R23_AGC21, 0x09 },
 138                 { R20_AGC11, 0xe0 },
 139                 { R23_AGC21, 0x0c },
 140                 { R20_AGC11, 0x40 },
 141                 { R23_AGC21, 0x01 },
 142                 { R20_AGC11, 0x80 },
 143                 { R23_AGC21, 0x08 },
 144                 { R20_AGC11, 0xc0 },
 145                 { R23_AGC21, 0x0b },
 146                 { R24_AGC22, 0x1c },
 147                 { R24_AGC22, 0x0c },
 148         };
 149
 150         if (fe->ops.i2c_gate_ctrl)
 151                 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */
 152
 153         /* low-pass filter cut-off frequency */
 154         if (bw <= 6000000) {
 155                 LP_Fc = 0;
 156                 priv->if_frequency = 3000000;
 157         } else if (bw <= 7000000) {
 158                 LP_Fc = 1;
 159                 priv->if_frequency = 3500000;
 160         } else {
 161                 LP_Fc = 2;
 162                 priv->if_frequency = 4000000;
 163         }
 164
 165         LO_Frac = c->frequency + priv->if_frequency;
 166
 167         /* band-pass filter */
 168         if (LO_Frac < 188000000)
 169                 BP_Filter = 3;
 170         else if (LO_Frac < 253000000)
 171                 BP_Filter = 4;
 172         else if (LO_Frac < 343000000)
 173                 BP_Filter = 5;
 174         else
 175                 BP_Filter = 6;
 176
 177         buf[0] = (priv->regs[R1A_IF1] & ~7) | BP_Filter; /* BP_Filter */
 178         buf[1] = (priv->regs[R1B_IF2] & ~3) | LP_Fc; /* LP_Fc */
 179         buf[2] = priv->regs[R1C_AGC2B];
 180         ret = tda18218_wr_regs(priv, R1A_IF1, buf, 3);
 181         if (ret)
 182                 goto error;
 183
 184         buf[0] = (LO_Frac / 1000) >> 12; /* LO_Frac_0 */
 185         buf[1] = (LO_Frac / 1000) >> 4; /* LO_Frac_1 */
 186         buf[2] = (LO_Frac / 1000) << 4 |
 187                 (priv->regs[R0C_MD5] & 0x0f); /* LO_Frac_2 */
 188         ret = tda18218_wr_regs(priv, R0A_MD3, buf, 3);
 189         if (ret)
 190                 goto error;
 191
 192         buf[0] = priv->regs[R0F_MD8] | (1 << 6); /* Freq_prog_Start */
 193         ret = tda18218_wr_regs(priv, R0F_MD8, buf, 1);
 194         if (ret)
 195                 goto error;
 196
 197         buf[0] = priv->regs[R0F_MD8] & ~(1 << 6); /* Freq_prog_Start */
 198         ret = tda18218_wr_regs(priv, R0F_MD8, buf, 1);
 199         if (ret)
 200                 goto error;
 201
 202         /* trigger AGC */
 203         for (i = 0; i < ARRAY_SIZE(agc); i++) {
 204                 ret = tda18218_wr_reg(priv, agc[i][0], agc[i][1]);
 205                 if (ret)
 206                         goto error;
 207         }
 208
 209 error:
 210         if (fe->ops.i2c_gate_ctrl)
 211                 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */
 212
 213         if (ret)
 214                 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 215
 216         return ret;
 217 }
 218
 219 static int tda18218_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
 220 {
 221         struct tda18218_priv *priv = fe->tuner_priv;
 222         *frequency = priv->if_frequency;
 223         dev_dbg(&priv->i2c->dev, "%s: if_frequency=%d\n", __func__, *frequency);
 224         return 0;
 225 }
 226
 227 static int tda18218_sleep(struct dvb_frontend *fe)
 228 {
 229         struct tda18218_priv *priv = fe->tuner_priv;
 230         int ret;
 231
 232         if (fe->ops.i2c_gate_ctrl)
 233                 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */
 234
 235         /* standby */
 236         ret = tda18218_wr_reg(priv, R17_PD1, priv->regs[R17_PD1] | (1 << 0));
 237
 238         if (fe->ops.i2c_gate_ctrl)
 239                 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */
 240
 241         if (ret)
 242                 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 243
 244         return ret;
 245 }
 246
 247 static int tda18218_init(struct dvb_frontend *fe)
 248 {
 249         struct tda18218_priv *priv = fe->tuner_priv;
 250         int ret;
 251
 252         /* TODO: calibrations */
 253
 254         if (fe->ops.i2c_gate_ctrl)
 255                 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */
 256
 257         ret = tda18218_wr_regs(priv, R00_ID, priv->regs, TDA18218_NUM_REGS);
 258
 259         if (fe->ops.i2c_gate_ctrl)
 260                 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */
 261
 262         if (ret)
 263                 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 264
 265         return ret;
 266 }
 267
 268 static void tda18218_release(struct dvb_frontend *fe)
 269 {
 270         kfree(fe->tuner_priv);
 271         fe->tuner_priv = NULL;
 272 }
 273
 274 static const struct dvb_tuner_ops tda18218_tuner_ops = {
 275         .info = {
 276                 .name           = "NXP TDA18218",
 277
 278                 .frequency_min  = 174000000,
 279                 .frequency_max  = 864000000,
 280                 .frequency_step =      1000,
 281         },
 282
 283         .release       = tda18218_release,
 284         .init          = tda18218_init,
 285         .sleep         = tda18218_sleep,
 286
 287         .set_params    = tda18218_set_params,
 288
 289         .get_if_frequency = tda18218_get_if_frequency,
 290 };
 291
 292 struct dvb_frontend *tda18218_attach(struct dvb_frontend *fe,
 293         struct i2c_adapter *i2c, struct tda18218_config *cfg)
 294 {
 295         struct tda18218_priv *priv = NULL;
 296         u8 val;
 297         int ret;
 298         /* chip default registers values */
 299         static u8 def_regs[] = {
 300                 0xc0, 0x88, 0x00, 0x8e, 0x03, 0x00, 0x00, 0xd0, 0x00, 0x40,
 301                 0x00, 0x00, 0x07, 0xff, 0x84, 0x09, 0x00, 0x13, 0x00, 0x00,
 302                 0x01, 0x84, 0x09, 0xf0, 0x19, 0x0a, 0x8e, 0x69, 0x98, 0x01,
 303                 0x00, 0x58, 0x10, 0x40, 0x8c, 0x00, 0x0c, 0x48, 0x85, 0xc9,
 304                 0xa7, 0x00, 0x00, 0x00, 0x30, 0x81, 0x80, 0x00, 0x39, 0x00,
 305                 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xf6
 306         };
 307
 308         priv = kzalloc(sizeof(struct tda18218_priv), GFP_KERNEL);
 309         if (priv == NULL)
 310                 return NULL;
 311
 312         priv->cfg = cfg;
 313         priv->i2c = i2c;
 314         fe->tuner_priv = priv;
 315
 316         if (fe->ops.i2c_gate_ctrl)
 317                 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */
 318
 319         /* check if the tuner is there */
 320         ret = tda18218_rd_reg(priv, R00_ID, &val);
 321         if (!ret)
 322                 dev_dbg(&priv->i2c->dev, "%s: chip id=%02x\n", __func__, val);
 323         if (ret || val != def_regs[R00_ID]) {
 324                 kfree(priv);
 325                 return NULL;
 326         }
 327
 328         dev_info(&priv->i2c->dev,
 329                         "%s: NXP TDA18218HN successfully identified\n",
 330                         KBUILD_MODNAME);
 331
 332         memcpy(&fe->ops.tuner_ops, &tda18218_tuner_ops,
 333                 sizeof(struct dvb_tuner_ops));
 334         memcpy(priv->regs, def_regs, sizeof(def_regs));
 335
 336         /* loop-through enabled chip default register values */
 337         if (priv->cfg->loop_through) {
 338                 priv->regs[R17_PD1] = 0xb0;
 339                 priv->regs[R18_PD2] = 0x59;
 340         }
 341
 342         /* standby */
 343         ret = tda18218_wr_reg(priv, R17_PD1, priv->regs[R17_PD1] | (1 << 0));
 344         if (ret)
 345                 dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 346
 347         if (fe->ops.i2c_gate_ctrl)
 348                 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */
 349
 350         return fe;
 351 }
 352 EXPORT_SYMBOL(tda18218_attach);
 353
 354 MODULE_DESCRIPTION("NXP TDA18218HN silicon tuner driver");
 355 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 356 MODULE_LICENSE("GPL");