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