drivers/media/dvb/frontends/stv6110x.c

   1 /*
   2         STV6110(A) Silicon tuner driver
   3
   4         Copyright (C) Manu Abraham <abraham.manu@gmail.com>
   5
   6         Copyright (C) ST Microelectronics
   7
   8         This program is free software; you can redistribute it and/or modify
   9         it under the terms of the GNU General Public License as published by
  10         the Free Software Foundation; either version 2 of the License, or
  11         (at your option) any later version.
  12
  13         This program is distributed in the hope that it will be useful,
  14         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16         GNU General Public License for more details.
  17
  18         You should have received a copy of the GNU General Public License
  19         along with this program; if not, write to the Free Software
  20         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include <linux/init.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/string.h>
  27
  28 #include "dvb_frontend.h"
  29
  30 #include "stv6110x_reg.h"
  31 #include "stv6110x.h"
  32 #include "stv6110x_priv.h"
  33
  34 static unsigned int verbose;
  35 module_param(verbose, int, 0644);
  36 MODULE_PARM_DESC(verbose, "Set Verbosity level");
  37
  38 static int stv6110x_read_reg(struct stv6110x_state *stv6110x, u8 reg, u8 *data)
  39 {
  40         int ret;
  41         const struct stv6110x_config *config = stv6110x->config;
  42         u8 b0[] = { reg };
  43         u8 b1[] = { 0 };
  44         struct i2c_msg msg[] = {
  45                 { .addr = config->addr, .flags = 0,        .buf = b0, .len = 1 },
  46                 { .addr = config->addr, .flags = I2C_M_RD, .buf = b1, .len = 1 }
  47         };
  48
  49         ret = i2c_transfer(stv6110x->i2c, msg, 2);
  50         if (ret != 2) {
  51                 dprintk(FE_ERROR, 1, "I/O Error");
  52                 return -EREMOTEIO;
  53         }
  54         *data = b1[0];
  55
  56         return 0;
  57 }
  58
  59 static int stv6110x_write_regs(struct stv6110x_state *stv6110x, int start, u8 data[], int len)
  60 {
  61         int ret;
  62         const struct stv6110x_config *config = stv6110x->config;
  63         u8 buf[len + 1];
  64         struct i2c_msg msg = {
  65                 .addr = config->addr,
  66                 .flags = 0,
  67                 .buf = buf,
  68                 .len = len + 1
  69         };
  70
  71         if (start + len > 8)
  72                 return -EINVAL;
  73
  74         buf[0] = start;
  75         memcpy(&buf[1], data, len);
  76
  77         ret = i2c_transfer(stv6110x->i2c, &msg, 1);
  78         if (ret != 1) {
  79                 dprintk(FE_ERROR, 1, "I/O Error");
  80                 return -EREMOTEIO;
  81         }
  82
  83         return 0;
  84 }
  85
  86 static int stv6110x_write_reg(struct stv6110x_state *stv6110x, u8 reg, u8 data)
  87 {
  88         return stv6110x_write_regs(stv6110x, reg, &data, 1);
  89 }
  90
  91 static int stv6110x_init(struct dvb_frontend *fe)
  92 {
  93         struct stv6110x_state *stv6110x = fe->tuner_priv;
  94         int ret;
  95
  96         ret = stv6110x_write_regs(stv6110x, 0, stv6110x->regs,
  97                                   ARRAY_SIZE(stv6110x->regs));
  98         if (ret < 0) {
  99                 dprintk(FE_ERROR, 1, "Initialization failed");
 100                 return -1;
 101         }
 102
 103         return 0;
 104 }
 105
 106 static int stv6110x_set_frequency(struct dvb_frontend *fe, u32 frequency)
 107 {
 108         struct stv6110x_state *stv6110x = fe->tuner_priv;
 109         u32 rDiv, divider;
 110         s32 pVal, pCalc, rDivOpt = 0, pCalcOpt = 1000;
 111         u8 i;
 112
 113         STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_K, (REFCLOCK_MHz - 16));
 114
 115         if (frequency <= 1023000) {
 116                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 1);
 117                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 0);
 118                 pVal = 40;
 119         } else if (frequency <= 1300000) {
 120                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 1);
 121                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 1);
 122                 pVal = 40;
 123         } else if (frequency <= 2046000) {
 124                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 0);
 125                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 0);
 126                 pVal = 20;
 127         } else {
 128                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 0);
 129                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 1);
 130                 pVal = 20;
 131         }
 132
 133         for (rDiv = 0; rDiv <= 3; rDiv++) {
 134                 pCalc = (REFCLOCK_kHz / 100) / R_DIV(rDiv);
 135
 136                 if ((abs((s32)(pCalc - pVal))) < (abs((s32)(pCalcOpt - pVal))))
 137                         rDivOpt = rDiv;
 138
 139                 pCalcOpt = (REFCLOCK_kHz / 100) / R_DIV(rDivOpt);
 140         }
 141
 142         divider = (frequency * R_DIV(rDivOpt) * pVal) / REFCLOCK_kHz;
 143         divider = (divider + 5) / 10;
 144
 145         STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_R_DIV, rDivOpt);
 146         STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_N_DIV_11_8, MSB(divider));
 147         STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG0], TNG0_N_DIV_7_0, LSB(divider));
 148
 149         /* VCO Auto calibration */
 150         STV6110x_SETFIELD(stv6110x->regs[STV6110x_STAT1], STAT1_CALVCO_STRT, 1);
 151
 152         stv6110x_write_reg(stv6110x, STV6110x_CTRL1, stv6110x->regs[STV6110x_CTRL1]);
 153         stv6110x_write_reg(stv6110x, STV6110x_TNG1, stv6110x->regs[STV6110x_TNG1]);
 154         stv6110x_write_reg(stv6110x, STV6110x_TNG0, stv6110x->regs[STV6110x_TNG0]);
 155         stv6110x_write_reg(stv6110x, STV6110x_STAT1, stv6110x->regs[STV6110x_STAT1]);
 156
 157         for (i = 0; i < TRIALS; i++) {
 158                 stv6110x_read_reg(stv6110x, STV6110x_STAT1, &stv6110x->regs[STV6110x_STAT1]);
 159                 if (!STV6110x_GETFIELD(STAT1_CALVCO_STRT, stv6110x->regs[STV6110x_STAT1]))
 160                                 break;
 161                 msleep(1);
 162         }
 163
 164         return 0;
 165 }
 166
 167 static int stv6110x_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 168 {
 169         struct stv6110x_state *stv6110x = fe->tuner_priv;
 170
 171         stv6110x_read_reg(stv6110x, STV6110x_TNG1, &stv6110x->regs[STV6110x_TNG1]);
 172         stv6110x_read_reg(stv6110x, STV6110x_TNG0, &stv6110x->regs[STV6110x_TNG0]);
 173
 174         *frequency = (MAKEWORD16(STV6110x_GETFIELD(TNG1_N_DIV_11_8, stv6110x->regs[STV6110x_TNG1]),
 175                                  STV6110x_GETFIELD(TNG0_N_DIV_7_0, stv6110x->regs[STV6110x_TNG0]))) * REFCLOCK_kHz;
 176
 177         *frequency /= (1 << (STV6110x_GETFIELD(TNG1_R_DIV, stv6110x->regs[STV6110x_TNG1]) +
 178                              STV6110x_GETFIELD(TNG1_DIV4SEL, stv6110x->regs[STV6110x_TNG1])));
 179
 180         *frequency >>= 2;
 181
 182         return 0;
 183 }
 184
 185 static int stv6110x_set_bandwidth(struct dvb_frontend *fe, u32 bandwidth)
 186 {
 187         struct stv6110x_state *stv6110x = fe->tuner_priv;
 188         u32 halfbw;
 189         u8 i;
 190
 191         halfbw = bandwidth >> 1;
 192
 193         if (halfbw > 36000000)
 194                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_CF, 31); /* LPF */
 195         else if (halfbw < 5000000)
 196                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_CF, 0); /* LPF */
 197         else
 198                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_CF, ((halfbw / 1000000) - 5)); /* LPF */
 199
 200
 201         STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_RCCLK_OFF, 0x0); /* cal. clk activated */
 202         STV6110x_SETFIELD(stv6110x->regs[STV6110x_STAT1], STAT1_CALRC_STRT, 0x1); /* LPF auto cal */
 203
 204         stv6110x_write_reg(stv6110x, STV6110x_CTRL3, stv6110x->regs[STV6110x_CTRL3]);
 205         stv6110x_write_reg(stv6110x, STV6110x_STAT1, stv6110x->regs[STV6110x_STAT1]);
 206
 207         for (i = 0; i < TRIALS; i++) {
 208                 stv6110x_read_reg(stv6110x, STV6110x_STAT1, &stv6110x->regs[STV6110x_STAT1]);
 209                 if (!STV6110x_GETFIELD(STAT1_CALRC_STRT, stv6110x->regs[STV6110x_STAT1]))
 210                         break;
 211                 msleep(1);
 212         }
 213         STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_RCCLK_OFF, 0x1); /* cal. done */
 214         stv6110x_write_reg(stv6110x, STV6110x_CTRL3, stv6110x->regs[STV6110x_CTRL3]);
 215
 216         return 0;
 217 }
 218
 219 static int stv6110x_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 220 {
 221         struct stv6110x_state *stv6110x = fe->tuner_priv;
 222
 223         stv6110x_read_reg(stv6110x, STV6110x_CTRL3, &stv6110x->regs[STV6110x_CTRL3]);
 224         *bandwidth = (STV6110x_GETFIELD(CTRL3_CF, stv6110x->regs[STV6110x_CTRL3]) + 5) * 2000000;
 225
 226         return 0;
 227 }
 228
 229 static int stv6110x_set_refclock(struct dvb_frontend *fe, u32 refclock)
 230 {
 231         struct stv6110x_state *stv6110x = fe->tuner_priv;
 232
 233         /* setup divider */
 234         switch (refclock) {
 235         default:
 236         case 1:
 237                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 0);
 238                 break;
 239         case 2:
 240                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 1);
 241                 break;
 242         case 4:
 243                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 2);
 244                 break;
 245         case 8:
 246         case 0:
 247                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 3);
 248                 break;
 249         }
 250         stv6110x_write_reg(stv6110x, STV6110x_CTRL2, stv6110x->regs[STV6110x_CTRL2]);
 251
 252         return 0;
 253 }
 254
 255 static int stv6110x_get_bbgain(struct dvb_frontend *fe, u32 *gain)
 256 {
 257         struct stv6110x_state *stv6110x = fe->tuner_priv;
 258
 259         stv6110x_read_reg(stv6110x, STV6110x_CTRL2, &stv6110x->regs[STV6110x_CTRL2]);
 260         *gain = 2 * STV6110x_GETFIELD(CTRL2_BBGAIN, stv6110x->regs[STV6110x_CTRL2]);
 261
 262         return 0;
 263 }
 264
 265 static int stv6110x_set_bbgain(struct dvb_frontend *fe, u32 gain)
 266 {
 267         struct stv6110x_state *stv6110x = fe->tuner_priv;
 268
 269         STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_BBGAIN, gain / 2);
 270         stv6110x_write_reg(stv6110x, STV6110x_CTRL2, stv6110x->regs[STV6110x_CTRL2]);
 271
 272         return 0;
 273 }
 274
 275 static int stv6110x_set_mode(struct dvb_frontend *fe, enum tuner_mode mode)
 276 {
 277         struct stv6110x_state *stv6110x = fe->tuner_priv;
 278         int ret;
 279
 280         switch (mode) {
 281         case TUNER_SLEEP:
 282                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_SYN, 0);
 283                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_RX, 0);
 284                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_LPT, 0);
 285                 break;
 286
 287         case TUNER_WAKE:
 288                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_SYN, 1);
 289                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_RX, 1);
 290                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_LPT, 1);
 291                 break;
 292         }
 293
 294         ret = stv6110x_write_reg(stv6110x, STV6110x_CTRL1, stv6110x->regs[STV6110x_CTRL1]);
 295         if (ret < 0) {
 296                 dprintk(FE_ERROR, 1, "I/O Error");
 297                 return -EIO;
 298         }
 299
 300         return 0;
 301 }
 302
 303 static int stv6110x_sleep(struct dvb_frontend *fe)
 304 {
 305         return stv6110x_set_mode(fe, TUNER_SLEEP);
 306 }
 307
 308 static int stv6110x_get_status(struct dvb_frontend *fe, u32 *status)
 309 {
 310         struct stv6110x_state *stv6110x = fe->tuner_priv;
 311
 312         stv6110x_read_reg(stv6110x, STV6110x_STAT1, &stv6110x->regs[STV6110x_STAT1]);
 313
 314         if (STV6110x_GETFIELD(STAT1_LOCK, stv6110x->regs[STV6110x_STAT1]))
 315                 *status = TUNER_PHASELOCKED;
 316         else
 317                 *status = 0;
 318
 319         return 0;
 320 }
 321
 322
 323 static int stv6110x_release(struct dvb_frontend *fe)
 324 {
 325         struct stv6110x_state *stv6110x = fe->tuner_priv;
 326
 327         fe->tuner_priv = NULL;
 328         kfree(stv6110x);
 329
 330         return 0;
 331 }
 332
 333 static struct dvb_tuner_ops stv6110x_ops = {
 334         .info = {
 335                 .name           = "STV6110(A) Silicon Tuner",
 336                 .frequency_min  =  950000,
 337                 .frequency_max  = 2150000,
 338                 .frequency_step = 0,
 339         },
 340
 341         .init                   = stv6110x_init,
 342         .sleep                  = stv6110x_sleep,
 343         .release                = stv6110x_release
 344 };
 345
 346 static struct stv6110x_devctl stv6110x_ctl = {
 347         .tuner_init             = stv6110x_init,
 348         .tuner_set_mode         = stv6110x_set_mode,
 349         .tuner_set_frequency    = stv6110x_set_frequency,
 350         .tuner_get_frequency    = stv6110x_get_frequency,
 351         .tuner_set_bandwidth    = stv6110x_set_bandwidth,
 352         .tuner_get_bandwidth    = stv6110x_get_bandwidth,
 353         .tuner_set_bbgain       = stv6110x_set_bbgain,
 354         .tuner_get_bbgain       = stv6110x_get_bbgain,
 355         .tuner_set_refclk       = stv6110x_set_refclock,
 356         .tuner_get_status       = stv6110x_get_status,
 357 };
 358
 359 struct stv6110x_devctl *stv6110x_attach(struct dvb_frontend *fe,
 360                                         const struct stv6110x_config *config,
 361                                         struct i2c_adapter *i2c)
 362 {
 363         struct stv6110x_state *stv6110x;
 364         u8 default_regs[] = {0x07, 0x11, 0xdc, 0x85, 0x17, 0x01, 0xe6, 0x1e};
 365         int ret;
 366
 367         stv6110x = kzalloc(sizeof (struct stv6110x_state), GFP_KERNEL);
 368         if (stv6110x == NULL)
 369                 goto error;
 370
 371         stv6110x->i2c           = i2c;
 372         stv6110x->config        = config;
 373         stv6110x->devctl        = &stv6110x_ctl;
 374         memcpy(stv6110x->regs, default_regs, 8);
 375
 376         /* setup divider */
 377         switch (stv6110x->config->clk_div) {
 378         default:
 379         case 1:
 380                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 0);
 381                 break;
 382         case 2:
 383                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 1);
 384                 break;
 385         case 4:
 386                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 2);
 387                 break;
 388         case 8:
 389         case 0:
 390                 STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 3);
 391                 break;
 392         }
 393
 394         if (fe->ops.i2c_gate_ctrl) {
 395                 ret = fe->ops.i2c_gate_ctrl(fe, 1);
 396                 if (ret < 0)
 397                         goto error;
 398         }
 399
 400         ret = stv6110x_write_regs(stv6110x, 0, stv6110x->regs,
 401                                   ARRAY_SIZE(stv6110x->regs));
 402         if (ret < 0) {
 403                 dprintk(FE_ERROR, 1, "Initialization failed");
 404                 goto error;
 405         }
 406
 407         if (fe->ops.i2c_gate_ctrl) {
 408                 ret = fe->ops.i2c_gate_ctrl(fe, 0);
 409                 if (ret < 0)
 410                         goto error;
 411         }
 412
 413         fe->tuner_priv          = stv6110x;
 414         fe->ops.tuner_ops       = stv6110x_ops;
 415
 416         printk("%s: Attaching STV6110x \n", __func__);
 417         return stv6110x->devctl;
 418
 419 error:
 420         kfree(stv6110x);
 421         return NULL;
 422 }
 423 EXPORT_SYMBOL(stv6110x_attach);
 424
 425 MODULE_AUTHOR("Manu Abraham");
 426 MODULE_DESCRIPTION("STV6110x Silicon tuner");
 427 MODULE_LICENSE("GPL");