drivers/media/tuners/tda18271-fe.c

   1 /*
   2     tda18271-fe.c - driver for the Philips / NXP TDA18271 silicon tuner
   3
   4     Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
   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 "tda18271-priv.h"
  22 #include "tda8290.h"
  23
  24 #include <linux/delay.h>
  25 #include <linux/videodev2.h>
  26
  27 int tda18271_debug;
  28 module_param_named(debug, tda18271_debug, int, 0644);
  29 MODULE_PARM_DESC(debug, "set debug level "
  30                  "(info=1, map=2, reg=4, adv=8, cal=16 (or-able))");
  31
  32 static int tda18271_cal_on_startup = -1;
  33 module_param_named(cal, tda18271_cal_on_startup, int, 0644);
  34 MODULE_PARM_DESC(cal, "perform RF tracking filter calibration on startup");
  35
  36 static DEFINE_MUTEX(tda18271_list_mutex);
  37 static LIST_HEAD(hybrid_tuner_instance_list);
  38
  39 /*---------------------------------------------------------------------*/
  40
  41 static int tda18271_toggle_output(struct dvb_frontend *fe, int standby)
  42 {
  43         struct tda18271_priv *priv = fe->tuner_priv;
  44
  45         int ret = tda18271_set_standby_mode(fe, standby ? 1 : 0,
  46                         priv->output_opt & TDA18271_OUTPUT_LT_OFF ? 1 : 0,
  47                         priv->output_opt & TDA18271_OUTPUT_XT_OFF ? 1 : 0);
  48
  49         if (tda_fail(ret))
  50                 goto fail;
  51
  52         tda_dbg("%s mode: xtal oscillator %s, slave tuner loop thru %s\n",
  53                 standby ? "standby" : "active",
  54                 priv->output_opt & TDA18271_OUTPUT_XT_OFF ? "off" : "on",
  55                 priv->output_opt & TDA18271_OUTPUT_LT_OFF ? "off" : "on");
  56 fail:
  57         return ret;
  58 }
  59
  60 /*---------------------------------------------------------------------*/
  61
  62 static inline int charge_pump_source(struct dvb_frontend *fe, int force)
  63 {
  64         struct tda18271_priv *priv = fe->tuner_priv;
  65         return tda18271_charge_pump_source(fe,
  66                                            (priv->role == TDA18271_SLAVE) ?
  67                                            TDA18271_CAL_PLL :
  68                                            TDA18271_MAIN_PLL, force);
  69 }
  70
  71 static inline void tda18271_set_if_notch(struct dvb_frontend *fe)
  72 {
  73         struct tda18271_priv *priv = fe->tuner_priv;
  74         unsigned char *regs = priv->tda18271_regs;
  75
  76         switch (priv->mode) {
  77         case TDA18271_ANALOG:
  78                 regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
  79                 break;
  80         case TDA18271_DIGITAL:
  81                 regs[R_MPD]  |= 0x80; /* IF notch = 1 */
  82                 break;
  83         }
  84 }
  85
  86 static int tda18271_channel_configuration(struct dvb_frontend *fe,
  87                                           struct tda18271_std_map_item *map,
  88                                           u32 freq, u32 bw)
  89 {
  90         struct tda18271_priv *priv = fe->tuner_priv;
  91         unsigned char *regs = priv->tda18271_regs;
  92         int ret;
  93         u32 N;
  94
  95         /* update TV broadcast parameters */
  96
  97         /* set standard */
  98         regs[R_EP3]  &= ~0x1f; /* clear std bits */
  99         regs[R_EP3]  |= (map->agc_mode << 3) | map->std;
 100
 101         if (priv->id == TDA18271HDC2) {
 102                 /* set rfagc to high speed mode */
 103                 regs[R_EP3] &= ~0x04;
 104         }
 105
 106         /* set cal mode to normal */
 107         regs[R_EP4]  &= ~0x03;
 108
 109         /* update IF output level */
 110         regs[R_EP4]  &= ~0x1c; /* clear if level bits */
 111         regs[R_EP4]  |= (map->if_lvl << 2);
 112
 113         /* update FM_RFn */
 114         regs[R_EP4]  &= ~0x80;
 115         regs[R_EP4]  |= map->fm_rfn << 7;
 116
 117         /* update rf top / if top */
 118         regs[R_EB22]  = 0x00;
 119         regs[R_EB22] |= map->rfagc_top;
 120         ret = tda18271_write_regs(fe, R_EB22, 1);
 121         if (tda_fail(ret))
 122                 goto fail;
 123
 124         /* --------------------------------------------------------------- */
 125
 126         /* disable Power Level Indicator */
 127         regs[R_EP1]  |= 0x40;
 128
 129         /* make sure thermometer is off */
 130         regs[R_TM]   &= ~0x10;
 131
 132         /* frequency dependent parameters */
 133
 134         tda18271_calc_ir_measure(fe, &freq);
 135
 136         tda18271_calc_bp_filter(fe, &freq);
 137
 138         tda18271_calc_rf_band(fe, &freq);
 139
 140         tda18271_calc_gain_taper(fe, &freq);
 141
 142         /* --------------------------------------------------------------- */
 143
 144         /* dual tuner and agc1 extra configuration */
 145
 146         switch (priv->role) {
 147         case TDA18271_MASTER:
 148                 regs[R_EB1]  |= 0x04; /* main vco */
 149                 break;
 150         case TDA18271_SLAVE:
 151                 regs[R_EB1]  &= ~0x04; /* cal vco */
 152                 break;
 153         }
 154
 155         /* agc1 always active */
 156         regs[R_EB1]  &= ~0x02;
 157
 158         /* agc1 has priority on agc2 */
 159         regs[R_EB1]  &= ~0x01;
 160
 161         ret = tda18271_write_regs(fe, R_EB1, 1);
 162         if (tda_fail(ret))
 163                 goto fail;
 164
 165         /* --------------------------------------------------------------- */
 166
 167         N = map->if_freq * 1000 + freq;
 168
 169         switch (priv->role) {
 170         case TDA18271_MASTER:
 171                 tda18271_calc_main_pll(fe, N);
 172                 tda18271_set_if_notch(fe);
 173                 tda18271_write_regs(fe, R_MPD, 4);
 174                 break;
 175         case TDA18271_SLAVE:
 176                 tda18271_calc_cal_pll(fe, N);
 177                 tda18271_write_regs(fe, R_CPD, 4);
 178
 179                 regs[R_MPD] = regs[R_CPD] & 0x7f;
 180                 tda18271_set_if_notch(fe);
 181                 tda18271_write_regs(fe, R_MPD, 1);
 182                 break;
 183         }
 184
 185         ret = tda18271_write_regs(fe, R_TM, 7);
 186         if (tda_fail(ret))
 187                 goto fail;
 188
 189         /* force charge pump source */
 190         charge_pump_source(fe, 1);
 191
 192         msleep(1);
 193
 194         /* return pll to normal operation */
 195         charge_pump_source(fe, 0);
 196
 197         msleep(20);
 198
 199         if (priv->id == TDA18271HDC2) {
 200                 /* set rfagc to normal speed mode */
 201                 if (map->fm_rfn)
 202                         regs[R_EP3] &= ~0x04;
 203                 else
 204                         regs[R_EP3] |= 0x04;
 205                 ret = tda18271_write_regs(fe, R_EP3, 1);
 206         }
 207 fail:
 208         return ret;
 209 }
 210
 211 static int tda18271_read_thermometer(struct dvb_frontend *fe)
 212 {
 213         struct tda18271_priv *priv = fe->tuner_priv;
 214         unsigned char *regs = priv->tda18271_regs;
 215         int tm;
 216
 217         /* switch thermometer on */
 218         regs[R_TM]   |= 0x10;
 219         tda18271_write_regs(fe, R_TM, 1);
 220
 221         /* read thermometer info */
 222         tda18271_read_regs(fe);
 223
 224         if ((((regs[R_TM] & 0x0f) == 0x00) && ((regs[R_TM] & 0x20) == 0x20)) ||
 225             (((regs[R_TM] & 0x0f) == 0x08) && ((regs[R_TM] & 0x20) == 0x00))) {
 226
 227                 if ((regs[R_TM] & 0x20) == 0x20)
 228                         regs[R_TM] &= ~0x20;
 229                 else
 230                         regs[R_TM] |= 0x20;
 231
 232                 tda18271_write_regs(fe, R_TM, 1);
 233
 234                 msleep(10); /* temperature sensing */
 235
 236                 /* read thermometer info */
 237                 tda18271_read_regs(fe);
 238         }
 239
 240         tm = tda18271_lookup_thermometer(fe);
 241
 242         /* switch thermometer off */
 243         regs[R_TM]   &= ~0x10;
 244         tda18271_write_regs(fe, R_TM, 1);
 245
 246         /* set CAL mode to normal */
 247         regs[R_EP4]  &= ~0x03;
 248         tda18271_write_regs(fe, R_EP4, 1);
 249
 250         return tm;
 251 }
 252
 253 /* ------------------------------------------------------------------ */
 254
 255 static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe,
 256                                                      u32 freq)
 257 {
 258         struct tda18271_priv *priv = fe->tuner_priv;
 259         struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
 260         unsigned char *regs = priv->tda18271_regs;
 261         int i, ret;
 262         u8 tm_current, dc_over_dt, rf_tab;
 263         s32 rfcal_comp, approx;
 264
 265         /* power up */
 266         ret = tda18271_set_standby_mode(fe, 0, 0, 0);
 267         if (tda_fail(ret))
 268                 goto fail;
 269
 270         /* read die current temperature */
 271         tm_current = tda18271_read_thermometer(fe);
 272
 273         /* frequency dependent parameters */
 274
 275         tda18271_calc_rf_cal(fe, &freq);
 276         rf_tab = regs[R_EB14];
 277
 278         i = tda18271_lookup_rf_band(fe, &freq, NULL);
 279         if (tda_fail(i))
 280                 return i;
 281
 282         if ((0 == map[i].rf3) || (freq / 1000 < map[i].rf2)) {
 283                 approx = map[i].rf_a1 * (s32)(freq / 1000 - map[i].rf1) +
 284                         map[i].rf_b1 + rf_tab;
 285         } else {
 286                 approx = map[i].rf_a2 * (s32)(freq / 1000 - map[i].rf2) +
 287                         map[i].rf_b2 + rf_tab;
 288         }
 289
 290         if (approx < 0)
 291                 approx = 0;
 292         if (approx > 255)
 293                 approx = 255;
 294
 295         tda18271_lookup_map(fe, RF_CAL_DC_OVER_DT, &freq, &dc_over_dt);
 296
 297         /* calculate temperature compensation */
 298         rfcal_comp = dc_over_dt * (s32)(tm_current - priv->tm_rfcal) / 1000;
 299
 300         regs[R_EB14] = (unsigned char)(approx + rfcal_comp);
 301         ret = tda18271_write_regs(fe, R_EB14, 1);
 302 fail:
 303         return ret;
 304 }
 305
 306 static int tda18271_por(struct dvb_frontend *fe)
 307 {
 308         struct tda18271_priv *priv = fe->tuner_priv;
 309         unsigned char *regs = priv->tda18271_regs;
 310         int ret;
 311
 312         /* power up detector 1 */
 313         regs[R_EB12] &= ~0x20;
 314         ret = tda18271_write_regs(fe, R_EB12, 1);
 315         if (tda_fail(ret))
 316                 goto fail;
 317
 318         regs[R_EB18] &= ~0x80; /* turn agc1 loop on */
 319         regs[R_EB18] &= ~0x03; /* set agc1_gain to  6 dB */
 320         ret = tda18271_write_regs(fe, R_EB18, 1);
 321         if (tda_fail(ret))
 322                 goto fail;
 323
 324         regs[R_EB21] |= 0x03; /* set agc2_gain to -6 dB */
 325
 326         /* POR mode */
 327         ret = tda18271_set_standby_mode(fe, 1, 0, 0);
 328         if (tda_fail(ret))
 329                 goto fail;
 330
 331         /* disable 1.5 MHz low pass filter */
 332         regs[R_EB23] &= ~0x04; /* forcelp_fc2_en = 0 */
 333         regs[R_EB23] &= ~0x02; /* XXX: lp_fc[2] = 0 */
 334         ret = tda18271_write_regs(fe, R_EB21, 3);
 335 fail:
 336         return ret;
 337 }
 338
 339 static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
 340 {
 341         struct tda18271_priv *priv = fe->tuner_priv;
 342         unsigned char *regs = priv->tda18271_regs;
 343         u32 N;
 344
 345         /* set CAL mode to normal */
 346         regs[R_EP4]  &= ~0x03;
 347         tda18271_write_regs(fe, R_EP4, 1);
 348
 349         /* switch off agc1 */
 350         regs[R_EP3]  |= 0x40; /* sm_lt = 1 */
 351
 352         regs[R_EB18] |= 0x03; /* set agc1_gain to 15 dB */
 353         tda18271_write_regs(fe, R_EB18, 1);
 354
 355         /* frequency dependent parameters */
 356
 357         tda18271_calc_bp_filter(fe, &freq);
 358         tda18271_calc_gain_taper(fe, &freq);
 359         tda18271_calc_rf_band(fe, &freq);
 360         tda18271_calc_km(fe, &freq);
 361
 362         tda18271_write_regs(fe, R_EP1, 3);
 363         tda18271_write_regs(fe, R_EB13, 1);
 364
 365         /* main pll charge pump source */
 366         tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
 367
 368         /* cal pll charge pump source */
 369         tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 1);
 370
 371         /* force dcdc converter to 0 V */
 372         regs[R_EB14] = 0x00;
 373         tda18271_write_regs(fe, R_EB14, 1);
 374
 375         /* disable plls lock */
 376         regs[R_EB20] &= ~0x20;
 377         tda18271_write_regs(fe, R_EB20, 1);
 378
 379         /* set CAL mode to RF tracking filter calibration */
 380         regs[R_EP4]  |= 0x03;
 381         tda18271_write_regs(fe, R_EP4, 2);
 382
 383         /* --------------------------------------------------------------- */
 384
 385         /* set the internal calibration signal */
 386         N = freq;
 387
 388         tda18271_calc_cal_pll(fe, N);
 389         tda18271_write_regs(fe, R_CPD, 4);
 390
 391         /* downconvert internal calibration */
 392         N += 1000000;
 393
 394         tda18271_calc_main_pll(fe, N);
 395         tda18271_write_regs(fe, R_MPD, 4);
 396
 397         msleep(5);
 398
 399         tda18271_write_regs(fe, R_EP2, 1);
 400         tda18271_write_regs(fe, R_EP1, 1);
 401         tda18271_write_regs(fe, R_EP2, 1);
 402         tda18271_write_regs(fe, R_EP1, 1);
 403
 404         /* --------------------------------------------------------------- */
 405
 406         /* normal operation for the main pll */
 407         tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
 408
 409         /* normal operation for the cal pll  */
 410         tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 0);
 411
 412         msleep(10); /* plls locking */
 413
 414         /* launch the rf tracking filters calibration */
 415         regs[R_EB20]  |= 0x20;
 416         tda18271_write_regs(fe, R_EB20, 1);
 417
 418         msleep(60); /* calibration */
 419
 420         /* --------------------------------------------------------------- */
 421
 422         /* set CAL mode to normal */
 423         regs[R_EP4]  &= ~0x03;
 424
 425         /* switch on agc1 */
 426         regs[R_EP3]  &= ~0x40; /* sm_lt = 0 */
 427
 428         regs[R_EB18] &= ~0x03; /* set agc1_gain to  6 dB */
 429         tda18271_write_regs(fe, R_EB18, 1);
 430
 431         tda18271_write_regs(fe, R_EP3, 2);
 432
 433         /* synchronization */
 434         tda18271_write_regs(fe, R_EP1, 1);
 435
 436         /* get calibration result */
 437         tda18271_read_extended(fe);
 438
 439         return regs[R_EB14];
 440 }
 441
 442 static int tda18271_powerscan(struct dvb_frontend *fe,
 443                               u32 *freq_in, u32 *freq_out)
 444 {
 445         struct tda18271_priv *priv = fe->tuner_priv;
 446         unsigned char *regs = priv->tda18271_regs;
 447         int sgn, bcal, count, wait, ret;
 448         u8 cid_target;
 449         u16 count_limit;
 450         u32 freq;
 451
 452         freq = *freq_in;
 453
 454         tda18271_calc_rf_band(fe, &freq);
 455         tda18271_calc_rf_cal(fe, &freq);
 456         tda18271_calc_gain_taper(fe, &freq);
 457         tda18271_lookup_cid_target(fe, &freq, &cid_target, &count_limit);
 458
 459         tda18271_write_regs(fe, R_EP2, 1);
 460         tda18271_write_regs(fe, R_EB14, 1);
 461
 462         /* downconvert frequency */
 463         freq += 1000000;
 464
 465         tda18271_calc_main_pll(fe, freq);
 466         tda18271_write_regs(fe, R_MPD, 4);
 467
 468         msleep(5); /* pll locking */
 469
 470         /* detection mode */
 471         regs[R_EP4]  &= ~0x03;
 472         regs[R_EP4]  |= 0x01;
 473         tda18271_write_regs(fe, R_EP4, 1);
 474
 475         /* launch power detection measurement */
 476         tda18271_write_regs(fe, R_EP2, 1);
 477
 478         /* read power detection info, stored in EB10 */
 479         ret = tda18271_read_extended(fe);
 480         if (tda_fail(ret))
 481                 return ret;
 482
 483         /* algorithm initialization */
 484         sgn = 1;
 485         *freq_out = *freq_in;
 486         bcal = 0;
 487         count = 0;
 488         wait = false;
 489
 490         while ((regs[R_EB10] & 0x3f) < cid_target) {
 491                 /* downconvert updated freq to 1 MHz */
 492                 freq = *freq_in + (sgn * count) + 1000000;
 493
 494                 tda18271_calc_main_pll(fe, freq);
 495                 tda18271_write_regs(fe, R_MPD, 4);
 496
 497                 if (wait) {
 498                         msleep(5); /* pll locking */
 499                         wait = false;
 500                 } else
 501                         udelay(100); /* pll locking */
 502
 503                 /* launch power detection measurement */
 504                 tda18271_write_regs(fe, R_EP2, 1);
 505
 506                 /* read power detection info, stored in EB10 */
 507                 ret = tda18271_read_extended(fe);
 508                 if (tda_fail(ret))
 509                         return ret;
 510
 511                 count += 200;
 512
 513                 if (count <= count_limit)
 514                         continue;
 515
 516                 if (sgn <= 0)
 517                         break;
 518
 519                 sgn = -1 * sgn;
 520                 count = 200;
 521                 wait = true;
 522         }
 523
 524         if ((regs[R_EB10] & 0x3f) >= cid_target) {
 525                 bcal = 1;
 526                 *freq_out = freq - 1000000;
 527         } else
 528                 bcal = 0;
 529
 530         tda_cal("bcal = %d, freq_in = %d, freq_out = %d (freq = %d)\n",
 531                 bcal, *freq_in, *freq_out, freq);
 532
 533         return bcal;
 534 }
 535
 536 static int tda18271_powerscan_init(struct dvb_frontend *fe)
 537 {
 538         struct tda18271_priv *priv = fe->tuner_priv;
 539         unsigned char *regs = priv->tda18271_regs;
 540         int ret;
 541
 542         /* set standard to digital */
 543         regs[R_EP3]  &= ~0x1f; /* clear std bits */
 544         regs[R_EP3]  |= 0x12;
 545
 546         /* set cal mode to normal */
 547         regs[R_EP4]  &= ~0x03;
 548
 549         /* update IF output level */
 550         regs[R_EP4]  &= ~0x1c; /* clear if level bits */
 551
 552         ret = tda18271_write_regs(fe, R_EP3, 2);
 553         if (tda_fail(ret))
 554                 goto fail;
 555
 556         regs[R_EB18] &= ~0x03; /* set agc1_gain to   6 dB */
 557         ret = tda18271_write_regs(fe, R_EB18, 1);
 558         if (tda_fail(ret))
 559                 goto fail;
 560
 561         regs[R_EB21] &= ~0x03; /* set agc2_gain to -15 dB */
 562
 563         /* 1.5 MHz low pass filter */
 564         regs[R_EB23] |= 0x04; /* forcelp_fc2_en = 1 */
 565         regs[R_EB23] |= 0x02; /* lp_fc[2] = 1 */
 566
 567         ret = tda18271_write_regs(fe, R_EB21, 3);
 568 fail:
 569         return ret;
 570 }
 571
 572 static int tda18271_rf_tracking_filters_init(struct dvb_frontend *fe, u32 freq)
 573 {
 574         struct tda18271_priv *priv = fe->tuner_priv;
 575         struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
 576         unsigned char *regs = priv->tda18271_regs;
 577         int bcal, rf, i;
 578         s32 divisor, dividend;
 579 #define RF1 0
 580 #define RF2 1
 581 #define RF3 2
 582         u32 rf_default[3];
 583         u32 rf_freq[3];
 584         s32 prog_cal[3];
 585         s32 prog_tab[3];
 586
 587         i = tda18271_lookup_rf_band(fe, &freq, NULL);
 588
 589         if (tda_fail(i))
 590                 return i;
 591
 592         rf_default[RF1] = 1000 * map[i].rf1_def;
 593         rf_default[RF2] = 1000 * map[i].rf2_def;
 594         rf_default[RF3] = 1000 * map[i].rf3_def;
 595
 596         for (rf = RF1; rf <= RF3; rf++) {
 597                 if (0 == rf_default[rf])
 598                         return 0;
 599                 tda_cal("freq = %d, rf = %d\n", freq, rf);
 600
 601                 /* look for optimized calibration frequency */
 602                 bcal = tda18271_powerscan(fe, &rf_default[rf], &rf_freq[rf]);
 603                 if (tda_fail(bcal))
 604                         return bcal;
 605
 606                 tda18271_calc_rf_cal(fe, &rf_freq[rf]);
 607                 prog_tab[rf] = (s32)regs[R_EB14];
 608
 609                 if (1 == bcal)
 610                         prog_cal[rf] =
 611                                 (s32)tda18271_calibrate_rf(fe, rf_freq[rf]);
 612                 else
 613                         prog_cal[rf] = prog_tab[rf];
 614
 615                 switch (rf) {
 616                 case RF1:
 617                         map[i].rf_a1 = 0;
 618                         map[i].rf_b1 = (prog_cal[RF1] - prog_tab[RF1]);
 619                         map[i].rf1   = rf_freq[RF1] / 1000;
 620                         break;
 621                 case RF2:
 622                         dividend = (prog_cal[RF2] - prog_tab[RF2] -
 623                                     prog_cal[RF1] + prog_tab[RF1]);
 624                         divisor = (s32)(rf_freq[RF2] - rf_freq[RF1]) / 1000;
 625                         map[i].rf_a1 = (dividend / divisor);
 626                         map[i].rf2   = rf_freq[RF2] / 1000;
 627                         break;
 628                 case RF3:
 629                         dividend = (prog_cal[RF3] - prog_tab[RF3] -
 630                                     prog_cal[RF2] + prog_tab[RF2]);
 631                         divisor = (s32)(rf_freq[RF3] - rf_freq[RF2]) / 1000;
 632                         map[i].rf_a2 = (dividend / divisor);
 633                         map[i].rf_b2 = (prog_cal[RF2] - prog_tab[RF2]);
 634                         map[i].rf3   = rf_freq[RF3] / 1000;
 635                         break;
 636                 default:
 637                         BUG();
 638                 }
 639         }
 640
 641         return 0;
 642 }
 643
 644 static int tda18271_calc_rf_filter_curve(struct dvb_frontend *fe)
 645 {
 646         struct tda18271_priv *priv = fe->tuner_priv;
 647         unsigned int i;
 648         int ret;
 649
 650         tda_info("performing RF tracking filter calibration\n");
 651
 652         /* wait for die temperature stabilization */
 653         msleep(200);
 654
 655         ret = tda18271_powerscan_init(fe);
 656         if (tda_fail(ret))
 657                 goto fail;
 658
 659         /* rf band calibration */
 660         for (i = 0; priv->rf_cal_state[i].rfmax != 0; i++) {
 661                 ret =
 662                 tda18271_rf_tracking_filters_init(fe, 1000 *
 663                                                   priv->rf_cal_state[i].rfmax);
 664                 if (tda_fail(ret))
 665                         goto fail;
 666         }
 667
 668         priv->tm_rfcal = tda18271_read_thermometer(fe);
 669 fail:
 670         return ret;
 671 }
 672
 673 /* ------------------------------------------------------------------ */
 674
 675 static int tda18271c2_rf_cal_init(struct dvb_frontend *fe)
 676 {
 677         struct tda18271_priv *priv = fe->tuner_priv;
 678         unsigned char *regs = priv->tda18271_regs;
 679         int ret;
 680
 681         /* test RF_CAL_OK to see if we need init */
 682         if ((regs[R_EP1] & 0x10) == 0)
 683                 priv->cal_initialized = false;
 684
 685         if (priv->cal_initialized)
 686                 return 0;
 687
 688         ret = tda18271_calc_rf_filter_curve(fe);
 689         if (tda_fail(ret))
 690                 goto fail;
 691
 692         ret = tda18271_por(fe);
 693         if (tda_fail(ret))
 694                 goto fail;
 695
 696         tda_info("RF tracking filter calibration complete\n");
 697
 698         priv->cal_initialized = true;
 699         goto end;
 700 fail:
 701         tda_info("RF tracking filter calibration failed!\n");
 702 end:
 703         return ret;
 704 }
 705
 706 static int tda18271c1_rf_tracking_filter_calibration(struct dvb_frontend *fe,
 707                                                      u32 freq, u32 bw)
 708 {
 709         struct tda18271_priv *priv = fe->tuner_priv;
 710         unsigned char *regs = priv->tda18271_regs;
 711         int ret;
 712         u32 N = 0;
 713
 714         /* calculate bp filter */
 715         tda18271_calc_bp_filter(fe, &freq);
 716         tda18271_write_regs(fe, R_EP1, 1);
 717
 718         regs[R_EB4]  &= 0x07;
 719         regs[R_EB4]  |= 0x60;
 720         tda18271_write_regs(fe, R_EB4, 1);
 721
 722         regs[R_EB7]   = 0x60;
 723         tda18271_write_regs(fe, R_EB7, 1);
 724
 725         regs[R_EB14]  = 0x00;
 726         tda18271_write_regs(fe, R_EB14, 1);
 727
 728         regs[R_EB20]  = 0xcc;
 729         tda18271_write_regs(fe, R_EB20, 1);
 730
 731         /* set cal mode to RF tracking filter calibration */
 732         regs[R_EP4]  |= 0x03;
 733
 734         /* calculate cal pll */
 735
 736         switch (priv->mode) {
 737         case TDA18271_ANALOG:
 738                 N = freq - 1250000;
 739                 break;
 740         case TDA18271_DIGITAL:
 741                 N = freq + bw / 2;
 742                 break;
 743         }
 744
 745         tda18271_calc_cal_pll(fe, N);
 746
 747         /* calculate main pll */
 748
 749         switch (priv->mode) {
 750         case TDA18271_ANALOG:
 751                 N = freq - 250000;
 752                 break;
 753         case TDA18271_DIGITAL:
 754                 N = freq + bw / 2 + 1000000;
 755                 break;
 756         }
 757
 758         tda18271_calc_main_pll(fe, N);
 759
 760         ret = tda18271_write_regs(fe, R_EP3, 11);
 761         if (tda_fail(ret))
 762                 return ret;
 763
 764         msleep(5); /* RF tracking filter calibration initialization */
 765
 766         /* search for K,M,CO for RF calibration */
 767         tda18271_calc_km(fe, &freq);
 768         tda18271_write_regs(fe, R_EB13, 1);
 769
 770         /* search for rf band */
 771         tda18271_calc_rf_band(fe, &freq);
 772
 773         /* search for gain taper */
 774         tda18271_calc_gain_taper(fe, &freq);
 775
 776         tda18271_write_regs(fe, R_EP2, 1);
 777         tda18271_write_regs(fe, R_EP1, 1);
 778         tda18271_write_regs(fe, R_EP2, 1);
 779         tda18271_write_regs(fe, R_EP1, 1);
 780
 781         regs[R_EB4]  &= 0x07;
 782         regs[R_EB4]  |= 0x40;
 783         tda18271_write_regs(fe, R_EB4, 1);
 784
 785         regs[R_EB7]   = 0x40;
 786         tda18271_write_regs(fe, R_EB7, 1);
 787         msleep(10); /* pll locking */
 788
 789         regs[R_EB20]  = 0xec;
 790         tda18271_write_regs(fe, R_EB20, 1);
 791         msleep(60); /* RF tracking filter calibration completion */
 792
 793         regs[R_EP4]  &= ~0x03; /* set cal mode to normal */
 794         tda18271_write_regs(fe, R_EP4, 1);
 795
 796         tda18271_write_regs(fe, R_EP1, 1);
 797
 798         /* RF tracking filter correction for VHF_Low band */
 799         if (0 == tda18271_calc_rf_cal(fe, &freq))
 800                 tda18271_write_regs(fe, R_EB14, 1);
 801
 802         return 0;
 803 }
 804
 805 /* ------------------------------------------------------------------ */
 806
 807 static int tda18271_ir_cal_init(struct dvb_frontend *fe)
 808 {
 809         struct tda18271_priv *priv = fe->tuner_priv;
 810         unsigned char *regs = priv->tda18271_regs;
 811         int ret;
 812
 813         ret = tda18271_read_regs(fe);
 814         if (tda_fail(ret))
 815                 goto fail;
 816
 817         /* test IR_CAL_OK to see if we need init */
 818         if ((regs[R_EP1] & 0x08) == 0)
 819                 ret = tda18271_init_regs(fe);
 820 fail:
 821         return ret;
 822 }
 823
 824 static int tda18271_init(struct dvb_frontend *fe)
 825 {
 826         struct tda18271_priv *priv = fe->tuner_priv;
 827         int ret;
 828
 829         mutex_lock(&priv->lock);
 830
 831         /* full power up */
 832         ret = tda18271_set_standby_mode(fe, 0, 0, 0);
 833         if (tda_fail(ret))
 834                 goto fail;
 835
 836         /* initialization */
 837         ret = tda18271_ir_cal_init(fe);
 838         if (tda_fail(ret))
 839                 goto fail;
 840
 841         if (priv->id == TDA18271HDC2)
 842                 tda18271c2_rf_cal_init(fe);
 843 fail:
 844         mutex_unlock(&priv->lock);
 845
 846         return ret;
 847 }
 848
 849 static int tda18271_sleep(struct dvb_frontend *fe)
 850 {
 851         struct tda18271_priv *priv = fe->tuner_priv;
 852         int ret;
 853
 854         mutex_lock(&priv->lock);
 855
 856         /* enter standby mode, with required output features enabled */
 857         ret = tda18271_toggle_output(fe, 1);
 858
 859         mutex_unlock(&priv->lock);
 860
 861         return ret;
 862 }
 863
 864 /* ------------------------------------------------------------------ */
 865
 866 static int tda18271_agc(struct dvb_frontend *fe)
 867 {
 868         struct tda18271_priv *priv = fe->tuner_priv;
 869         int ret = 0;
 870
 871         switch (priv->config) {
 872         case TDA8290_LNA_OFF:
 873                 /* no external agc configuration required */
 874                 if (tda18271_debug & DBG_ADV)
 875                         tda_dbg("no agc configuration provided\n");
 876                 break;
 877         case TDA8290_LNA_ON_BRIDGE:
 878                 /* switch with GPIO of saa713x */
 879                 tda_dbg("invoking callback\n");
 880                 if (fe->callback)
 881                         ret = fe->callback(priv->i2c_props.adap->algo_data,
 882                                            DVB_FRONTEND_COMPONENT_TUNER,
 883                                            TDA18271_CALLBACK_CMD_AGC_ENABLE,
 884                                            priv->mode);
 885                 break;
 886         case TDA8290_LNA_GP0_HIGH_ON:
 887         case TDA8290_LNA_GP0_HIGH_OFF:
 888         default:
 889                 /* n/a - currently not supported */
 890                 tda_err("unsupported configuration: %d\n", priv->config);
 891                 ret = -EINVAL;
 892                 break;
 893         }
 894         return ret;
 895 }
 896
 897 static int tda18271_tune(struct dvb_frontend *fe,
 898                          struct tda18271_std_map_item *map, u32 freq, u32 bw)
 899 {
 900         struct tda18271_priv *priv = fe->tuner_priv;
 901         int ret;
 902
 903         tda_dbg("freq = %d, ifc = %d, bw = %d, agc_mode = %d, std = %d\n",
 904                 freq, map->if_freq, bw, map->agc_mode, map->std);
 905
 906         ret = tda18271_agc(fe);
 907         if (tda_fail(ret))
 908                 tda_warn("failed to configure agc\n");
 909
 910         ret = tda18271_init(fe);
 911         if (tda_fail(ret))
 912                 goto fail;
 913
 914         mutex_lock(&priv->lock);
 915
 916         switch (priv->id) {
 917         case TDA18271HDC1:
 918                 tda18271c1_rf_tracking_filter_calibration(fe, freq, bw);
 919                 break;
 920         case TDA18271HDC2:
 921                 tda18271c2_rf_tracking_filters_correction(fe, freq);
 922                 break;
 923         }
 924         ret = tda18271_channel_configuration(fe, map, freq, bw);
 925
 926         mutex_unlock(&priv->lock);
 927 fail:
 928         return ret;
 929 }
 930
 931 /* ------------------------------------------------------------------ */
 932
 933 static int tda18271_set_params(struct dvb_frontend *fe)
 934 {
 935         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 936         u32 delsys = c->delivery_system;
 937         u32 bw = c->bandwidth_hz;
 938         u32 freq = c->frequency;
 939         struct tda18271_priv *priv = fe->tuner_priv;
 940         struct tda18271_std_map *std_map = &priv->std;
 941         struct tda18271_std_map_item *map;
 942         int ret;
 943
 944         priv->mode = TDA18271_DIGITAL;
 945
 946         switch (delsys) {
 947         case SYS_ATSC:
 948                 map = &std_map->atsc_6;
 949                 bw = 6000000;
 950                 break;
 951         case SYS_ISDBT:
 952         case SYS_DVBT:
 953         case SYS_DVBT2:
 954                 if (bw <= 6000000) {
 955                         map = &std_map->dvbt_6;
 956                 } else if (bw <= 7000000) {
 957                         map = &std_map->dvbt_7;
 958                 } else {
 959                         map = &std_map->dvbt_8;
 960                 }
 961                 break;
 962         case SYS_DVBC_ANNEX_B:
 963                 bw = 6000000;
 964                 /* falltrough */
 965         case SYS_DVBC_ANNEX_A:
 966         case SYS_DVBC_ANNEX_C:
 967                 if (bw <= 6000000) {
 968                         map = &std_map->qam_6;
 969                 } else if (bw <= 7000000) {
 970                         map = &std_map->qam_7;
 971                 } else {
 972                         map = &std_map->qam_8;
 973                 }
 974                 break;
 975         default:
 976                 tda_warn("modulation type not supported!\n");
 977                 return -EINVAL;
 978         }
 979
 980         /* When tuning digital, the analog demod must be tri-stated */
 981         if (fe->ops.analog_ops.standby)
 982                 fe->ops.analog_ops.standby(fe);
 983
 984         ret = tda18271_tune(fe, map, freq, bw);
 985
 986         if (tda_fail(ret))
 987                 goto fail;
 988
 989         priv->if_freq   = map->if_freq;
 990         priv->frequency = freq;
 991         priv->bandwidth = bw;
 992 fail:
 993         return ret;
 994 }
 995
 996 static int tda18271_set_analog_params(struct dvb_frontend *fe,
 997                                       struct analog_parameters *params)
 998 {
 999         struct tda18271_priv *priv = fe->tuner_priv;
1000         struct tda18271_std_map *std_map = &priv->std;
1001         struct tda18271_std_map_item *map;
1002         char *mode;
1003         int ret;
1004         u32 freq = params->frequency * 125 *
1005                 ((params->mode == V4L2_TUNER_RADIO) ? 1 : 1000) / 2;
1006
1007         priv->mode = TDA18271_ANALOG;
1008
1009         if (params->mode == V4L2_TUNER_RADIO) {
1010                 map = &std_map->fm_radio;
1011                 mode = "fm";
1012         } else if (params->std & V4L2_STD_MN) {
1013                 map = &std_map->atv_mn;
1014                 mode = "MN";
1015         } else if (params->std & V4L2_STD_B) {
1016                 map = &std_map->atv_b;
1017                 mode = "B";
1018         } else if (params->std & V4L2_STD_GH) {
1019                 map = &std_map->atv_gh;
1020                 mode = "GH";
1021         } else if (params->std & V4L2_STD_PAL_I) {
1022                 map = &std_map->atv_i;
1023                 mode = "I";
1024         } else if (params->std & V4L2_STD_DK) {
1025                 map = &std_map->atv_dk;
1026                 mode = "DK";
1027         } else if (params->std & V4L2_STD_SECAM_L) {
1028                 map = &std_map->atv_l;
1029                 mode = "L";
1030         } else if (params->std & V4L2_STD_SECAM_LC) {
1031                 map = &std_map->atv_lc;
1032                 mode = "L'";
1033         } else {
1034                 map = &std_map->atv_i;
1035                 mode = "xx";
1036         }
1037
1038         tda_dbg("setting tda18271 to system %s\n", mode);
1039
1040         ret = tda18271_tune(fe, map, freq, 0);
1041
1042         if (tda_fail(ret))
1043                 goto fail;
1044
1045         priv->if_freq   = map->if_freq;
1046         priv->frequency = freq;
1047         priv->bandwidth = 0;
1048 fail:
1049         return ret;
1050 }
1051
1052 static int tda18271_release(struct dvb_frontend *fe)
1053 {
1054         struct tda18271_priv *priv = fe->tuner_priv;
1055
1056         mutex_lock(&tda18271_list_mutex);
1057
1058         if (priv)
1059                 hybrid_tuner_release_state(priv);
1060
1061         mutex_unlock(&tda18271_list_mutex);
1062
1063         fe->tuner_priv = NULL;
1064
1065         return 0;
1066 }
1067
1068 static int tda18271_get_frequency(struct dvb_frontend *fe, u32 *frequency)
1069 {
1070         struct tda18271_priv *priv = fe->tuner_priv;
1071         *frequency = priv->frequency;
1072         return 0;
1073 }
1074
1075 static int tda18271_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
1076 {
1077         struct tda18271_priv *priv = fe->tuner_priv;
1078         *bandwidth = priv->bandwidth;
1079         return 0;
1080 }
1081
1082 static int tda18271_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
1083 {
1084         struct tda18271_priv *priv = fe->tuner_priv;
1085         *frequency = (u32)priv->if_freq * 1000;
1086         return 0;
1087 }
1088
1089 /* ------------------------------------------------------------------ */
1090
1091 #define tda18271_update_std(std_cfg, name) do {                         \
1092         if (map->std_cfg.if_freq +                                      \
1093                 map->std_cfg.agc_mode + map->std_cfg.std +              \
1094                 map->std_cfg.if_lvl + map->std_cfg.rfagc_top > 0) {     \
1095                 tda_dbg("Using custom std config for %s\n", name);      \
1096                 memcpy(&std->std_cfg, &map->std_cfg,                    \
1097                         sizeof(struct tda18271_std_map_item));          \
1098         } } while (0)
1099
1100 #define tda18271_dump_std_item(std_cfg, name) do {                      \
1101         tda_dbg("(%s) if_freq = %d, agc_mode = %d, std = %d, "          \
1102                 "if_lvl = %d, rfagc_top = 0x%02x\n",                    \
1103                 name, std->std_cfg.if_freq,                             \
1104                 std->std_cfg.agc_mode, std->std_cfg.std,                \
1105                 std->std_cfg.if_lvl, std->std_cfg.rfagc_top);           \
1106         } while (0)
1107
1108 static int tda18271_dump_std_map(struct dvb_frontend *fe)
1109 {
1110         struct tda18271_priv *priv = fe->tuner_priv;
1111         struct tda18271_std_map *std = &priv->std;
1112
1113         tda_dbg("========== STANDARD MAP SETTINGS ==========\n");
1114         tda18271_dump_std_item(fm_radio, "  fm  ");
1115         tda18271_dump_std_item(atv_b,  "atv b ");
1116         tda18271_dump_std_item(atv_dk, "atv dk");
1117         tda18271_dump_std_item(atv_gh, "atv gh");
1118         tda18271_dump_std_item(atv_i,  "atv i ");
1119         tda18271_dump_std_item(atv_l,  "atv l ");
1120         tda18271_dump_std_item(atv_lc, "atv l'");
1121         tda18271_dump_std_item(atv_mn, "atv mn");
1122         tda18271_dump_std_item(atsc_6, "atsc 6");
1123         tda18271_dump_std_item(dvbt_6, "dvbt 6");
1124         tda18271_dump_std_item(dvbt_7, "dvbt 7");
1125         tda18271_dump_std_item(dvbt_8, "dvbt 8");
1126         tda18271_dump_std_item(qam_6,  "qam 6 ");
1127         tda18271_dump_std_item(qam_7,  "qam 7 ");
1128         tda18271_dump_std_item(qam_8,  "qam 8 ");
1129
1130         return 0;
1131 }
1132
1133 static int tda18271_update_std_map(struct dvb_frontend *fe,
1134                                    struct tda18271_std_map *map)
1135 {
1136         struct tda18271_priv *priv = fe->tuner_priv;
1137         struct tda18271_std_map *std = &priv->std;
1138
1139         if (!map)
1140                 return -EINVAL;
1141
1142         tda18271_update_std(fm_radio, "fm");
1143         tda18271_update_std(atv_b,  "atv b");
1144         tda18271_update_std(atv_dk, "atv dk");
1145         tda18271_update_std(atv_gh, "atv gh");
1146         tda18271_update_std(atv_i,  "atv i");
1147         tda18271_update_std(atv_l,  "atv l");
1148         tda18271_update_std(atv_lc, "atv l'");
1149         tda18271_update_std(atv_mn, "atv mn");
1150         tda18271_update_std(atsc_6, "atsc 6");
1151         tda18271_update_std(dvbt_6, "dvbt 6");
1152         tda18271_update_std(dvbt_7, "dvbt 7");
1153         tda18271_update_std(dvbt_8, "dvbt 8");
1154         tda18271_update_std(qam_6,  "qam 6");
1155         tda18271_update_std(qam_7,  "qam 7");
1156         tda18271_update_std(qam_8,  "qam 8");
1157
1158         return 0;
1159 }
1160
1161 static int tda18271_get_id(struct dvb_frontend *fe)
1162 {
1163         struct tda18271_priv *priv = fe->tuner_priv;
1164         unsigned char *regs = priv->tda18271_regs;
1165         char *name;
1166         int ret;
1167
1168         mutex_lock(&priv->lock);
1169         ret = tda18271_read_regs(fe);
1170         mutex_unlock(&priv->lock);
1171
1172         if (ret) {
1173                 tda_info("Error reading device ID @ %d-%04x, bailing out.\n",
1174                          i2c_adapter_id(priv->i2c_props.adap),
1175                          priv->i2c_props.addr);
1176                 return -EIO;
1177         }
1178
1179         switch (regs[R_ID] & 0x7f) {
1180         case 3:
1181                 name = "TDA18271HD/C1";
1182                 priv->id = TDA18271HDC1;
1183                 break;
1184         case 4:
1185                 name = "TDA18271HD/C2";
1186                 priv->id = TDA18271HDC2;
1187                 break;
1188         default:
1189                 tda_info("Unknown device (%i) detected @ %d-%04x, device not supported.\n",
1190                          regs[R_ID], i2c_adapter_id(priv->i2c_props.adap),
1191                          priv->i2c_props.addr);
1192                 return -EINVAL;
1193         }
1194
1195         tda_info("%s detected @ %d-%04x\n", name,
1196                  i2c_adapter_id(priv->i2c_props.adap), priv->i2c_props.addr);
1197
1198         return 0;
1199 }
1200
1201 static int tda18271_setup_configuration(struct dvb_frontend *fe,
1202                                         struct tda18271_config *cfg)
1203 {
1204         struct tda18271_priv *priv = fe->tuner_priv;
1205
1206         priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO;
1207         priv->role = (cfg) ? cfg->role : TDA18271_MASTER;
1208         priv->config = (cfg) ? cfg->config : 0;
1209         priv->small_i2c = (cfg) ?
1210                 cfg->small_i2c : TDA18271_39_BYTE_CHUNK_INIT;
1211         priv->output_opt = (cfg) ?
1212                 cfg->output_opt : TDA18271_OUTPUT_LT_XT_ON;
1213
1214         return 0;
1215 }
1216
1217 static inline int tda18271_need_cal_on_startup(struct tda18271_config *cfg)
1218 {
1219         /* tda18271_cal_on_startup == -1 when cal module option is unset */
1220         return ((tda18271_cal_on_startup == -1) ?
1221                 /* honor configuration setting */
1222                 ((cfg) && (cfg->rf_cal_on_startup)) :
1223                 /* module option overrides configuration setting */
1224                 (tda18271_cal_on_startup)) ? 1 : 0;
1225 }
1226
1227 static int tda18271_set_config(struct dvb_frontend *fe, void *priv_cfg)
1228 {
1229         struct tda18271_config *cfg = (struct tda18271_config *) priv_cfg;
1230
1231         tda18271_setup_configuration(fe, cfg);
1232
1233         if (tda18271_need_cal_on_startup(cfg))
1234                 tda18271_init(fe);
1235
1236         /* override default std map with values in config struct */
1237         if ((cfg) && (cfg->std_map))
1238                 tda18271_update_std_map(fe, cfg->std_map);
1239
1240         return 0;
1241 }
1242
1243 static const struct dvb_tuner_ops tda18271_tuner_ops = {
1244         .info = {
1245                 .name = "NXP TDA18271HD",
1246                 .frequency_min  =  45000000,
1247                 .frequency_max  = 864000000,
1248                 .frequency_step =     62500
1249         },
1250         .init              = tda18271_init,
1251         .sleep             = tda18271_sleep,
1252         .set_params        = tda18271_set_params,
1253         .set_analog_params = tda18271_set_analog_params,
1254         .release           = tda18271_release,
1255         .set_config        = tda18271_set_config,
1256         .get_frequency     = tda18271_get_frequency,
1257         .get_bandwidth     = tda18271_get_bandwidth,
1258         .get_if_frequency  = tda18271_get_if_frequency,
1259 };
1260
1261 struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
1262                                      struct i2c_adapter *i2c,
1263                                      struct tda18271_config *cfg)
1264 {
1265         struct tda18271_priv *priv = NULL;
1266         int instance, ret;
1267
1268         mutex_lock(&tda18271_list_mutex);
1269
1270         instance = hybrid_tuner_request_state(struct tda18271_priv, priv,
1271                                               hybrid_tuner_instance_list,
1272                                               i2c, addr, "tda18271");
1273         switch (instance) {
1274         case 0:
1275                 goto fail;
1276         case 1:
1277                 /* new tuner instance */
1278                 fe->tuner_priv = priv;
1279
1280                 tda18271_setup_configuration(fe, cfg);
1281
1282                 priv->cal_initialized = false;
1283                 mutex_init(&priv->lock);
1284
1285                 ret = tda18271_get_id(fe);
1286                 if (tda_fail(ret))
1287                         goto fail;
1288
1289                 ret = tda18271_assign_map_layout(fe);
1290                 if (tda_fail(ret))
1291                         goto fail;
1292
1293                 /* if delay_cal is set, delay IR & RF calibration until init()
1294                  * module option 'cal' overrides this delay */
1295                 if ((cfg->delay_cal) && (!tda18271_need_cal_on_startup(cfg)))
1296                         break;
1297
1298                 mutex_lock(&priv->lock);
1299                 tda18271_init_regs(fe);
1300
1301                 if ((tda18271_need_cal_on_startup(cfg)) &&
1302                     (priv->id == TDA18271HDC2))
1303                         tda18271c2_rf_cal_init(fe);
1304
1305                 /* enter standby mode, with required output features enabled */
1306                 ret = tda18271_toggle_output(fe, 1);
1307                 tda_fail(ret);
1308
1309                 mutex_unlock(&priv->lock);
1310                 break;
1311         default:
1312                 /* existing tuner instance */
1313                 fe->tuner_priv = priv;
1314
1315                 /* allow dvb driver to override configuration settings */
1316                 if (cfg) {
1317                         if (cfg->gate != TDA18271_GATE_ANALOG)
1318                                 priv->gate = cfg->gate;
1319                         if (cfg->role)
1320                                 priv->role = cfg->role;
1321                         if (cfg->config)
1322                                 priv->config = cfg->config;
1323                         if (cfg->small_i2c)
1324                                 priv->small_i2c = cfg->small_i2c;
1325                         if (cfg->output_opt)
1326                                 priv->output_opt = cfg->output_opt;
1327                         if (cfg->std_map)
1328                                 tda18271_update_std_map(fe, cfg->std_map);
1329                 }
1330                 if (tda18271_need_cal_on_startup(cfg))
1331                         tda18271_init(fe);
1332                 break;
1333         }
1334
1335         /* override default std map with values in config struct */
1336         if ((cfg) && (cfg->std_map))
1337                 tda18271_update_std_map(fe, cfg->std_map);
1338
1339         mutex_unlock(&tda18271_list_mutex);
1340
1341         memcpy(&fe->ops.tuner_ops, &tda18271_tuner_ops,
1342                sizeof(struct dvb_tuner_ops));
1343
1344         if (tda18271_debug & (DBG_MAP | DBG_ADV))
1345                 tda18271_dump_std_map(fe);
1346
1347         return fe;
1348 fail:
1349         mutex_unlock(&tda18271_list_mutex);
1350
1351         tda18271_release(fe);
1352         return NULL;
1353 }
1354 EXPORT_SYMBOL_GPL(tda18271_attach);
1355 MODULE_DESCRIPTION("NXP TDA18271HD analog / digital tuner driver");
1356 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1357 MODULE_LICENSE("GPL");
1358 MODULE_VERSION("0.4");