drivers/media/dvb-frontends/dib0090.c

   1 /*
   2  * Linux-DVB Driver for DiBcom's DiB0090 base-band RF Tuner.
   3  *
   4  * Copyright (C) 2005-9 DiBcom (http://www.dibcom.fr/)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  15  * GNU General Public License for more details.
  16  *
  17  *
  18  * This code is more or less generated from another driver, please
  19  * excuse some codingstyle oddities.
  20  *
  21  */
  22
  23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25 #include <linux/kernel.h>
  26 #include <linux/slab.h>
  27 #include <linux/i2c.h>
  28 #include <linux/mutex.h>
  29
  30 #include <media/dvb_frontend.h>
  31
  32 #include "dib0090.h"
  33 #include "dibx000_common.h"
  34
  35 static int debug;
  36 module_param(debug, int, 0644);
  37 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
  38
  39 #define dprintk(fmt, arg...) do {                                       \
  40         if (debug)                                                      \
  41                 printk(KERN_DEBUG pr_fmt("%s: " fmt),                   \
  42                        __func__, ##arg);                                \
  43 } while (0)
  44
  45 #define CONFIG_SYS_DVBT
  46 #define CONFIG_SYS_ISDBT
  47 #define CONFIG_BAND_CBAND
  48 #define CONFIG_BAND_VHF
  49 #define CONFIG_BAND_UHF
  50 #define CONFIG_DIB0090_USE_PWM_AGC
  51
  52 #define EN_LNA0      0x8000
  53 #define EN_LNA1      0x4000
  54 #define EN_LNA2      0x2000
  55 #define EN_LNA3      0x1000
  56 #define EN_MIX0      0x0800
  57 #define EN_MIX1      0x0400
  58 #define EN_MIX2      0x0200
  59 #define EN_MIX3      0x0100
  60 #define EN_IQADC     0x0040
  61 #define EN_PLL       0x0020
  62 #define EN_TX        0x0010
  63 #define EN_BB        0x0008
  64 #define EN_LO        0x0004
  65 #define EN_BIAS      0x0001
  66
  67 #define EN_IQANA     0x0002
  68 #define EN_DIGCLK    0x0080     /* not in the 0x24 reg, only in 0x1b */
  69 #define EN_CRYSTAL   0x0002
  70
  71 #define EN_UHF           0x22E9
  72 #define EN_VHF           0x44E9
  73 #define EN_LBD           0x11E9
  74 #define EN_SBD           0x44E9
  75 #define EN_CAB           0x88E9
  76
  77 /* Calibration defines */
  78 #define      DC_CAL 0x1
  79 #define     WBD_CAL 0x2
  80 #define    TEMP_CAL 0x4
  81 #define CAPTRIM_CAL 0x8
  82
  83 #define KROSUS_PLL_LOCKED   0x800
  84 #define KROSUS              0x2
  85
  86 /* Use those defines to identify SOC version */
  87 #define SOC               0x02
  88 #define SOC_7090_P1G_11R1 0x82
  89 #define SOC_7090_P1G_21R1 0x8a
  90 #define SOC_8090_P1G_11R1 0x86
  91 #define SOC_8090_P1G_21R1 0x8e
  92
  93 /* else use thos ones to check */
  94 #define P1A_B      0x0
  95 #define P1C        0x1
  96 #define P1D_E_F    0x3
  97 #define P1G        0x7
  98 #define P1G_21R2   0xf
  99
 100 #define MP001 0x1               /* Single 9090/8096 */
 101 #define MP005 0x4               /* Single Sband */
 102 #define MP008 0x6               /* Dual diversity VHF-UHF-LBAND */
 103 #define MP009 0x7               /* Dual diversity 29098 CBAND-UHF-LBAND-SBAND */
 104
 105 #define pgm_read_word(w) (*w)
 106
 107 struct dc_calibration;
 108
 109 struct dib0090_tuning {
 110         u32 max_freq;           /* for every frequency less than or equal to that field: this information is correct */
 111         u8 switch_trim;
 112         u8 lna_tune;
 113         u16 lna_bias;
 114         u16 v2i;
 115         u16 mix;
 116         u16 load;
 117         u16 tuner_enable;
 118 };
 119
 120 struct dib0090_pll {
 121         u32 max_freq;           /* for every frequency less than or equal to that field: this information is correct */
 122         u8 vco_band;
 123         u8 hfdiv_code;
 124         u8 hfdiv;
 125         u8 topresc;
 126 };
 127
 128 struct dib0090_identity {
 129         u8 version;
 130         u8 product;
 131         u8 p1g;
 132         u8 in_soc;
 133 };
 134
 135 struct dib0090_state {
 136         struct i2c_adapter *i2c;
 137         struct dvb_frontend *fe;
 138         const struct dib0090_config *config;
 139
 140         u8 current_band;
 141         enum frontend_tune_state tune_state;
 142         u32 current_rf;
 143
 144         u16 wbd_offset;
 145         s16 wbd_target;         /* in dB */
 146
 147         s16 rf_gain_limit;      /* take-over-point: where to split between bb and rf gain */
 148         s16 current_gain;       /* keeps the currently programmed gain */
 149         u8 agc_step;            /* new binary search */
 150
 151         u16 gain[2];            /* for channel monitoring */
 152
 153         const u16 *rf_ramp;
 154         const u16 *bb_ramp;
 155
 156         /* for the software AGC ramps */
 157         u16 bb_1_def;
 158         u16 rf_lt_def;
 159         u16 gain_reg[4];
 160
 161         /* for the captrim/dc-offset search */
 162         s8 step;
 163         s16 adc_diff;
 164         s16 min_adc_diff;
 165
 166         s8 captrim;
 167         s8 fcaptrim;
 168
 169         const struct dc_calibration *dc;
 170         u16 bb6, bb7;
 171
 172         const struct dib0090_tuning *current_tune_table_index;
 173         const struct dib0090_pll *current_pll_table_index;
 174
 175         u8 tuner_is_tuned;
 176         u8 agc_freeze;
 177
 178         struct dib0090_identity identity;
 179
 180         u32 rf_request;
 181         u8 current_standard;
 182
 183         u8 calibrate;
 184         u32 rest;
 185         u16 bias;
 186         s16 temperature;
 187
 188         u8 wbd_calibration_gain;
 189         const struct dib0090_wbd_slope *current_wbd_table;
 190         u16 wbdmux;
 191
 192         /* for the I2C transfer */
 193         struct i2c_msg msg[2];
 194         u8 i2c_write_buffer[3];
 195         u8 i2c_read_buffer[2];
 196         struct mutex i2c_buffer_lock;
 197 };
 198
 199 struct dib0090_fw_state {
 200         struct i2c_adapter *i2c;
 201         struct dvb_frontend *fe;
 202         struct dib0090_identity identity;
 203         const struct dib0090_config *config;
 204
 205         /* for the I2C transfer */
 206         struct i2c_msg msg;
 207         u8 i2c_write_buffer[2];
 208         u8 i2c_read_buffer[2];
 209         struct mutex i2c_buffer_lock;
 210 };
 211
 212 static u16 dib0090_read_reg(struct dib0090_state *state, u8 reg)
 213 {
 214         u16 ret;
 215
 216         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 217                 dprintk("could not acquire lock\n");
 218                 return 0;
 219         }
 220
 221         state->i2c_write_buffer[0] = reg;
 222
 223         memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
 224         state->msg[0].addr = state->config->i2c_address;
 225         state->msg[0].flags = 0;
 226         state->msg[0].buf = state->i2c_write_buffer;
 227         state->msg[0].len = 1;
 228         state->msg[1].addr = state->config->i2c_address;
 229         state->msg[1].flags = I2C_M_RD;
 230         state->msg[1].buf = state->i2c_read_buffer;
 231         state->msg[1].len = 2;
 232
 233         if (i2c_transfer(state->i2c, state->msg, 2) != 2) {
 234                 pr_warn("DiB0090 I2C read failed\n");
 235                 ret = 0;
 236         } else
 237                 ret = (state->i2c_read_buffer[0] << 8)
 238                         | state->i2c_read_buffer[1];
 239
 240         mutex_unlock(&state->i2c_buffer_lock);
 241         return ret;
 242 }
 243
 244 static int dib0090_write_reg(struct dib0090_state *state, u32 reg, u16 val)
 245 {
 246         int ret;
 247
 248         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 249                 dprintk("could not acquire lock\n");
 250                 return -EINVAL;
 251         }
 252
 253         state->i2c_write_buffer[0] = reg & 0xff;
 254         state->i2c_write_buffer[1] = val >> 8;
 255         state->i2c_write_buffer[2] = val & 0xff;
 256
 257         memset(state->msg, 0, sizeof(struct i2c_msg));
 258         state->msg[0].addr = state->config->i2c_address;
 259         state->msg[0].flags = 0;
 260         state->msg[0].buf = state->i2c_write_buffer;
 261         state->msg[0].len = 3;
 262
 263         if (i2c_transfer(state->i2c, state->msg, 1) != 1) {
 264                 pr_warn("DiB0090 I2C write failed\n");
 265                 ret = -EREMOTEIO;
 266         } else
 267                 ret = 0;
 268
 269         mutex_unlock(&state->i2c_buffer_lock);
 270         return ret;
 271 }
 272
 273 static u16 dib0090_fw_read_reg(struct dib0090_fw_state *state, u8 reg)
 274 {
 275         u16 ret;
 276
 277         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 278                 dprintk("could not acquire lock\n");
 279                 return 0;
 280         }
 281
 282         state->i2c_write_buffer[0] = reg;
 283
 284         memset(&state->msg, 0, sizeof(struct i2c_msg));
 285         state->msg.addr = reg;
 286         state->msg.flags = I2C_M_RD;
 287         state->msg.buf = state->i2c_read_buffer;
 288         state->msg.len = 2;
 289         if (i2c_transfer(state->i2c, &state->msg, 1) != 1) {
 290                 pr_warn("DiB0090 I2C read failed\n");
 291                 ret = 0;
 292         } else
 293                 ret = (state->i2c_read_buffer[0] << 8)
 294                         | state->i2c_read_buffer[1];
 295
 296         mutex_unlock(&state->i2c_buffer_lock);
 297         return ret;
 298 }
 299
 300 static int dib0090_fw_write_reg(struct dib0090_fw_state *state, u8 reg, u16 val)
 301 {
 302         int ret;
 303
 304         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 305                 dprintk("could not acquire lock\n");
 306                 return -EINVAL;
 307         }
 308
 309         state->i2c_write_buffer[0] = val >> 8;
 310         state->i2c_write_buffer[1] = val & 0xff;
 311
 312         memset(&state->msg, 0, sizeof(struct i2c_msg));
 313         state->msg.addr = reg;
 314         state->msg.flags = 0;
 315         state->msg.buf = state->i2c_write_buffer;
 316         state->msg.len = 2;
 317         if (i2c_transfer(state->i2c, &state->msg, 1) != 1) {
 318                 pr_warn("DiB0090 I2C write failed\n");
 319                 ret = -EREMOTEIO;
 320         } else
 321                 ret = 0;
 322
 323         mutex_unlock(&state->i2c_buffer_lock);
 324         return ret;
 325 }
 326
 327 #define HARD_RESET(state) do {  if (cfg->reset) {  if (cfg->sleep) cfg->sleep(fe, 0); msleep(10);  cfg->reset(fe, 1); msleep(10);  cfg->reset(fe, 0); msleep(10);  }  } while (0)
 328 #define ADC_TARGET -220
 329 #define GAIN_ALPHA 5
 330 #define WBD_ALPHA 6
 331 #define LPF     100
 332 static void dib0090_write_regs(struct dib0090_state *state, u8 r, const u16 * b, u8 c)
 333 {
 334         do {
 335                 dib0090_write_reg(state, r++, *b++);
 336         } while (--c);
 337 }
 338
 339 static int dib0090_identify(struct dvb_frontend *fe)
 340 {
 341         struct dib0090_state *state = fe->tuner_priv;
 342         u16 v;
 343         struct dib0090_identity *identity = &state->identity;
 344
 345         v = dib0090_read_reg(state, 0x1a);
 346
 347         identity->p1g = 0;
 348         identity->in_soc = 0;
 349
 350         dprintk("Tuner identification (Version = 0x%04x)\n", v);
 351
 352         /* without PLL lock info */
 353         v &= ~KROSUS_PLL_LOCKED;
 354
 355         identity->version = v & 0xff;
 356         identity->product = (v >> 8) & 0xf;
 357
 358         if (identity->product != KROSUS)
 359                 goto identification_error;
 360
 361         if ((identity->version & 0x3) == SOC) {
 362                 identity->in_soc = 1;
 363                 switch (identity->version) {
 364                 case SOC_8090_P1G_11R1:
 365                         dprintk("SOC 8090 P1-G11R1 Has been detected\n");
 366                         identity->p1g = 1;
 367                         break;
 368                 case SOC_8090_P1G_21R1:
 369                         dprintk("SOC 8090 P1-G21R1 Has been detected\n");
 370                         identity->p1g = 1;
 371                         break;
 372                 case SOC_7090_P1G_11R1:
 373                         dprintk("SOC 7090 P1-G11R1 Has been detected\n");
 374                         identity->p1g = 1;
 375                         break;
 376                 case SOC_7090_P1G_21R1:
 377                         dprintk("SOC 7090 P1-G21R1 Has been detected\n");
 378                         identity->p1g = 1;
 379                         break;
 380                 default:
 381                         goto identification_error;
 382                 }
 383         } else {
 384                 switch ((identity->version >> 5) & 0x7) {
 385                 case MP001:
 386                         dprintk("MP001 : 9090/8096\n");
 387                         break;
 388                 case MP005:
 389                         dprintk("MP005 : Single Sband\n");
 390                         break;
 391                 case MP008:
 392                         dprintk("MP008 : diversity VHF-UHF-LBAND\n");
 393                         break;
 394                 case MP009:
 395                         dprintk("MP009 : diversity 29098 CBAND-UHF-LBAND-SBAND\n");
 396                         break;
 397                 default:
 398                         goto identification_error;
 399                 }
 400
 401                 switch (identity->version & 0x1f) {
 402                 case P1G_21R2:
 403                         dprintk("P1G_21R2 detected\n");
 404                         identity->p1g = 1;
 405                         break;
 406                 case P1G:
 407                         dprintk("P1G detected\n");
 408                         identity->p1g = 1;
 409                         break;
 410                 case P1D_E_F:
 411                         dprintk("P1D/E/F detected\n");
 412                         break;
 413                 case P1C:
 414                         dprintk("P1C detected\n");
 415                         break;
 416                 case P1A_B:
 417                         dprintk("P1-A/B detected: driver is deactivated - not available\n");
 418                         goto identification_error;
 419                         break;
 420                 default:
 421                         goto identification_error;
 422                 }
 423         }
 424
 425         return 0;
 426
 427 identification_error:
 428         return -EIO;
 429 }
 430
 431 static int dib0090_fw_identify(struct dvb_frontend *fe)
 432 {
 433         struct dib0090_fw_state *state = fe->tuner_priv;
 434         struct dib0090_identity *identity = &state->identity;
 435
 436         u16 v = dib0090_fw_read_reg(state, 0x1a);
 437         identity->p1g = 0;
 438         identity->in_soc = 0;
 439
 440         dprintk("FE: Tuner identification (Version = 0x%04x)\n", v);
 441
 442         /* without PLL lock info */
 443         v &= ~KROSUS_PLL_LOCKED;
 444
 445         identity->version = v & 0xff;
 446         identity->product = (v >> 8) & 0xf;
 447
 448         if (identity->product != KROSUS)
 449                 goto identification_error;
 450
 451         if ((identity->version & 0x3) == SOC) {
 452                 identity->in_soc = 1;
 453                 switch (identity->version) {
 454                 case SOC_8090_P1G_11R1:
 455                         dprintk("SOC 8090 P1-G11R1 Has been detected\n");
 456                         identity->p1g = 1;
 457                         break;
 458                 case SOC_8090_P1G_21R1:
 459                         dprintk("SOC 8090 P1-G21R1 Has been detected\n");
 460                         identity->p1g = 1;
 461                         break;
 462                 case SOC_7090_P1G_11R1:
 463                         dprintk("SOC 7090 P1-G11R1 Has been detected\n");
 464                         identity->p1g = 1;
 465                         break;
 466                 case SOC_7090_P1G_21R1:
 467                         dprintk("SOC 7090 P1-G21R1 Has been detected\n");
 468                         identity->p1g = 1;
 469                         break;
 470                 default:
 471                         goto identification_error;
 472                 }
 473         } else {
 474                 switch ((identity->version >> 5) & 0x7) {
 475                 case MP001:
 476                         dprintk("MP001 : 9090/8096\n");
 477                         break;
 478                 case MP005:
 479                         dprintk("MP005 : Single Sband\n");
 480                         break;
 481                 case MP008:
 482                         dprintk("MP008 : diversity VHF-UHF-LBAND\n");
 483                         break;
 484                 case MP009:
 485                         dprintk("MP009 : diversity 29098 CBAND-UHF-LBAND-SBAND\n");
 486                         break;
 487                 default:
 488                         goto identification_error;
 489                 }
 490
 491                 switch (identity->version & 0x1f) {
 492                 case P1G_21R2:
 493                         dprintk("P1G_21R2 detected\n");
 494                         identity->p1g = 1;
 495                         break;
 496                 case P1G:
 497                         dprintk("P1G detected\n");
 498                         identity->p1g = 1;
 499                         break;
 500                 case P1D_E_F:
 501                         dprintk("P1D/E/F detected\n");
 502                         break;
 503                 case P1C:
 504                         dprintk("P1C detected\n");
 505                         break;
 506                 case P1A_B:
 507                         dprintk("P1-A/B detected: driver is deactivated - not available\n");
 508                         goto identification_error;
 509                         break;
 510                 default:
 511                         goto identification_error;
 512                 }
 513         }
 514
 515         return 0;
 516
 517 identification_error:
 518         return -EIO;
 519 }
 520
 521 static void dib0090_reset_digital(struct dvb_frontend *fe, const struct dib0090_config *cfg)
 522 {
 523         struct dib0090_state *state = fe->tuner_priv;
 524         u16 PllCfg, i, v;
 525
 526         HARD_RESET(state);
 527         dib0090_write_reg(state, 0x24, EN_PLL | EN_CRYSTAL);
 528         if (cfg->in_soc)
 529                 return;
 530
 531         dib0090_write_reg(state, 0x1b, EN_DIGCLK | EN_PLL | EN_CRYSTAL);        /* PLL, DIG_CLK and CRYSTAL remain */
 532         /* adcClkOutRatio=8->7, release reset */
 533         dib0090_write_reg(state, 0x20, ((cfg->io.adc_clock_ratio - 1) << 11) | (0 << 10) | (1 << 9) | (1 << 8) | (0 << 4) | 0);
 534         if (cfg->clkoutdrive != 0)
 535                 dib0090_write_reg(state, 0x23, (0 << 15) | ((!cfg->analog_output) << 14) | (2 << 10) | (1 << 9) | (0 << 8)
 536                                 | (cfg->clkoutdrive << 5) | (cfg->clkouttobamse << 4) | (0 << 2) | (0));
 537         else
 538                 dib0090_write_reg(state, 0x23, (0 << 15) | ((!cfg->analog_output) << 14) | (2 << 10) | (1 << 9) | (0 << 8)
 539                                 | (7 << 5) | (cfg->clkouttobamse << 4) | (0 << 2) | (0));
 540
 541         /* Read Pll current config * */
 542         PllCfg = dib0090_read_reg(state, 0x21);
 543
 544         /** Reconfigure PLL if current setting is different from default setting **/
 545         if ((PllCfg & 0x1FFF) != ((cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv)) && (!cfg->in_soc)
 546                         && !cfg->io.pll_bypass) {
 547
 548                 /* Set Bypass mode */
 549                 PllCfg |= (1 << 15);
 550                 dib0090_write_reg(state, 0x21, PllCfg);
 551
 552                 /* Set Reset Pll */
 553                 PllCfg &= ~(1 << 13);
 554                 dib0090_write_reg(state, 0x21, PllCfg);
 555
 556         /*** Set new Pll configuration in bypass and reset state ***/
 557                 PllCfg = (1 << 15) | (0 << 13) | (cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv);
 558                 dib0090_write_reg(state, 0x21, PllCfg);
 559
 560                 /* Remove Reset Pll */
 561                 PllCfg |= (1 << 13);
 562                 dib0090_write_reg(state, 0x21, PllCfg);
 563
 564         /*** Wait for PLL lock ***/
 565                 i = 100;
 566                 do {
 567                         v = !!(dib0090_read_reg(state, 0x1a) & 0x800);
 568                         if (v)
 569                                 break;
 570                 } while (--i);
 571
 572                 if (i == 0) {
 573                         dprintk("Pll: Unable to lock Pll\n");
 574                         return;
 575                 }
 576
 577                 /* Finally Remove Bypass mode */
 578                 PllCfg &= ~(1 << 15);
 579                 dib0090_write_reg(state, 0x21, PllCfg);
 580         }
 581
 582         if (cfg->io.pll_bypass) {
 583                 PllCfg |= (cfg->io.pll_bypass << 15);
 584                 dib0090_write_reg(state, 0x21, PllCfg);
 585         }
 586 }
 587
 588 static int dib0090_fw_reset_digital(struct dvb_frontend *fe, const struct dib0090_config *cfg)
 589 {
 590         struct dib0090_fw_state *state = fe->tuner_priv;
 591         u16 PllCfg;
 592         u16 v;
 593         int i;
 594
 595         dprintk("fw reset digital\n");
 596         HARD_RESET(state);
 597
 598         dib0090_fw_write_reg(state, 0x24, EN_PLL | EN_CRYSTAL);
 599         dib0090_fw_write_reg(state, 0x1b, EN_DIGCLK | EN_PLL | EN_CRYSTAL);     /* PLL, DIG_CLK and CRYSTAL remain */
 600
 601         dib0090_fw_write_reg(state, 0x20,
 602                         ((cfg->io.adc_clock_ratio - 1) << 11) | (0 << 10) | (1 << 9) | (1 << 8) | (cfg->data_tx_drv << 4) | cfg->ls_cfg_pad_drv);
 603
 604         v = (0 << 15) | ((!cfg->analog_output) << 14) | (1 << 9) | (0 << 8) | (cfg->clkouttobamse << 4) | (0 << 2) | (0);
 605         if (cfg->clkoutdrive != 0)
 606                 v |= cfg->clkoutdrive << 5;
 607         else
 608                 v |= 7 << 5;
 609
 610         v |= 2 << 10;
 611         dib0090_fw_write_reg(state, 0x23, v);
 612
 613         /* Read Pll current config * */
 614         PllCfg = dib0090_fw_read_reg(state, 0x21);
 615
 616         /** Reconfigure PLL if current setting is different from default setting **/
 617         if ((PllCfg & 0x1FFF) != ((cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv)) && !cfg->io.pll_bypass) {
 618
 619                 /* Set Bypass mode */
 620                 PllCfg |= (1 << 15);
 621                 dib0090_fw_write_reg(state, 0x21, PllCfg);
 622
 623                 /* Set Reset Pll */
 624                 PllCfg &= ~(1 << 13);
 625                 dib0090_fw_write_reg(state, 0x21, PllCfg);
 626
 627         /*** Set new Pll configuration in bypass and reset state ***/
 628                 PllCfg = (1 << 15) | (0 << 13) | (cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv);
 629                 dib0090_fw_write_reg(state, 0x21, PllCfg);
 630
 631                 /* Remove Reset Pll */
 632                 PllCfg |= (1 << 13);
 633                 dib0090_fw_write_reg(state, 0x21, PllCfg);
 634
 635         /*** Wait for PLL lock ***/
 636                 i = 100;
 637                 do {
 638                         v = !!(dib0090_fw_read_reg(state, 0x1a) & 0x800);
 639                         if (v)
 640                                 break;
 641                 } while (--i);
 642
 643                 if (i == 0) {
 644                         dprintk("Pll: Unable to lock Pll\n");
 645                         return -EIO;
 646                 }
 647
 648                 /* Finally Remove Bypass mode */
 649                 PllCfg &= ~(1 << 15);
 650                 dib0090_fw_write_reg(state, 0x21, PllCfg);
 651         }
 652
 653         if (cfg->io.pll_bypass) {
 654                 PllCfg |= (cfg->io.pll_bypass << 15);
 655                 dib0090_fw_write_reg(state, 0x21, PllCfg);
 656         }
 657
 658         return dib0090_fw_identify(fe);
 659 }
 660
 661 static int dib0090_wakeup(struct dvb_frontend *fe)
 662 {
 663         struct dib0090_state *state = fe->tuner_priv;
 664         if (state->config->sleep)
 665                 state->config->sleep(fe, 0);
 666
 667         /* enable dataTX in case we have been restarted in the wrong moment */
 668         dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14));
 669         return 0;
 670 }
 671
 672 static int dib0090_sleep(struct dvb_frontend *fe)
 673 {
 674         struct dib0090_state *state = fe->tuner_priv;
 675         if (state->config->sleep)
 676                 state->config->sleep(fe, 1);
 677         return 0;
 678 }
 679
 680 void dib0090_dcc_freq(struct dvb_frontend *fe, u8 fast)
 681 {
 682         struct dib0090_state *state = fe->tuner_priv;
 683         if (fast)
 684                 dib0090_write_reg(state, 0x04, 0);
 685         else
 686                 dib0090_write_reg(state, 0x04, 1);
 687 }
 688
 689 EXPORT_SYMBOL(dib0090_dcc_freq);
 690
 691 static const u16 bb_ramp_pwm_normal_socs[] = {
 692         550, /* max BB gain in 10th of dB */
 693         (1<<9) | 8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */
 694         440,
 695         (4  << 9) | 0, /* BB_RAMP3 = 26dB */
 696         (0  << 9) | 208, /* BB_RAMP4 */
 697         (4  << 9) | 208, /* BB_RAMP5 = 29dB */
 698         (0  << 9) | 440, /* BB_RAMP6 */
 699 };
 700
 701 static const u16 rf_ramp_pwm_cband_7090p[] = {
 702         280, /* max RF gain in 10th of dB */
 703         18, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 704         504, /* ramp_max = maximum X used on the ramp */
 705         (29 << 10) | 364, /* RF_RAMP5, LNA 1 = 8dB */
 706         (0  << 10) | 504, /* RF_RAMP6, LNA 1 */
 707         (60 << 10) | 228, /* RF_RAMP7, LNA 2 = 7.7dB */
 708         (0  << 10) | 364, /* RF_RAMP8, LNA 2 */
 709         (34 << 10) | 109, /* GAIN_4_1, LNA 3 = 6.8dB */
 710         (0  << 10) | 228, /* GAIN_4_2, LNA 3 */
 711         (37 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */
 712         (0  << 10) | 109, /* RF_RAMP4, LNA 4 */
 713 };
 714
 715 static const u16 rf_ramp_pwm_cband_7090e_sensitivity[] = {
 716         186, /* max RF gain in 10th of dB */
 717         40, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 718         746, /* ramp_max = maximum X used on the ramp */
 719         (10 << 10) | 345, /* RF_RAMP5, LNA 1 = 10dB */
 720         (0  << 10) | 746, /* RF_RAMP6, LNA 1 */
 721         (0 << 10) | 0, /* RF_RAMP7, LNA 2 = 0 dB */
 722         (0  << 10) | 0, /* RF_RAMP8, LNA 2 */
 723         (28 << 10) | 200, /* GAIN_4_1, LNA 3 = 6.8dB */ /* 3.61 dB */
 724         (0  << 10) | 345, /* GAIN_4_2, LNA 3 */
 725         (20 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ /* 4.96 dB */
 726         (0  << 10) | 200, /* RF_RAMP4, LNA 4 */
 727 };
 728
 729 static const u16 rf_ramp_pwm_cband_7090e_aci[] = {
 730         86, /* max RF gain in 10th of dB */
 731         40, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 732         345, /* ramp_max = maximum X used on the ramp */
 733         (0 << 10) | 0, /* RF_RAMP5, LNA 1 = 8dB */ /* 7.47 dB */
 734         (0 << 10) | 0, /* RF_RAMP6, LNA 1 */
 735         (0 << 10) | 0, /* RF_RAMP7, LNA 2 = 0 dB */
 736         (0 << 10) | 0, /* RF_RAMP8, LNA 2 */
 737         (28 << 10) | 200, /* GAIN_4_1, LNA 3 = 6.8dB */ /* 3.61 dB */
 738         (0  << 10) | 345, /* GAIN_4_2, LNA 3 */
 739         (20 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ /* 4.96 dB */
 740         (0  << 10) | 200, /* RF_RAMP4, LNA 4 */
 741 };
 742
 743 static const u16 rf_ramp_pwm_cband_8090[] = {
 744         345, /* max RF gain in 10th of dB */
 745         29, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 746         1000, /* ramp_max = maximum X used on the ramp */
 747         (35 << 10) | 772, /* RF_RAMP3, LNA 1 = 8dB */
 748         (0  << 10) | 1000, /* RF_RAMP4, LNA 1 */
 749         (58 << 10) | 496, /* RF_RAMP5, LNA 2 = 9.5dB */
 750         (0  << 10) | 772, /* RF_RAMP6, LNA 2 */
 751         (27 << 10) | 200, /* RF_RAMP7, LNA 3 = 10.5dB */
 752         (0  << 10) | 496, /* RF_RAMP8, LNA 3 */
 753         (40 << 10) | 0, /* GAIN_4_1, LNA 4 = 7dB */
 754         (0  << 10) | 200, /* GAIN_4_2, LNA 4 */
 755 };
 756
 757 static const u16 rf_ramp_pwm_uhf_7090[] = {
 758         407, /* max RF gain in 10th of dB */
 759         13, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 760         529, /* ramp_max = maximum X used on the ramp */
 761         (23 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.7dB */
 762         (0  << 10) | 176, /* RF_RAMP4, LNA 1 */
 763         (63 << 10) | 400, /* RF_RAMP5, LNA 2 = 8dB */
 764         (0  << 10) | 529, /* RF_RAMP6, LNA 2 */
 765         (48 << 10) | 316, /* RF_RAMP7, LNA 3 = 6.8dB */
 766         (0  << 10) | 400, /* RF_RAMP8, LNA 3 */
 767         (29 << 10) | 176, /* GAIN_4_1, LNA 4 = 11.5dB */
 768         (0  << 10) | 316, /* GAIN_4_2, LNA 4 */
 769 };
 770
 771 static const u16 rf_ramp_pwm_uhf_8090[] = {
 772         388, /* max RF gain in 10th of dB */
 773         26, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 774         1008, /* ramp_max = maximum X used on the ramp */
 775         (11 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.7dB */
 776         (0  << 10) | 369, /* RF_RAMP4, LNA 1 */
 777         (41 << 10) | 809, /* RF_RAMP5, LNA 2 = 8dB */
 778         (0  << 10) | 1008, /* RF_RAMP6, LNA 2 */
 779         (27 << 10) | 659, /* RF_RAMP7, LNA 3 = 6dB */
 780         (0  << 10) | 809, /* RF_RAMP8, LNA 3 */
 781         (14 << 10) | 369, /* GAIN_4_1, LNA 4 = 11.5dB */
 782         (0  << 10) | 659, /* GAIN_4_2, LNA 4 */
 783 };
 784
 785 /* GENERAL PWM ramp definition for all other Krosus */
 786 static const u16 bb_ramp_pwm_normal[] = {
 787         500, /* max BB gain in 10th of dB */
 788         8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */
 789         400,
 790         (2  << 9) | 0, /* BB_RAMP3 = 21dB */
 791         (0  << 9) | 168, /* BB_RAMP4 */
 792         (2  << 9) | 168, /* BB_RAMP5 = 29dB */
 793         (0  << 9) | 400, /* BB_RAMP6 */
 794 };
 795
 796 #if 0
 797 /* Currently unused */
 798 static const u16 bb_ramp_pwm_boost[] = {
 799         550, /* max BB gain in 10th of dB */
 800         8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */
 801         440,
 802         (2  << 9) | 0, /* BB_RAMP3 = 26dB */
 803         (0  << 9) | 208, /* BB_RAMP4 */
 804         (2  << 9) | 208, /* BB_RAMP5 = 29dB */
 805         (0  << 9) | 440, /* BB_RAMP6 */
 806 };
 807 #endif
 808
 809 static const u16 rf_ramp_pwm_cband[] = {
 810         314, /* max RF gain in 10th of dB */
 811         33, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 812         1023, /* ramp_max = maximum X used on the ramp */
 813         (8  << 10) | 743, /* RF_RAMP3, LNA 1 = 0dB */
 814         (0  << 10) | 1023, /* RF_RAMP4, LNA 1 */
 815         (15 << 10) | 469, /* RF_RAMP5, LNA 2 = 0dB */
 816         (0  << 10) | 742, /* RF_RAMP6, LNA 2 */
 817         (9  << 10) | 234, /* RF_RAMP7, LNA 3 = 0dB */
 818         (0  << 10) | 468, /* RF_RAMP8, LNA 3 */
 819         (9  << 10) | 0, /* GAIN_4_1, LNA 4 = 0dB */
 820         (0  << 10) | 233, /* GAIN_4_2, LNA 4 */
 821 };
 822
 823 static const u16 rf_ramp_pwm_vhf[] = {
 824         398, /* max RF gain in 10th of dB */
 825         24, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 826         954, /* ramp_max = maximum X used on the ramp */
 827         (7  << 10) | 0, /* RF_RAMP3, LNA 1 = 13.2dB */
 828         (0  << 10) | 290, /* RF_RAMP4, LNA 1 */
 829         (16 << 10) | 699, /* RF_RAMP5, LNA 2 = 10.5dB */
 830         (0  << 10) | 954, /* RF_RAMP6, LNA 2 */
 831         (17 << 10) | 580, /* RF_RAMP7, LNA 3 = 5dB */
 832         (0  << 10) | 699, /* RF_RAMP8, LNA 3 */
 833         (7  << 10) | 290, /* GAIN_4_1, LNA 4 = 12.5dB */
 834         (0  << 10) | 580, /* GAIN_4_2, LNA 4 */
 835 };
 836
 837 static const u16 rf_ramp_pwm_uhf[] = {
 838         398, /* max RF gain in 10th of dB */
 839         24, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 840         954, /* ramp_max = maximum X used on the ramp */
 841         (7  << 10) | 0, /* RF_RAMP3, LNA 1 = 13.2dB */
 842         (0  << 10) | 290, /* RF_RAMP4, LNA 1 */
 843         (16 << 10) | 699, /* RF_RAMP5, LNA 2 = 10.5dB */
 844         (0  << 10) | 954, /* RF_RAMP6, LNA 2 */
 845         (17 << 10) | 580, /* RF_RAMP7, LNA 3 = 5dB */
 846         (0  << 10) | 699, /* RF_RAMP8, LNA 3 */
 847         (7  << 10) | 290, /* GAIN_4_1, LNA 4 = 12.5dB */
 848         (0  << 10) | 580, /* GAIN_4_2, LNA 4 */
 849 };
 850
 851 #if 0
 852 /* Currently unused */
 853 static const u16 rf_ramp_pwm_sband[] = {
 854         253, /* max RF gain in 10th of dB */
 855         38, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
 856         961,
 857         (4  << 10) | 0, /* RF_RAMP3, LNA 1 = 14.1dB */
 858         (0  << 10) | 508, /* RF_RAMP4, LNA 1 */
 859         (9  << 10) | 508, /* RF_RAMP5, LNA 2 = 11.2dB */
 860         (0  << 10) | 961, /* RF_RAMP6, LNA 2 */
 861         (0  << 10) | 0, /* RF_RAMP7, LNA 3 = 0dB */
 862         (0  << 10) | 0, /* RF_RAMP8, LNA 3 */
 863         (0  << 10) | 0, /* GAIN_4_1, LNA 4 = 0dB */
 864         (0  << 10) | 0, /* GAIN_4_2, LNA 4 */
 865 };
 866 #endif
 867
 868 struct slope {
 869         s16 range;
 870         s16 slope;
 871 };
 872 static u16 slopes_to_scale(const struct slope *slopes, u8 num, s16 val)
 873 {
 874         u8 i;
 875         u16 rest;
 876         u16 ret = 0;
 877         for (i = 0; i < num; i++) {
 878                 if (val > slopes[i].range)
 879                         rest = slopes[i].range;
 880                 else
 881                         rest = val;
 882                 ret += (rest * slopes[i].slope) / slopes[i].range;
 883                 val -= rest;
 884         }
 885         return ret;
 886 }
 887
 888 static const struct slope dib0090_wbd_slopes[3] = {
 889         {66, 120},              /* -64,-52: offset -   65 */
 890         {600, 170},             /* -52,-35: 65     -  665 */
 891         {170, 250},             /* -45,-10: 665    - 835 */
 892 };
 893
 894 static s16 dib0090_wbd_to_db(struct dib0090_state *state, u16 wbd)
 895 {
 896         wbd &= 0x3ff;
 897         if (wbd < state->wbd_offset)
 898                 wbd = 0;
 899         else
 900                 wbd -= state->wbd_offset;
 901         /* -64dB is the floor */
 902         return -640 + (s16) slopes_to_scale(dib0090_wbd_slopes, ARRAY_SIZE(dib0090_wbd_slopes), wbd);
 903 }
 904
 905 static void dib0090_wbd_target(struct dib0090_state *state, u32 rf)
 906 {
 907         u16 offset = 250;
 908
 909         /* TODO : DAB digital N+/-1 interferer perfs : offset = 10 */
 910
 911         if (state->current_band == BAND_VHF)
 912                 offset = 650;
 913 #ifndef FIRMWARE_FIREFLY
 914         if (state->current_band == BAND_VHF)
 915                 offset = state->config->wbd_vhf_offset;
 916         if (state->current_band == BAND_CBAND)
 917                 offset = state->config->wbd_cband_offset;
 918 #endif
 919
 920         state->wbd_target = dib0090_wbd_to_db(state, state->wbd_offset + offset);
 921         dprintk("wbd-target: %d dB\n", (u32) state->wbd_target);
 922 }
 923
 924 static const int gain_reg_addr[4] = {
 925         0x08, 0x0a, 0x0f, 0x01
 926 };
 927
 928 static void dib0090_gain_apply(struct dib0090_state *state, s16 gain_delta, s16 top_delta, u8 force)
 929 {
 930         u16 rf, bb, ref;
 931         u16 i, v, gain_reg[4] = { 0 }, gain;
 932         const u16 *g;
 933
 934         if (top_delta < -511)
 935                 top_delta = -511;
 936         if (top_delta > 511)
 937                 top_delta = 511;
 938
 939         if (force) {
 940                 top_delta *= (1 << WBD_ALPHA);
 941                 gain_delta *= (1 << GAIN_ALPHA);
 942         }
 943
 944         if (top_delta >= ((s16) (state->rf_ramp[0] << WBD_ALPHA) - state->rf_gain_limit))       /* overflow */
 945                 state->rf_gain_limit = state->rf_ramp[0] << WBD_ALPHA;
 946         else
 947                 state->rf_gain_limit += top_delta;
 948
 949         if (state->rf_gain_limit < 0)   /*underflow */
 950                 state->rf_gain_limit = 0;
 951
 952         /* use gain as a temporary variable and correct current_gain */
 953         gain = ((state->rf_gain_limit >> WBD_ALPHA) + state->bb_ramp[0]) << GAIN_ALPHA;
 954         if (gain_delta >= ((s16) gain - state->current_gain))   /* overflow */
 955                 state->current_gain = gain;
 956         else
 957                 state->current_gain += gain_delta;
 958         /* cannot be less than 0 (only if gain_delta is less than 0 we can have current_gain < 0) */
 959         if (state->current_gain < 0)
 960                 state->current_gain = 0;
 961
 962         /* now split total gain to rf and bb gain */
 963         gain = state->current_gain >> GAIN_ALPHA;
 964
 965         /* requested gain is bigger than rf gain limit - ACI/WBD adjustment */
 966         if (gain > (state->rf_gain_limit >> WBD_ALPHA)) {
 967                 rf = state->rf_gain_limit >> WBD_ALPHA;
 968                 bb = gain - rf;
 969                 if (bb > state->bb_ramp[0])
 970                         bb = state->bb_ramp[0];
 971         } else {                /* high signal level -> all gains put on RF */
 972                 rf = gain;
 973                 bb = 0;
 974         }
 975
 976         state->gain[0] = rf;
 977         state->gain[1] = bb;
 978
 979         /* software ramp */
 980         /* Start with RF gains */
 981         g = state->rf_ramp + 1; /* point on RF LNA1 max gain */
 982         ref = rf;
 983         for (i = 0; i < 7; i++) {       /* Go over all amplifiers => 5RF amps + 2 BB amps = 7 amps */
 984                 if (g[0] == 0 || ref < (g[1] - g[0]))   /* if total gain of the current amp is null or this amp is not concerned because it starts to work from an higher gain value */
 985                         v = 0;  /* force the gain to write for the current amp to be null */
 986                 else if (ref >= g[1])   /* Gain to set is higher than the high working point of this amp */
 987                         v = g[2];       /* force this amp to be full gain */
 988                 else            /* compute the value to set to this amp because we are somewhere in his range */
 989                         v = ((ref - (g[1] - g[0])) * g[2]) / g[0];
 990
 991                 if (i == 0)     /* LNA 1 reg mapping */
 992                         gain_reg[0] = v;
 993                 else if (i == 1)        /* LNA 2 reg mapping */
 994                         gain_reg[0] |= v << 7;
 995                 else if (i == 2)        /* LNA 3 reg mapping */
 996                         gain_reg[1] = v;
 997                 else if (i == 3)        /* LNA 4 reg mapping */
 998                         gain_reg[1] |= v << 7;
 999                 else if (i == 4)        /* CBAND LNA reg mapping */
1000                         gain_reg[2] = v | state->rf_lt_def;
1001                 else if (i == 5)        /* BB gain 1 reg mapping */
1002                         gain_reg[3] = v << 3;
1003                 else if (i == 6)        /* BB gain 2 reg mapping */
1004                         gain_reg[3] |= v << 8;
1005
1006                 g += 3;         /* go to next gain bloc */
1007
1008                 /* When RF is finished, start with BB */
1009                 if (i == 4) {
1010                         g = state->bb_ramp + 1; /* point on BB gain 1 max gain */
1011                         ref = bb;
1012                 }
1013         }
1014         gain_reg[3] |= state->bb_1_def;
1015         gain_reg[3] |= ((bb % 10) * 100) / 125;
1016
1017 #ifdef DEBUG_AGC
1018         dprintk("GA CALC: DB: %3d(rf) + %3d(bb) = %3d gain_reg[0]=%04x gain_reg[1]=%04x gain_reg[2]=%04x gain_reg[0]=%04x\n", rf, bb, rf + bb,
1019                 gain_reg[0], gain_reg[1], gain_reg[2], gain_reg[3]);
1020 #endif
1021
1022         /* Write the amplifier regs */
1023         for (i = 0; i < 4; i++) {
1024                 v = gain_reg[i];
1025                 if (force || state->gain_reg[i] != v) {
1026                         state->gain_reg[i] = v;
1027                         dib0090_write_reg(state, gain_reg_addr[i], v);
1028                 }
1029         }
1030 }
1031
1032 static void dib0090_set_boost(struct dib0090_state *state, int onoff)
1033 {
1034         state->bb_1_def &= 0xdfff;
1035         state->bb_1_def |= onoff << 13;
1036 }
1037
1038 static void dib0090_set_rframp(struct dib0090_state *state, const u16 * cfg)
1039 {
1040         state->rf_ramp = cfg;
1041 }
1042
1043 static void dib0090_set_rframp_pwm(struct dib0090_state *state, const u16 * cfg)
1044 {
1045         state->rf_ramp = cfg;
1046
1047         dib0090_write_reg(state, 0x2a, 0xffff);
1048
1049         dprintk("total RF gain: %ddB, step: %d\n", (u32) cfg[0], dib0090_read_reg(state, 0x2a));
1050
1051         dib0090_write_regs(state, 0x2c, cfg + 3, 6);
1052         dib0090_write_regs(state, 0x3e, cfg + 9, 2);
1053 }
1054
1055 static void dib0090_set_bbramp(struct dib0090_state *state, const u16 * cfg)
1056 {
1057         state->bb_ramp = cfg;
1058         dib0090_set_boost(state, cfg[0] > 500); /* we want the boost if the gain is higher that 50dB */
1059 }
1060
1061 static void dib0090_set_bbramp_pwm(struct dib0090_state *state, const u16 * cfg)
1062 {
1063         state->bb_ramp = cfg;
1064
1065         dib0090_set_boost(state, cfg[0] > 500); /* we want the boost if the gain is higher that 50dB */
1066
1067         dib0090_write_reg(state, 0x33, 0xffff);
1068         dprintk("total BB gain: %ddB, step: %d\n", (u32) cfg[0], dib0090_read_reg(state, 0x33));
1069         dib0090_write_regs(state, 0x35, cfg + 3, 4);
1070 }
1071
1072 void dib0090_pwm_gain_reset(struct dvb_frontend *fe)
1073 {
1074         struct dib0090_state *state = fe->tuner_priv;
1075         const u16 *bb_ramp = bb_ramp_pwm_normal; /* default baseband config */
1076         const u16 *rf_ramp = NULL;
1077         u8 en_pwm_rf_mux = 1;
1078
1079         /* reset the AGC */
1080         if (state->config->use_pwm_agc) {
1081                 if (state->current_band == BAND_CBAND) {
1082                         if (state->identity.in_soc) {
1083                                 bb_ramp = bb_ramp_pwm_normal_socs;
1084                                 if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1)
1085                                         rf_ramp = rf_ramp_pwm_cband_8090;
1086                                 else if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1) {
1087                                         if (state->config->is_dib7090e) {
1088                                                 if (state->rf_ramp == NULL)
1089                                                         rf_ramp = rf_ramp_pwm_cband_7090e_sensitivity;
1090                                                 else
1091                                                         rf_ramp = state->rf_ramp;
1092                                         } else
1093                                                 rf_ramp = rf_ramp_pwm_cband_7090p;
1094                                 }
1095                         } else
1096                                 rf_ramp = rf_ramp_pwm_cband;
1097                 } else
1098
1099                         if (state->current_band == BAND_VHF) {
1100                                 if (state->identity.in_soc) {
1101                                         bb_ramp = bb_ramp_pwm_normal_socs;
1102                                         /* rf_ramp = &rf_ramp_pwm_vhf_socs; */ /* TODO */
1103                                 } else
1104                                         rf_ramp = rf_ramp_pwm_vhf;
1105                         } else if (state->current_band == BAND_UHF) {
1106                                 if (state->identity.in_soc) {
1107                                         bb_ramp = bb_ramp_pwm_normal_socs;
1108                                         if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1)
1109                                                 rf_ramp = rf_ramp_pwm_uhf_8090;
1110                                         else if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1)
1111                                                 rf_ramp = rf_ramp_pwm_uhf_7090;
1112                                 } else
1113                                         rf_ramp = rf_ramp_pwm_uhf;
1114                         }
1115                 if (rf_ramp)
1116                         dib0090_set_rframp_pwm(state, rf_ramp);
1117                 dib0090_set_bbramp_pwm(state, bb_ramp);
1118
1119                 /* activate the ramp generator using PWM control */
1120                 if (state->rf_ramp)
1121                         dprintk("ramp RF gain = %d BAND = %s version = %d\n",
1122                                 state->rf_ramp[0],
1123                                 (state->current_band == BAND_CBAND) ? "CBAND" : "NOT CBAND",
1124                                 state->identity.version & 0x1f);
1125
1126                 if (rf_ramp && ((state->rf_ramp && state->rf_ramp[0] == 0) ||
1127                     (state->current_band == BAND_CBAND &&
1128                     (state->identity.version & 0x1f) <= P1D_E_F))) {
1129                         dprintk("DE-Engage mux for direct gain reg control\n");
1130                         en_pwm_rf_mux = 0;
1131                 } else
1132                         dprintk("Engage mux for PWM control\n");
1133
1134                 dib0090_write_reg(state, 0x32, (en_pwm_rf_mux << 12) | (en_pwm_rf_mux << 11));
1135
1136                 /* Set fast servo cutoff to start AGC; 0 = 1KHz ; 1 = 50Hz ; 2 = 150Hz ; 3 = 50KHz ; 4 = servo fast*/
1137                 if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1)
1138                         dib0090_write_reg(state, 0x04, 3);
1139                 else
1140                         dib0090_write_reg(state, 0x04, 1);
1141                 dib0090_write_reg(state, 0x39, (1 << 10)); /* 0 gain by default */
1142         }
1143 }
1144 EXPORT_SYMBOL(dib0090_pwm_gain_reset);
1145
1146 void dib0090_set_dc_servo(struct dvb_frontend *fe, u8 DC_servo_cutoff)
1147 {
1148         struct dib0090_state *state = fe->tuner_priv;
1149         if (DC_servo_cutoff < 4)
1150                 dib0090_write_reg(state, 0x04, DC_servo_cutoff);
1151 }
1152 EXPORT_SYMBOL(dib0090_set_dc_servo);
1153
1154 static u32 dib0090_get_slow_adc_val(struct dib0090_state *state)
1155 {
1156         u16 adc_val = dib0090_read_reg(state, 0x1d);
1157         if (state->identity.in_soc)
1158                 adc_val >>= 2;
1159         return adc_val;
1160 }
1161
1162 int dib0090_gain_control(struct dvb_frontend *fe)
1163 {
1164         struct dib0090_state *state = fe->tuner_priv;
1165         enum frontend_tune_state *tune_state = &state->tune_state;
1166         int ret = 10;
1167
1168         u16 wbd_val = 0;
1169         u8 apply_gain_immediatly = 1;
1170         s16 wbd_error = 0, adc_error = 0;
1171
1172         if (*tune_state == CT_AGC_START) {
1173                 state->agc_freeze = 0;
1174                 dib0090_write_reg(state, 0x04, 0x0);
1175
1176 #ifdef CONFIG_BAND_SBAND
1177                 if (state->current_band == BAND_SBAND) {
1178                         dib0090_set_rframp(state, rf_ramp_sband);
1179                         dib0090_set_bbramp(state, bb_ramp_boost);
1180                 } else
1181 #endif
1182 #ifdef CONFIG_BAND_VHF
1183                 if (state->current_band == BAND_VHF && !state->identity.p1g) {
1184                         dib0090_set_rframp(state, rf_ramp_pwm_vhf);
1185                         dib0090_set_bbramp(state, bb_ramp_pwm_normal);
1186                 } else
1187 #endif
1188 #ifdef CONFIG_BAND_CBAND
1189                 if (state->current_band == BAND_CBAND && !state->identity.p1g) {
1190                         dib0090_set_rframp(state, rf_ramp_pwm_cband);
1191                         dib0090_set_bbramp(state, bb_ramp_pwm_normal);
1192                 } else
1193 #endif
1194                 if ((state->current_band == BAND_CBAND || state->current_band == BAND_VHF) && state->identity.p1g) {
1195                         dib0090_set_rframp(state, rf_ramp_pwm_cband_7090p);
1196                         dib0090_set_bbramp(state, bb_ramp_pwm_normal_socs);
1197                 } else {
1198                         dib0090_set_rframp(state, rf_ramp_pwm_uhf);
1199                         dib0090_set_bbramp(state, bb_ramp_pwm_normal);
1200                 }
1201
1202                 dib0090_write_reg(state, 0x32, 0);
1203                 dib0090_write_reg(state, 0x39, 0);
1204
1205                 dib0090_wbd_target(state, state->current_rf);
1206
1207                 state->rf_gain_limit = state->rf_ramp[0] << WBD_ALPHA;
1208                 state->current_gain = ((state->rf_ramp[0] + state->bb_ramp[0]) / 2) << GAIN_ALPHA;
1209
1210                 *tune_state = CT_AGC_STEP_0;
1211         } else if (!state->agc_freeze) {
1212                 s16 wbd = 0, i, cnt;
1213
1214                 int adc;
1215                 wbd_val = dib0090_get_slow_adc_val(state);
1216
1217                 if (*tune_state == CT_AGC_STEP_0)
1218                         cnt = 5;
1219                 else
1220                         cnt = 1;
1221
1222                 for (i = 0; i < cnt; i++) {
1223                         wbd_val = dib0090_get_slow_adc_val(state);
1224                         wbd += dib0090_wbd_to_db(state, wbd_val);
1225                 }
1226                 wbd /= cnt;
1227                 wbd_error = state->wbd_target - wbd;
1228
1229                 if (*tune_state == CT_AGC_STEP_0) {
1230                         if (wbd_error < 0 && state->rf_gain_limit > 0 && !state->identity.p1g) {
1231 #ifdef CONFIG_BAND_CBAND
1232                                 /* in case of CBAND tune reduce first the lt_gain2 before adjusting the RF gain */
1233                                 u8 ltg2 = (state->rf_lt_def >> 10) & 0x7;
1234                                 if (state->current_band == BAND_CBAND && ltg2) {
1235                                         ltg2 >>= 1;
1236                                         state->rf_lt_def &= ltg2 << 10; /* reduce in 3 steps from 7 to 0 */
1237                                 }
1238 #endif
1239                         } else {
1240                                 state->agc_step = 0;
1241                                 *tune_state = CT_AGC_STEP_1;
1242                         }
1243                 } else {
1244                         /* calc the adc power */
1245                         adc = state->config->get_adc_power(fe);
1246                         adc = (adc * ((s32) 355774) + (((s32) 1) << 20)) >> 21; /* included in [0:-700] */
1247
1248                         adc_error = (s16) (((s32) ADC_TARGET) - adc);
1249 #ifdef CONFIG_STANDARD_DAB
1250                         if (state->fe->dtv_property_cache.delivery_system == STANDARD_DAB)
1251                                 adc_error -= 10;
1252 #endif
1253 #ifdef CONFIG_STANDARD_DVBT
1254                         if (state->fe->dtv_property_cache.delivery_system == STANDARD_DVBT &&
1255                                         (state->fe->dtv_property_cache.modulation == QAM_64 || state->fe->dtv_property_cache.modulation == QAM_16))
1256                                 adc_error += 60;
1257 #endif
1258 #ifdef CONFIG_SYS_ISDBT
1259                         if ((state->fe->dtv_property_cache.delivery_system == SYS_ISDBT) && (((state->fe->dtv_property_cache.layer[0].segment_count >
1260                                                                 0)
1261                                                         &&
1262                                                         ((state->fe->dtv_property_cache.layer[0].modulation ==
1263                                                           QAM_64)
1264                                                          || (state->fe->dtv_property_cache.
1265                                                                  layer[0].modulation == QAM_16)))
1266                                                 ||
1267                                                 ((state->fe->dtv_property_cache.layer[1].segment_count >
1268                                                   0)
1269                                                  &&
1270                                                  ((state->fe->dtv_property_cache.layer[1].modulation ==
1271                                                    QAM_64)
1272                                                   || (state->fe->dtv_property_cache.
1273                                                           layer[1].modulation == QAM_16)))
1274                                                 ||
1275                                                 ((state->fe->dtv_property_cache.layer[2].segment_count >
1276                                                   0)
1277                                                  &&
1278                                                  ((state->fe->dtv_property_cache.layer[2].modulation ==
1279                                                    QAM_64)
1280                                                   || (state->fe->dtv_property_cache.
1281                                                           layer[2].modulation == QAM_16)))
1282                                                 )
1283                                 )
1284                                 adc_error += 60;
1285 #endif
1286
1287                         if (*tune_state == CT_AGC_STEP_1) {     /* quickly go to the correct range of the ADC power */
1288                                 if (abs(adc_error) < 50 || state->agc_step++ > 5) {
1289
1290 #ifdef CONFIG_STANDARD_DAB
1291                                         if (state->fe->dtv_property_cache.delivery_system == STANDARD_DAB) {
1292                                                 dib0090_write_reg(state, 0x02, (1 << 15) | (15 << 11) | (31 << 6) | (63));      /* cap value = 63 : narrow BB filter : Fc = 1.8MHz */
1293                                                 dib0090_write_reg(state, 0x04, 0x0);
1294                                         } else
1295 #endif
1296                                         {
1297                                                 dib0090_write_reg(state, 0x02, (1 << 15) | (3 << 11) | (6 << 6) | (32));
1298                                                 dib0090_write_reg(state, 0x04, 0x01);   /*0 = 1KHz ; 1 = 150Hz ; 2 = 50Hz ; 3 = 50KHz ; 4 = servo fast */
1299                                         }
1300
1301                                         *tune_state = CT_AGC_STOP;
1302                                 }
1303                         } else {
1304                                 /* everything higher than or equal to CT_AGC_STOP means tracking */
1305                                 ret = 100;      /* 10ms interval */
1306                                 apply_gain_immediatly = 0;
1307                         }
1308                 }
1309 #ifdef DEBUG_AGC
1310                 dprintk
1311                         ("tune state %d, ADC = %3ddB (ADC err %3d) WBD %3ddB (WBD err %3d, WBD val SADC: %4d), RFGainLimit (TOP): %3d, signal: %3ddBm",
1312                          (u32) *tune_state, (u32) adc, (u32) adc_error, (u32) wbd, (u32) wbd_error, (u32) wbd_val,
1313                          (u32) state->rf_gain_limit >> WBD_ALPHA, (s32) 200 + adc - (state->current_gain >> GAIN_ALPHA));
1314 #endif
1315         }
1316
1317         /* apply gain */
1318         if (!state->agc_freeze)
1319                 dib0090_gain_apply(state, adc_error, wbd_error, apply_gain_immediatly);
1320         return ret;
1321 }
1322
1323 EXPORT_SYMBOL(dib0090_gain_control);
1324
1325 void dib0090_get_current_gain(struct dvb_frontend *fe, u16 * rf, u16 * bb, u16 * rf_gain_limit, u16 * rflt)
1326 {
1327         struct dib0090_state *state = fe->tuner_priv;
1328         if (rf)
1329                 *rf = state->gain[0];
1330         if (bb)
1331                 *bb = state->gain[1];
1332         if (rf_gain_limit)
1333                 *rf_gain_limit = state->rf_gain_limit;
1334         if (rflt)
1335                 *rflt = (state->rf_lt_def >> 10) & 0x7;
1336 }
1337
1338 EXPORT_SYMBOL(dib0090_get_current_gain);
1339
1340 u16 dib0090_get_wbd_target(struct dvb_frontend *fe)
1341 {
1342         struct dib0090_state *state = fe->tuner_priv;
1343         u32 f_MHz = state->fe->dtv_property_cache.frequency / 1000000;
1344         s32 current_temp = state->temperature;
1345         s32 wbd_thot, wbd_tcold;
1346         const struct dib0090_wbd_slope *wbd = state->current_wbd_table;
1347
1348         while (f_MHz > wbd->max_freq)
1349                 wbd++;
1350
1351         dprintk("using wbd-table-entry with max freq %d\n", wbd->max_freq);
1352
1353         if (current_temp < 0)
1354                 current_temp = 0;
1355         if (current_temp > 128)
1356                 current_temp = 128;
1357
1358         state->wbdmux &= ~(7 << 13);
1359         if (wbd->wbd_gain != 0)
1360                 state->wbdmux |= (wbd->wbd_gain << 13);
1361         else
1362                 state->wbdmux |= (4 << 13);
1363
1364         dib0090_write_reg(state, 0x10, state->wbdmux);
1365
1366         wbd_thot = wbd->offset_hot - (((u32) wbd->slope_hot * f_MHz) >> 6);
1367         wbd_tcold = wbd->offset_cold - (((u32) wbd->slope_cold * f_MHz) >> 6);
1368
1369         wbd_tcold += ((wbd_thot - wbd_tcold) * current_temp) >> 7;
1370
1371         state->wbd_target = dib0090_wbd_to_db(state, state->wbd_offset + wbd_tcold);
1372         dprintk("wbd-target: %d dB\n", (u32) state->wbd_target);
1373         dprintk("wbd offset applied is %d\n", wbd_tcold);
1374
1375         return state->wbd_offset + wbd_tcold;
1376 }
1377 EXPORT_SYMBOL(dib0090_get_wbd_target);
1378
1379 u16 dib0090_get_wbd_offset(struct dvb_frontend *fe)
1380 {
1381         struct dib0090_state *state = fe->tuner_priv;
1382         return state->wbd_offset;
1383 }
1384 EXPORT_SYMBOL(dib0090_get_wbd_offset);
1385
1386 int dib0090_set_switch(struct dvb_frontend *fe, u8 sw1, u8 sw2, u8 sw3)
1387 {
1388         struct dib0090_state *state = fe->tuner_priv;
1389
1390         dib0090_write_reg(state, 0x0b, (dib0090_read_reg(state, 0x0b) & 0xfff8)
1391                         | ((sw3 & 1) << 2) | ((sw2 & 1) << 1) | (sw1 & 1));
1392
1393         return 0;
1394 }
1395 EXPORT_SYMBOL(dib0090_set_switch);
1396
1397 int dib0090_set_vga(struct dvb_frontend *fe, u8 onoff)
1398 {
1399         struct dib0090_state *state = fe->tuner_priv;
1400
1401         dib0090_write_reg(state, 0x09, (dib0090_read_reg(state, 0x09) & 0x7fff)
1402                         | ((onoff & 1) << 15));
1403         return 0;
1404 }
1405 EXPORT_SYMBOL(dib0090_set_vga);
1406
1407 int dib0090_update_rframp_7090(struct dvb_frontend *fe, u8 cfg_sensitivity)
1408 {
1409         struct dib0090_state *state = fe->tuner_priv;
1410
1411         if ((!state->identity.p1g) || (!state->identity.in_soc)
1412                         || ((state->identity.version != SOC_7090_P1G_21R1)
1413                                 && (state->identity.version != SOC_7090_P1G_11R1))) {
1414                 dprintk("%s() function can only be used for dib7090P\n", __func__);
1415                 return -ENODEV;
1416         }
1417
1418         if (cfg_sensitivity)
1419                 state->rf_ramp = rf_ramp_pwm_cband_7090e_sensitivity;
1420         else
1421                 state->rf_ramp = rf_ramp_pwm_cband_7090e_aci;
1422         dib0090_pwm_gain_reset(fe);
1423
1424         return 0;
1425 }
1426 EXPORT_SYMBOL(dib0090_update_rframp_7090);
1427
1428 static const u16 dib0090_defaults[] = {
1429
1430         25, 0x01,
1431         0x0000,
1432         0x99a0,
1433         0x6008,
1434         0x0000,
1435         0x8bcb,
1436         0x0000,
1437         0x0405,
1438         0x0000,
1439         0x0000,
1440         0x0000,
1441         0xb802,
1442         0x0300,
1443         0x2d12,
1444         0xbac0,
1445         0x7c00,
1446         0xdbb9,
1447         0x0954,
1448         0x0743,
1449         0x8000,
1450         0x0001,
1451         0x0040,
1452         0x0100,
1453         0x0000,
1454         0xe910,
1455         0x149e,
1456
1457         1, 0x1c,
1458         0xff2d,
1459
1460         1, 0x39,
1461         0x0000,
1462
1463         2, 0x1e,
1464         0x07FF,
1465         0x0007,
1466
1467         1, 0x24,
1468         EN_UHF | EN_CRYSTAL,
1469
1470         2, 0x3c,
1471         0x3ff,
1472         0x111,
1473         0
1474 };
1475
1476 static const u16 dib0090_p1g_additionnal_defaults[] = {
1477         1, 0x05,
1478         0xabcd,
1479
1480         1, 0x11,
1481         0x00b4,
1482
1483         1, 0x1c,
1484         0xfffd,
1485
1486         1, 0x40,
1487         0x108,
1488         0
1489 };
1490
1491 static void dib0090_set_default_config(struct dib0090_state *state, const u16 * n)
1492 {
1493         u16 l, r;
1494
1495         l = pgm_read_word(n++);
1496         while (l) {
1497                 r = pgm_read_word(n++);
1498                 do {
1499                         dib0090_write_reg(state, r, pgm_read_word(n++));
1500                         r++;
1501                 } while (--l);
1502                 l = pgm_read_word(n++);
1503         }
1504 }
1505
1506 #define CAP_VALUE_MIN (u8)  9
1507 #define CAP_VALUE_MAX (u8) 40
1508 #define HR_MIN        (u8) 25
1509 #define HR_MAX        (u8) 40
1510 #define POLY_MIN      (u8)  0
1511 #define POLY_MAX      (u8)  8
1512
1513 static void dib0090_set_EFUSE(struct dib0090_state *state)
1514 {
1515         u8 c, h, n;
1516         u16 e2, e4;
1517         u16 cal;
1518
1519         e2 = dib0090_read_reg(state, 0x26);
1520         e4 = dib0090_read_reg(state, 0x28);
1521
1522         if ((state->identity.version == P1D_E_F) ||
1523                         (state->identity.version == P1G) || (e2 == 0xffff)) {
1524
1525                 dib0090_write_reg(state, 0x22, 0x10);
1526                 cal = (dib0090_read_reg(state, 0x22) >> 6) & 0x3ff;
1527
1528                 if ((cal < 670) || (cal == 1023))
1529                         cal = 850;
1530                 n = 165 - ((cal * 10)>>6) ;
1531                 e2 = e4 = (3<<12) | (34<<6) | (n);
1532         }
1533
1534         if (e2 != e4)
1535                 e2 &= e4; /* Remove the redundancy  */
1536
1537         if (e2 != 0xffff) {
1538                 c = e2 & 0x3f;
1539                 n = (e2 >> 12) & 0xf;
1540                 h = (e2 >> 6) & 0x3f;
1541
1542                 if ((c >= CAP_VALUE_MAX) || (c <= CAP_VALUE_MIN))
1543                         c = 32;
1544                 else
1545                         c += 14;
1546                 if ((h >= HR_MAX) || (h <= HR_MIN))
1547                         h = 34;
1548                 if ((n >= POLY_MAX) || (n <= POLY_MIN))
1549                         n = 3;
1550
1551                 dib0090_write_reg(state, 0x13, (h << 10));
1552                 e2 = (n << 11) | ((h >> 2)<<6) | c;
1553                 dib0090_write_reg(state, 0x2, e2); /* Load the BB_2 */
1554         }
1555 }
1556
1557 static int dib0090_reset(struct dvb_frontend *fe)
1558 {
1559         struct dib0090_state *state = fe->tuner_priv;
1560
1561         dib0090_reset_digital(fe, state->config);
1562         if (dib0090_identify(fe) < 0)
1563                 return -EIO;
1564
1565 #ifdef CONFIG_TUNER_DIB0090_P1B_SUPPORT
1566         if (!(state->identity.version & 0x1))   /* it is P1B - reset is already done */
1567                 return 0;
1568 #endif
1569
1570         if (!state->identity.in_soc) {
1571                 if ((dib0090_read_reg(state, 0x1a) >> 5) & 0x2)
1572                         dib0090_write_reg(state, 0x1b, (EN_IQADC | EN_BB | EN_BIAS | EN_DIGCLK | EN_PLL | EN_CRYSTAL));
1573                 else
1574                         dib0090_write_reg(state, 0x1b, (EN_DIGCLK | EN_PLL | EN_CRYSTAL));
1575         }
1576
1577         dib0090_set_default_config(state, dib0090_defaults);
1578
1579         if (state->identity.in_soc)
1580                 dib0090_write_reg(state, 0x18, 0x2910);  /* charge pump current = 0 */
1581
1582         if (state->identity.p1g)
1583                 dib0090_set_default_config(state, dib0090_p1g_additionnal_defaults);
1584
1585         /* Update the efuse : Only available for KROSUS > P1C  and SOC as well*/
1586         if (((state->identity.version & 0x1f) >= P1D_E_F) || (state->identity.in_soc))
1587                 dib0090_set_EFUSE(state);
1588
1589         /* Congigure in function of the crystal */
1590         if (state->config->force_crystal_mode != 0)
1591                 dib0090_write_reg(state, 0x14,
1592                                 state->config->force_crystal_mode & 3);
1593         else if (state->config->io.clock_khz >= 24000)
1594                 dib0090_write_reg(state, 0x14, 1);
1595         else
1596                 dib0090_write_reg(state, 0x14, 2);
1597         dprintk("Pll lock : %d\n", (dib0090_read_reg(state, 0x1a) >> 11) & 0x1);
1598
1599         state->calibrate = DC_CAL | WBD_CAL | TEMP_CAL; /* enable iq-offset-calibration and wbd-calibration when tuning next time */
1600
1601         return 0;
1602 }
1603
1604 #define steps(u) (((u) > 15) ? ((u)-16) : (u))
1605 #define INTERN_WAIT 10
1606 static int dib0090_get_offset(struct dib0090_state *state, enum frontend_tune_state *tune_state)
1607 {
1608         int ret = INTERN_WAIT * 10;
1609
1610         switch (*tune_state) {
1611         case CT_TUNER_STEP_2:
1612                 /* Turns to positive */
1613                 dib0090_write_reg(state, 0x1f, 0x7);
1614                 *tune_state = CT_TUNER_STEP_3;
1615                 break;
1616
1617         case CT_TUNER_STEP_3:
1618                 state->adc_diff = dib0090_read_reg(state, 0x1d);
1619
1620                 /* Turns to negative */
1621                 dib0090_write_reg(state, 0x1f, 0x4);
1622                 *tune_state = CT_TUNER_STEP_4;
1623                 break;
1624
1625         case CT_TUNER_STEP_4:
1626                 state->adc_diff -= dib0090_read_reg(state, 0x1d);
1627                 *tune_state = CT_TUNER_STEP_5;
1628                 ret = 0;
1629                 break;
1630
1631         default:
1632                 break;
1633         }
1634
1635         return ret;
1636 }
1637
1638 struct dc_calibration {
1639         u8 addr;
1640         u8 offset;
1641         u8 pga:1;
1642         u16 bb1;
1643         u8 i:1;
1644 };
1645
1646 static const struct dc_calibration dc_table[] = {
1647         /* Step1 BB gain1= 26 with boost 1, gain 2 = 0 */
1648         {0x06, 5, 1, (1 << 13) | (0 << 8) | (26 << 3), 1},
1649         {0x07, 11, 1, (1 << 13) | (0 << 8) | (26 << 3), 0},
1650         /* Step 2 BB gain 1 = 26 with boost = 1 & gain 2 = 29 */
1651         {0x06, 0, 0, (1 << 13) | (29 << 8) | (26 << 3), 1},
1652         {0x06, 10, 0, (1 << 13) | (29 << 8) | (26 << 3), 0},
1653         {0},
1654 };
1655
1656 static const struct dc_calibration dc_p1g_table[] = {
1657         /* Step1 BB gain1= 26 with boost 1, gain 2 = 0 */
1658         /* addr ; trim reg offset ; pga ; CTRL_BB1 value ; i or q */
1659         {0x06, 5, 1, (1 << 13) | (0 << 8) | (15 << 3), 1},
1660         {0x07, 11, 1, (1 << 13) | (0 << 8) | (15 << 3), 0},
1661         /* Step 2 BB gain 1 = 26 with boost = 1 & gain 2 = 29 */
1662         {0x06, 0, 0, (1 << 13) | (29 << 8) | (15 << 3), 1},
1663         {0x06, 10, 0, (1 << 13) | (29 << 8) | (15 << 3), 0},
1664         {0},
1665 };
1666
1667 static void dib0090_set_trim(struct dib0090_state *state)
1668 {
1669         u16 *val;
1670
1671         if (state->dc->addr == 0x07)
1672                 val = &state->bb7;
1673         else
1674                 val = &state->bb6;
1675
1676         *val &= ~(0x1f << state->dc->offset);
1677         *val |= state->step << state->dc->offset;
1678
1679         dib0090_write_reg(state, state->dc->addr, *val);
1680 }
1681
1682 static int dib0090_dc_offset_calibration(struct dib0090_state *state, enum frontend_tune_state *tune_state)
1683 {
1684         int ret = 0;
1685         u16 reg;
1686
1687         switch (*tune_state) {
1688         case CT_TUNER_START:
1689                 dprintk("Start DC offset calibration");
1690
1691                 /* force vcm2 = 0.8V */
1692                 state->bb6 = 0;
1693                 state->bb7 = 0x040d;
1694
1695                 /* the LNA AND LO are off */
1696                 reg = dib0090_read_reg(state, 0x24) & 0x0ffb;   /* shutdown lna and lo */
1697                 dib0090_write_reg(state, 0x24, reg);
1698
1699                 state->wbdmux = dib0090_read_reg(state, 0x10);
1700                 dib0090_write_reg(state, 0x10, (state->wbdmux & ~(0xff << 3)) | (0x7 << 3) | 0x3);
1701                 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) & ~(1 << 14));
1702
1703                 state->dc = dc_table;
1704
1705                 if (state->identity.p1g)
1706                         state->dc = dc_p1g_table;
1707
1708                 /* fall through */
1709         case CT_TUNER_STEP_0:
1710                 dprintk("Start/continue DC calibration for %s path\n",
1711                         (state->dc->i == 1) ? "I" : "Q");
1712                 dib0090_write_reg(state, 0x01, state->dc->bb1);
1713                 dib0090_write_reg(state, 0x07, state->bb7 | (state->dc->i << 7));
1714
1715                 state->step = 0;
1716                 state->min_adc_diff = 1023;
1717                 *tune_state = CT_TUNER_STEP_1;
1718                 ret = 50;
1719                 break;
1720
1721         case CT_TUNER_STEP_1:
1722                 dib0090_set_trim(state);
1723                 *tune_state = CT_TUNER_STEP_2;
1724                 break;
1725
1726         case CT_TUNER_STEP_2:
1727         case CT_TUNER_STEP_3:
1728         case CT_TUNER_STEP_4:
1729                 ret = dib0090_get_offset(state, tune_state);
1730                 break;
1731
1732         case CT_TUNER_STEP_5:   /* found an offset */
1733                 dprintk("adc_diff = %d, current step= %d\n", (u32) state->adc_diff, state->step);
1734                 if (state->step == 0 && state->adc_diff < 0) {
1735                         state->min_adc_diff = -1023;
1736                         dprintk("Change of sign of the minimum adc diff\n");
1737                 }
1738
1739                 dprintk("adc_diff = %d, min_adc_diff = %d current_step = %d\n", state->adc_diff, state->min_adc_diff, state->step);
1740
1741                 /* first turn for this frequency */
1742                 if (state->step == 0) {
1743                         if (state->dc->pga && state->adc_diff < 0)
1744                                 state->step = 0x10;
1745                         if (state->dc->pga == 0 && state->adc_diff > 0)
1746                                 state->step = 0x10;
1747                 }
1748
1749                 /* Look for a change of Sign in the Adc_diff.min_adc_diff is used to STORE the setp N-1 */
1750                 if ((state->adc_diff & 0x8000) == (state->min_adc_diff & 0x8000) && steps(state->step) < 15) {
1751                         /* stop search when the delta the sign is changing and Steps =15 and Step=0 is force for continuance */
1752                         state->step++;
1753                         state->min_adc_diff = state->adc_diff;
1754                         *tune_state = CT_TUNER_STEP_1;
1755                 } else {
1756                         /* the minimum was what we have seen in the step before */
1757                         if (abs(state->adc_diff) > abs(state->min_adc_diff)) {
1758                                 dprintk("Since adc_diff N = %d  > adc_diff step N-1 = %d, Come back one step\n", state->adc_diff, state->min_adc_diff);
1759                                 state->step--;
1760                         }
1761
1762                         dib0090_set_trim(state);
1763                         dprintk("BB Offset Cal, BBreg=%hd,Offset=%hd,Value Set=%hd\n", state->dc->addr, state->adc_diff, state->step);
1764
1765                         state->dc++;
1766                         if (state->dc->addr == 0)       /* done */
1767                                 *tune_state = CT_TUNER_STEP_6;
1768                         else
1769                                 *tune_state = CT_TUNER_STEP_0;
1770
1771                 }
1772                 break;
1773
1774         case CT_TUNER_STEP_6:
1775                 dib0090_write_reg(state, 0x07, state->bb7 & ~0x0008);
1776                 dib0090_write_reg(state, 0x1f, 0x7);
1777                 *tune_state = CT_TUNER_START;   /* reset done -> real tuning can now begin */
1778                 state->calibrate &= ~DC_CAL;
1779         default:
1780                 break;
1781         }
1782         return ret;
1783 }
1784
1785 static int dib0090_wbd_calibration(struct dib0090_state *state, enum frontend_tune_state *tune_state)
1786 {
1787         u8 wbd_gain;
1788         const struct dib0090_wbd_slope *wbd = state->current_wbd_table;
1789
1790         switch (*tune_state) {
1791         case CT_TUNER_START:
1792                 while (state->current_rf / 1000 > wbd->max_freq)
1793                         wbd++;
1794                 if (wbd->wbd_gain != 0)
1795                         wbd_gain = wbd->wbd_gain;
1796                 else {
1797                         wbd_gain = 4;
1798 #if defined(CONFIG_BAND_LBAND) || defined(CONFIG_BAND_SBAND)
1799                         if ((state->current_band == BAND_LBAND) || (state->current_band == BAND_SBAND))
1800                                 wbd_gain = 2;
1801 #endif
1802                 }
1803
1804                 if (wbd_gain == state->wbd_calibration_gain) {  /* the WBD calibration has already been done */
1805                         *tune_state = CT_TUNER_START;
1806                         state->calibrate &= ~WBD_CAL;
1807                         return 0;
1808                 }
1809
1810                 dib0090_write_reg(state, 0x10, 0x1b81 | (1 << 10) | (wbd_gain << 13) | (1 << 3));
1811
1812                 dib0090_write_reg(state, 0x24, ((EN_UHF & 0x0fff) | (1 << 1)));
1813                 *tune_state = CT_TUNER_STEP_0;
1814                 state->wbd_calibration_gain = wbd_gain;
1815                 return 90;      /* wait for the WBDMUX to switch and for the ADC to sample */
1816
1817         case CT_TUNER_STEP_0:
1818                 state->wbd_offset = dib0090_get_slow_adc_val(state);
1819                 dprintk("WBD calibration offset = %d\n", state->wbd_offset);
1820                 *tune_state = CT_TUNER_START;   /* reset done -> real tuning can now begin */
1821                 state->calibrate &= ~WBD_CAL;
1822                 break;
1823
1824         default:
1825                 break;
1826         }
1827         return 0;
1828 }
1829
1830 static void dib0090_set_bandwidth(struct dib0090_state *state)
1831 {
1832         u16 tmp;
1833
1834         if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 5000)
1835                 tmp = (3 << 14);
1836         else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 6000)
1837                 tmp = (2 << 14);
1838         else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 7000)
1839                 tmp = (1 << 14);
1840         else
1841                 tmp = (0 << 14);
1842
1843         state->bb_1_def &= 0x3fff;
1844         state->bb_1_def |= tmp;
1845
1846         dib0090_write_reg(state, 0x01, state->bb_1_def);        /* be sure that we have the right bb-filter */
1847
1848         dib0090_write_reg(state, 0x03, 0x6008); /* = 0x6008 : vcm3_trim = 1 ; filter2_gm1_trim = 8 ; filter2_cutoff_freq = 0 */
1849         dib0090_write_reg(state, 0x04, 0x1);    /* 0 = 1KHz ; 1 = 50Hz ; 2 = 150Hz ; 3 = 50KHz ; 4 = servo fast */
1850         if (state->identity.in_soc) {
1851                 dib0090_write_reg(state, 0x05, 0x9bcf); /* attenuator_ibias_tri = 2 ; input_stage_ibias_tr = 1 ; nc = 11 ; ext_gm_trim = 1 ; obuf_ibias_trim = 4 ; filter13_gm2_ibias_t = 15 */
1852         } else {
1853                 dib0090_write_reg(state, 0x02, (5 << 11) | (8 << 6) | (22 & 0x3f));     /* 22 = cap_value */
1854                 dib0090_write_reg(state, 0x05, 0xabcd); /* = 0xabcd : attenuator_ibias_tri = 2 ; input_stage_ibias_tr = 2 ; nc = 11 ; ext_gm_trim = 1 ; obuf_ibias_trim = 4 ; filter13_gm2_ibias_t = 13 */
1855         }
1856 }
1857
1858 static const struct dib0090_pll dib0090_pll_table[] = {
1859 #ifdef CONFIG_BAND_CBAND
1860         {56000, 0, 9, 48, 6},
1861         {70000, 1, 9, 48, 6},
1862         {87000, 0, 8, 32, 4},
1863         {105000, 1, 8, 32, 4},
1864         {115000, 0, 7, 24, 6},
1865         {140000, 1, 7, 24, 6},
1866         {170000, 0, 6, 16, 4},
1867 #endif
1868 #ifdef CONFIG_BAND_VHF
1869         {200000, 1, 6, 16, 4},
1870         {230000, 0, 5, 12, 6},
1871         {280000, 1, 5, 12, 6},
1872         {340000, 0, 4, 8, 4},
1873         {380000, 1, 4, 8, 4},
1874         {450000, 0, 3, 6, 6},
1875 #endif
1876 #ifdef CONFIG_BAND_UHF
1877         {580000, 1, 3, 6, 6},
1878         {700000, 0, 2, 4, 4},
1879         {860000, 1, 2, 4, 4},
1880 #endif
1881 #ifdef CONFIG_BAND_LBAND
1882         {1800000, 1, 0, 2, 4},
1883 #endif
1884 #ifdef CONFIG_BAND_SBAND
1885         {2900000, 0, 14, 1, 4},
1886 #endif
1887 };
1888
1889 static const struct dib0090_tuning dib0090_tuning_table_fm_vhf_on_cband[] = {
1890
1891 #ifdef CONFIG_BAND_CBAND
1892         {184000, 4, 1, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1893         {227000, 4, 3, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1894         {380000, 4, 7, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1895 #endif
1896 #ifdef CONFIG_BAND_UHF
1897         {520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1898         {550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1899         {650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1900         {750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1901         {850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1902         {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1903 #endif
1904 #ifdef CONFIG_BAND_LBAND
1905         {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1906         {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1907         {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1908 #endif
1909 #ifdef CONFIG_BAND_SBAND
1910         {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
1911         {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
1912 #endif
1913 };
1914
1915 static const struct dib0090_tuning dib0090_tuning_table[] = {
1916
1917 #ifdef CONFIG_BAND_CBAND
1918         {170000, 4, 1, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1919 #endif
1920 #ifdef CONFIG_BAND_VHF
1921         {184000, 1, 1, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1922         {227000, 1, 3, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1923         {380000, 1, 7, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1924 #endif
1925 #ifdef CONFIG_BAND_UHF
1926         {520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1927         {550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1928         {650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1929         {750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1930         {850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1931         {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1932 #endif
1933 #ifdef CONFIG_BAND_LBAND
1934         {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1935         {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1936         {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1937 #endif
1938 #ifdef CONFIG_BAND_SBAND
1939         {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
1940         {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
1941 #endif
1942 };
1943
1944 static const struct dib0090_tuning dib0090_p1g_tuning_table[] = {
1945 #ifdef CONFIG_BAND_CBAND
1946         {170000, 4, 1, 0x820f, 0x300, 0x2d22, 0x82cb, EN_CAB},
1947 #endif
1948 #ifdef CONFIG_BAND_VHF
1949         {184000, 1, 1, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1950         {227000, 1, 3, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1951         {380000, 1, 7, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1952 #endif
1953 #ifdef CONFIG_BAND_UHF
1954         {510000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1955         {540000, 2, 1, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1956         {600000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1957         {630000, 2, 4, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1958         {680000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1959         {720000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1960         {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1961 #endif
1962 #ifdef CONFIG_BAND_LBAND
1963         {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1964         {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1965         {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1966 #endif
1967 #ifdef CONFIG_BAND_SBAND
1968         {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
1969         {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
1970 #endif
1971 };
1972
1973 static const struct dib0090_pll dib0090_p1g_pll_table[] = {
1974 #ifdef CONFIG_BAND_CBAND
1975         {57000, 0, 11, 48, 6},
1976         {70000, 1, 11, 48, 6},
1977         {86000, 0, 10, 32, 4},
1978         {105000, 1, 10, 32, 4},
1979         {115000, 0, 9, 24, 6},
1980         {140000, 1, 9, 24, 6},
1981         {170000, 0, 8, 16, 4},
1982 #endif
1983 #ifdef CONFIG_BAND_VHF
1984         {200000, 1, 8, 16, 4},
1985         {230000, 0, 7, 12, 6},
1986         {280000, 1, 7, 12, 6},
1987         {340000, 0, 6, 8, 4},
1988         {380000, 1, 6, 8, 4},
1989         {455000, 0, 5, 6, 6},
1990 #endif
1991 #ifdef CONFIG_BAND_UHF
1992         {580000, 1, 5, 6, 6},
1993         {680000, 0, 4, 4, 4},
1994         {860000, 1, 4, 4, 4},
1995 #endif
1996 #ifdef CONFIG_BAND_LBAND
1997         {1800000, 1, 2, 2, 4},
1998 #endif
1999 #ifdef CONFIG_BAND_SBAND
2000         {2900000, 0, 1, 1, 6},
2001 #endif
2002 };
2003
2004 static const struct dib0090_tuning dib0090_p1g_tuning_table_fm_vhf_on_cband[] = {
2005 #ifdef CONFIG_BAND_CBAND
2006         {184000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB},
2007         {227000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB},
2008         {380000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB},
2009 #endif
2010 #ifdef CONFIG_BAND_UHF
2011         {520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2012         {550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2013         {650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2014         {750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2015         {850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2016         {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2017 #endif
2018 #ifdef CONFIG_BAND_LBAND
2019         {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
2020         {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
2021         {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
2022 #endif
2023 #ifdef CONFIG_BAND_SBAND
2024         {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
2025         {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
2026 #endif
2027 };
2028
2029 static const struct dib0090_tuning dib0090_tuning_table_cband_7090[] = {
2030 #ifdef CONFIG_BAND_CBAND
2031         {300000, 4, 3, 0x018F, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2032         {380000, 4, 10, 0x018F, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2033         {570000, 4, 10, 0x8190, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2034         {858000, 4, 5, 0x8190, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2035 #endif
2036 };
2037
2038 static const struct dib0090_tuning dib0090_tuning_table_cband_7090e_sensitivity[] = {
2039 #ifdef CONFIG_BAND_CBAND
2040         { 300000,  0 ,  3,  0x8105, 0x2c0, 0x2d12, 0xb84e, EN_CAB },
2041         { 380000,  0 ,  10, 0x810F, 0x2c0, 0x2d12, 0xb84e, EN_CAB },
2042         { 600000,  0 ,  10, 0x815E, 0x280, 0x2d12, 0xb84e, EN_CAB },
2043         { 660000,  0 ,  5,  0x85E3, 0x280, 0x2d12, 0xb84e, EN_CAB },
2044         { 720000,  0 ,  5,  0x852E, 0x280, 0x2d12, 0xb84e, EN_CAB },
2045         { 860000,  0 ,  4,  0x85E5, 0x280, 0x2d12, 0xb84e, EN_CAB },
2046 #endif
2047 };
2048
2049 int dib0090_update_tuning_table_7090(struct dvb_frontend *fe,
2050                 u8 cfg_sensitivity)
2051 {
2052         struct dib0090_state *state = fe->tuner_priv;
2053         const struct dib0090_tuning *tune =
2054                 dib0090_tuning_table_cband_7090e_sensitivity;
2055         static const struct dib0090_tuning dib0090_tuning_table_cband_7090e_aci[] = {
2056                 { 300000,  0 ,  3,  0x8165, 0x2c0, 0x2d12, 0xb84e, EN_CAB },
2057                 { 650000,  0 ,  4,  0x815B, 0x280, 0x2d12, 0xb84e, EN_CAB },
2058                 { 860000,  0 ,  5,  0x84EF, 0x280, 0x2d12, 0xb84e, EN_CAB },
2059         };
2060
2061         if ((!state->identity.p1g) || (!state->identity.in_soc)
2062                         || ((state->identity.version != SOC_7090_P1G_21R1)
2063                                 && (state->identity.version != SOC_7090_P1G_11R1))) {
2064                 dprintk("%s() function can only be used for dib7090\n", __func__);
2065                 return -ENODEV;
2066         }
2067
2068         if (cfg_sensitivity)
2069                 tune = dib0090_tuning_table_cband_7090e_sensitivity;
2070         else
2071                 tune = dib0090_tuning_table_cband_7090e_aci;
2072
2073         while (state->rf_request > tune->max_freq)
2074                 tune++;
2075
2076         dib0090_write_reg(state, 0x09, (dib0090_read_reg(state, 0x09) & 0x8000)
2077                         | (tune->lna_bias & 0x7fff));
2078         dib0090_write_reg(state, 0x0b, (dib0090_read_reg(state, 0x0b) & 0xf83f)
2079                         | ((tune->lna_tune << 6) & 0x07c0));
2080         return 0;
2081 }
2082 EXPORT_SYMBOL(dib0090_update_tuning_table_7090);
2083
2084 static int dib0090_captrim_search(struct dib0090_state *state, enum frontend_tune_state *tune_state)
2085 {
2086         int ret = 0;
2087         u16 lo4 = 0xe900;
2088
2089         s16 adc_target;
2090         u16 adc;
2091         s8 step_sign;
2092         u8 force_soft_search = 0;
2093
2094         if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1)
2095                 force_soft_search = 1;
2096
2097         if (*tune_state == CT_TUNER_START) {
2098                 dprintk("Start Captrim search : %s\n",
2099                         (force_soft_search == 1) ? "FORCE SOFT SEARCH" : "AUTO");
2100                 dib0090_write_reg(state, 0x10, 0x2B1);
2101                 dib0090_write_reg(state, 0x1e, 0x0032);
2102
2103                 if (!state->tuner_is_tuned) {
2104                         /* prepare a complete captrim */
2105                         if (!state->identity.p1g || force_soft_search)
2106                                 state->step = state->captrim = state->fcaptrim = 64;
2107
2108                         state->current_rf = state->rf_request;
2109                 } else {        /* we are already tuned to this frequency - the configuration is correct  */
2110                         if (!state->identity.p1g || force_soft_search) {
2111                                 /* do a minimal captrim even if the frequency has not changed */
2112                                 state->step = 4;
2113                                 state->captrim = state->fcaptrim = dib0090_read_reg(state, 0x18) & 0x7f;
2114                         }
2115                 }
2116                 state->adc_diff = 3000;
2117                 *tune_state = CT_TUNER_STEP_0;
2118
2119         } else if (*tune_state == CT_TUNER_STEP_0) {
2120                 if (state->identity.p1g && !force_soft_search) {
2121                         u8 ratio = 31;
2122
2123                         dib0090_write_reg(state, 0x40, (3 << 7) | (ratio << 2) | (1 << 1) | 1);
2124                         dib0090_read_reg(state, 0x40);
2125                         ret = 50;
2126                 } else {
2127                         state->step /= 2;
2128                         dib0090_write_reg(state, 0x18, lo4 | state->captrim);
2129
2130                         if (state->identity.in_soc)
2131                                 ret = 25;
2132                 }
2133                 *tune_state = CT_TUNER_STEP_1;
2134
2135         } else if (*tune_state == CT_TUNER_STEP_1) {
2136                 if (state->identity.p1g && !force_soft_search) {
2137                         dib0090_write_reg(state, 0x40, 0x18c | (0 << 1) | 0);
2138                         dib0090_read_reg(state, 0x40);
2139
2140                         state->fcaptrim = dib0090_read_reg(state, 0x18) & 0x7F;
2141                         dprintk("***Final Captrim= 0x%x\n", state->fcaptrim);
2142                         *tune_state = CT_TUNER_STEP_3;
2143
2144                 } else {
2145                         /* MERGE for all krosus before P1G */
2146                         adc = dib0090_get_slow_adc_val(state);
2147                         dprintk("CAPTRIM=%d; ADC = %d (ADC) & %dmV\n", (u32) state->captrim, (u32) adc, (u32) (adc) * (u32) 1800 / (u32) 1024);
2148
2149                         if (state->rest == 0 || state->identity.in_soc) {       /* Just for 8090P SOCS where auto captrim HW bug : TO CHECK IN ACI for SOCS !!! if 400 for 8090p SOC => tune issue !!! */
2150                                 adc_target = 200;
2151                         } else
2152                                 adc_target = 400;
2153
2154                         if (adc >= adc_target) {
2155                                 adc -= adc_target;
2156                                 step_sign = -1;
2157                         } else {
2158                                 adc = adc_target - adc;
2159                                 step_sign = 1;
2160                         }
2161
2162                         if (adc < state->adc_diff) {
2163                                 dprintk("CAPTRIM=%d is closer to target (%d/%d)\n", (u32) state->captrim, (u32) adc, (u32) state->adc_diff);
2164                                 state->adc_diff = adc;
2165                                 state->fcaptrim = state->captrim;
2166                         }
2167
2168                         state->captrim += step_sign * state->step;
2169                         if (state->step >= 1)
2170                                 *tune_state = CT_TUNER_STEP_0;
2171                         else
2172                                 *tune_state = CT_TUNER_STEP_2;
2173
2174                         ret = 25;
2175                 }
2176         } else if (*tune_state == CT_TUNER_STEP_2) {    /* this step is only used by krosus < P1G */
2177                 /*write the final cptrim config */
2178                 dib0090_write_reg(state, 0x18, lo4 | state->fcaptrim);
2179
2180                 *tune_state = CT_TUNER_STEP_3;
2181
2182         } else if (*tune_state == CT_TUNER_STEP_3) {
2183                 state->calibrate &= ~CAPTRIM_CAL;
2184                 *tune_state = CT_TUNER_STEP_0;
2185         }
2186
2187         return ret;
2188 }
2189
2190 static int dib0090_get_temperature(struct dib0090_state *state, enum frontend_tune_state *tune_state)
2191 {
2192         int ret = 15;
2193         s16 val;
2194
2195         switch (*tune_state) {
2196         case CT_TUNER_START:
2197                 state->wbdmux = dib0090_read_reg(state, 0x10);
2198                 dib0090_write_reg(state, 0x10, (state->wbdmux & ~(0xff << 3)) | (0x8 << 3));
2199
2200                 state->bias = dib0090_read_reg(state, 0x13);
2201                 dib0090_write_reg(state, 0x13, state->bias | (0x3 << 8));
2202
2203                 *tune_state = CT_TUNER_STEP_0;
2204                 /* wait for the WBDMUX to switch and for the ADC to sample */
2205                 break;
2206
2207         case CT_TUNER_STEP_0:
2208                 state->adc_diff = dib0090_get_slow_adc_val(state);
2209                 dib0090_write_reg(state, 0x13, (state->bias & ~(0x3 << 8)) | (0x2 << 8));
2210                 *tune_state = CT_TUNER_STEP_1;
2211                 break;
2212
2213         case CT_TUNER_STEP_1:
2214                 val = dib0090_get_slow_adc_val(state);
2215                 state->temperature = ((s16) ((val - state->adc_diff) * 180) >> 8) + 55;
2216
2217                 dprintk("temperature: %d C\n", state->temperature - 30);
2218
2219                 *tune_state = CT_TUNER_STEP_2;
2220                 break;
2221
2222         case CT_TUNER_STEP_2:
2223                 dib0090_write_reg(state, 0x13, state->bias);
2224                 dib0090_write_reg(state, 0x10, state->wbdmux);  /* write back original WBDMUX */
2225
2226                 *tune_state = CT_TUNER_START;
2227                 state->calibrate &= ~TEMP_CAL;
2228                 if (state->config->analog_output == 0)
2229                         dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14));
2230
2231                 break;
2232
2233         default:
2234                 ret = 0;
2235                 break;
2236         }
2237         return ret;
2238 }
2239
2240 #define WBD     0x781           /* 1 1 1 1 0000 0 0 1 */
2241 static int dib0090_tune(struct dvb_frontend *fe)
2242 {
2243         struct dib0090_state *state = fe->tuner_priv;
2244         const struct dib0090_tuning *tune = state->current_tune_table_index;
2245         const struct dib0090_pll *pll = state->current_pll_table_index;
2246         enum frontend_tune_state *tune_state = &state->tune_state;
2247
2248         u16 lo5, lo6, Den, tmp;
2249         u32 FBDiv, Rest, FREF, VCOF_kHz = 0;
2250         int ret = 10;           /* 1ms is the default delay most of the time */
2251         u8 c, i;
2252
2253         /************************* VCO ***************************/
2254         /* Default values for FG                                 */
2255         /* from these are needed :                               */
2256         /* Cp,HFdiv,VCOband,SD,Num,Den,FB and REFDiv             */
2257
2258         /* in any case we first need to do a calibration if needed */
2259         if (*tune_state == CT_TUNER_START) {
2260                 /* deactivate DataTX before some calibrations */
2261                 if (state->calibrate & (DC_CAL | TEMP_CAL | WBD_CAL))
2262                         dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) & ~(1 << 14));
2263                 else
2264                         /* Activate DataTX in case a calibration has been done before */
2265                         if (state->config->analog_output == 0)
2266                                 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14));
2267         }
2268
2269         if (state->calibrate & DC_CAL)
2270                 return dib0090_dc_offset_calibration(state, tune_state);
2271         else if (state->calibrate & WBD_CAL) {
2272                 if (state->current_rf == 0)
2273                         state->current_rf = state->fe->dtv_property_cache.frequency / 1000;
2274                 return dib0090_wbd_calibration(state, tune_state);
2275         } else if (state->calibrate & TEMP_CAL)
2276                 return dib0090_get_temperature(state, tune_state);
2277         else if (state->calibrate & CAPTRIM_CAL)
2278                 return dib0090_captrim_search(state, tune_state);
2279
2280         if (*tune_state == CT_TUNER_START) {
2281                 /* if soc and AGC pwm control, disengage mux to be able to R/W access to 0x01 register to set the right filter (cutoff_freq_select) during the tune sequence, otherwise, SOC SERPAR error when accessing to 0x01 */
2282                 if (state->config->use_pwm_agc && state->identity.in_soc) {
2283                         tmp = dib0090_read_reg(state, 0x39);
2284                         if ((tmp >> 10) & 0x1)
2285                                 dib0090_write_reg(state, 0x39, tmp & ~(1 << 10));
2286                 }
2287
2288                 state->current_band = (u8) BAND_OF_FREQUENCY(state->fe->dtv_property_cache.frequency / 1000);
2289                 state->rf_request =
2290                         state->fe->dtv_property_cache.frequency / 1000 + (state->current_band ==
2291                                         BAND_UHF ? state->config->freq_offset_khz_uhf : state->config->
2292                                         freq_offset_khz_vhf);
2293
2294                 /* in ISDB-T 1seg we shift tuning frequency */
2295                 if ((state->fe->dtv_property_cache.delivery_system == SYS_ISDBT && state->fe->dtv_property_cache.isdbt_sb_mode == 1
2296                                         && state->fe->dtv_property_cache.isdbt_partial_reception == 0)) {
2297                         const struct dib0090_low_if_offset_table *LUT_offset = state->config->low_if;
2298                         u8 found_offset = 0;
2299                         u32 margin_khz = 100;
2300
2301                         if (LUT_offset != NULL) {
2302                                 while (LUT_offset->RF_freq != 0xffff) {
2303                                         if (((state->rf_request > (LUT_offset->RF_freq - margin_khz))
2304                                                                 && (state->rf_request < (LUT_offset->RF_freq + margin_khz)))
2305                                                         && LUT_offset->std == state->fe->dtv_property_cache.delivery_system) {
2306                                                 state->rf_request += LUT_offset->offset_khz;
2307                                                 found_offset = 1;
2308                                                 break;
2309                                         }
2310                                         LUT_offset++;
2311                                 }
2312                         }
2313
2314                         if (found_offset == 0)
2315                                 state->rf_request += 400;
2316                 }
2317                 if (state->current_rf != state->rf_request || (state->current_standard != state->fe->dtv_property_cache.delivery_system)) {
2318                         state->tuner_is_tuned = 0;
2319                         state->current_rf = 0;
2320                         state->current_standard = 0;
2321
2322                         tune = dib0090_tuning_table;
2323                         if (state->identity.p1g)
2324                                 tune = dib0090_p1g_tuning_table;
2325
2326                         tmp = (state->identity.version >> 5) & 0x7;
2327
2328                         if (state->identity.in_soc) {
2329                                 if (state->config->force_cband_input) { /* Use the CBAND input for all band */
2330                                         if (state->current_band & BAND_CBAND || state->current_band & BAND_FM || state->current_band & BAND_VHF
2331                                                         || state->current_band & BAND_UHF) {
2332                                                 state->current_band = BAND_CBAND;
2333                                                 if (state->config->is_dib7090e)
2334                                                         tune = dib0090_tuning_table_cband_7090e_sensitivity;
2335                                                 else
2336                                                         tune = dib0090_tuning_table_cband_7090;
2337                                         }
2338                                 } else {        /* Use the CBAND input for all band under UHF */
2339                                         if (state->current_band & BAND_CBAND || state->current_band & BAND_FM || state->current_band & BAND_VHF) {
2340                                                 state->current_band = BAND_CBAND;
2341                                                 if (state->config->is_dib7090e)
2342                                                         tune = dib0090_tuning_table_cband_7090e_sensitivity;
2343                                                 else
2344                                                         tune = dib0090_tuning_table_cband_7090;
2345                                         }
2346                                 }
2347                         } else
2348                          if (tmp == 0x4 || tmp == 0x7) {
2349                                 /* CBAND tuner version for VHF */
2350                                 if (state->current_band == BAND_FM || state->current_band == BAND_CBAND || state->current_band == BAND_VHF) {
2351                                         state->current_band = BAND_CBAND;       /* Force CBAND */
2352
2353                                         tune = dib0090_tuning_table_fm_vhf_on_cband;
2354                                         if (state->identity.p1g)
2355                                                 tune = dib0090_p1g_tuning_table_fm_vhf_on_cband;
2356                                 }
2357                         }
2358
2359                         pll = dib0090_pll_table;
2360                         if (state->identity.p1g)
2361                                 pll = dib0090_p1g_pll_table;
2362
2363                         /* Look for the interval */
2364                         while (state->rf_request > tune->max_freq)
2365                                 tune++;
2366                         while (state->rf_request > pll->max_freq)
2367                                 pll++;
2368
2369                         state->current_tune_table_index = tune;
2370                         state->current_pll_table_index = pll;
2371
2372                         dib0090_write_reg(state, 0x0b, 0xb800 | (tune->switch_trim));
2373
2374                         VCOF_kHz = (pll->hfdiv * state->rf_request) * 2;
2375
2376                         FREF = state->config->io.clock_khz;
2377                         if (state->config->fref_clock_ratio != 0)
2378                                 FREF /= state->config->fref_clock_ratio;
2379
2380                         FBDiv = (VCOF_kHz / pll->topresc / FREF);
2381                         Rest = (VCOF_kHz / pll->topresc) - FBDiv * FREF;
2382
2383                         if (Rest < LPF)
2384                                 Rest = 0;
2385                         else if (Rest < 2 * LPF)
2386                                 Rest = 2 * LPF;
2387                         else if (Rest > (FREF - LPF)) {
2388                                 Rest = 0;
2389                                 FBDiv += 1;
2390                         } else if (Rest > (FREF - 2 * LPF))
2391                                 Rest = FREF - 2 * LPF;
2392                         Rest = (Rest * 6528) / (FREF / 10);
2393                         state->rest = Rest;
2394
2395                         /* external loop filter, otherwise:
2396                          * lo5 = (0 << 15) | (0 << 12) | (0 << 11) | (3 << 9) | (4 << 6) | (3 << 4) | 4;
2397                          * lo6 = 0x0e34 */
2398
2399                         if (Rest == 0) {
2400                                 if (pll->vco_band)
2401                                         lo5 = 0x049f;
2402                                 else
2403                                         lo5 = 0x041f;
2404                         } else {
2405                                 if (pll->vco_band)
2406                                         lo5 = 0x049e;
2407                                 else if (state->config->analog_output)
2408                                         lo5 = 0x041d;
2409                                 else
2410                                         lo5 = 0x041c;
2411                         }
2412
2413                         if (state->identity.p1g) {      /* Bias is done automatically in P1G */
2414                                 if (state->identity.in_soc) {
2415                                         if (state->identity.version == SOC_8090_P1G_11R1)
2416                                                 lo5 = 0x46f;
2417                                         else
2418                                                 lo5 = 0x42f;
2419                                 } else
2420                                         lo5 = 0x42c;
2421                         }
2422
2423                         lo5 |= (pll->hfdiv_code << 11) | (pll->vco_band << 7);  /* bit 15 is the split to the slave, we do not do it here */
2424
2425                         if (!state->config->io.pll_int_loop_filt) {
2426                                 if (state->identity.in_soc)
2427                                         lo6 = 0xff98;
2428                                 else if (state->identity.p1g || (Rest == 0))
2429                                         lo6 = 0xfff8;
2430                                 else
2431                                         lo6 = 0xff28;
2432                         } else
2433                                 lo6 = (state->config->io.pll_int_loop_filt << 3);
2434
2435                         Den = 1;
2436
2437                         if (Rest > 0) {
2438                                 lo6 |= (1 << 2) | 2;
2439                                 Den = 255;
2440                         }
2441                         dib0090_write_reg(state, 0x15, (u16) FBDiv);
2442                         if (state->config->fref_clock_ratio != 0)
2443                                 dib0090_write_reg(state, 0x16, (Den << 8) | state->config->fref_clock_ratio);
2444                         else
2445                                 dib0090_write_reg(state, 0x16, (Den << 8) | 1);
2446                         dib0090_write_reg(state, 0x17, (u16) Rest);
2447                         dib0090_write_reg(state, 0x19, lo5);
2448                         dib0090_write_reg(state, 0x1c, lo6);
2449
2450                         lo6 = tune->tuner_enable;
2451                         if (state->config->analog_output)
2452                                 lo6 = (lo6 & 0xff9f) | 0x2;
2453
2454                         dib0090_write_reg(state, 0x24, lo6 | EN_LO | state->config->use_pwm_agc * EN_CRYSTAL);
2455
2456                 }
2457
2458                 state->current_rf = state->rf_request;
2459                 state->current_standard = state->fe->dtv_property_cache.delivery_system;
2460
2461                 ret = 20;
2462                 state->calibrate = CAPTRIM_CAL; /* captrim search now */
2463         }
2464
2465         else if (*tune_state == CT_TUNER_STEP_0) {      /* Warning : because of captrim cal, if you change this step, change it also in _cal.c file because it is the step following captrim cal state machine */
2466                 const struct dib0090_wbd_slope *wbd = state->current_wbd_table;
2467
2468                 while (state->current_rf / 1000 > wbd->max_freq)
2469                         wbd++;
2470
2471                 dib0090_write_reg(state, 0x1e, 0x07ff);
2472                 dprintk("Final Captrim: %d\n", (u32) state->fcaptrim);
2473                 dprintk("HFDIV code: %d\n", (u32) pll->hfdiv_code);
2474                 dprintk("VCO = %d\n", (u32) pll->vco_band);
2475                 dprintk("VCOF in kHz: %d ((%d*%d) << 1))\n", (u32) ((pll->hfdiv * state->rf_request) * 2), (u32) pll->hfdiv, (u32) state->rf_request);
2476                 dprintk("REFDIV: %d, FREF: %d\n", (u32) 1, (u32) state->config->io.clock_khz);
2477                 dprintk("FBDIV: %d, Rest: %d\n", (u32) dib0090_read_reg(state, 0x15), (u32) dib0090_read_reg(state, 0x17));
2478                 dprintk("Num: %d, Den: %d, SD: %d\n", (u32) dib0090_read_reg(state, 0x17), (u32) (dib0090_read_reg(state, 0x16) >> 8),
2479                         (u32) dib0090_read_reg(state, 0x1c) & 0x3);
2480
2481 #define WBD     0x781           /* 1 1 1 1 0000 0 0 1 */
2482                 c = 4;
2483                 i = 3;
2484
2485                 if (wbd->wbd_gain != 0)
2486                         c = wbd->wbd_gain;
2487
2488                 state->wbdmux = (c << 13) | (i << 11) | (WBD | (state->config->use_pwm_agc << 1));
2489                 dib0090_write_reg(state, 0x10, state->wbdmux);
2490
2491                 if ((tune->tuner_enable == EN_CAB) && state->identity.p1g) {
2492                         dprintk("P1G : The cable band is selected and lna_tune = %d\n", tune->lna_tune);
2493                         dib0090_write_reg(state, 0x09, tune->lna_bias);
2494                         dib0090_write_reg(state, 0x0b, 0xb800 | (tune->lna_tune << 6) | (tune->switch_trim));
2495                 } else
2496                         dib0090_write_reg(state, 0x09, (tune->lna_tune << 5) | tune->lna_bias);
2497
2498                 dib0090_write_reg(state, 0x0c, tune->v2i);
2499                 dib0090_write_reg(state, 0x0d, tune->mix);
2500                 dib0090_write_reg(state, 0x0e, tune->load);
2501                 *tune_state = CT_TUNER_STEP_1;
2502
2503         } else if (*tune_state == CT_TUNER_STEP_1) {
2504                 /* initialize the lt gain register */
2505                 state->rf_lt_def = 0x7c00;
2506
2507                 dib0090_set_bandwidth(state);
2508                 state->tuner_is_tuned = 1;
2509
2510                 state->calibrate |= WBD_CAL;
2511                 state->calibrate |= TEMP_CAL;
2512                 *tune_state = CT_TUNER_STOP;
2513         } else
2514                 ret = FE_CALLBACK_TIME_NEVER;
2515         return ret;
2516 }
2517
2518 static void dib0090_release(struct dvb_frontend *fe)
2519 {
2520         kfree(fe->tuner_priv);
2521         fe->tuner_priv = NULL;
2522 }
2523
2524 enum frontend_tune_state dib0090_get_tune_state(struct dvb_frontend *fe)
2525 {
2526         struct dib0090_state *state = fe->tuner_priv;
2527
2528         return state->tune_state;
2529 }
2530
2531 EXPORT_SYMBOL(dib0090_get_tune_state);
2532
2533 int dib0090_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
2534 {
2535         struct dib0090_state *state = fe->tuner_priv;
2536
2537         state->tune_state = tune_state;
2538         return 0;
2539 }
2540
2541 EXPORT_SYMBOL(dib0090_set_tune_state);
2542
2543 static int dib0090_get_frequency(struct dvb_frontend *fe, u32 * frequency)
2544 {
2545         struct dib0090_state *state = fe->tuner_priv;
2546
2547         *frequency = 1000 * state->current_rf;
2548         return 0;
2549 }
2550
2551 static int dib0090_set_params(struct dvb_frontend *fe)
2552 {
2553         struct dib0090_state *state = fe->tuner_priv;
2554         u32 ret;
2555
2556         state->tune_state = CT_TUNER_START;
2557
2558         do {
2559                 ret = dib0090_tune(fe);
2560                 if (ret == FE_CALLBACK_TIME_NEVER)
2561                         break;
2562
2563                 /*
2564                  * Despite dib0090_tune returns time at a 0.1 ms range,
2565                  * the actual sleep time depends on CONFIG_HZ. The worse case
2566                  * is when CONFIG_HZ=100. In such case, the minimum granularity
2567                  * is 10ms. On some real field tests, the tuner sometimes don't
2568                  * lock when this timer is lower than 10ms. So, enforce a 10ms
2569                  * granularity and use usleep_range() instead of msleep().
2570                  */
2571                 ret = 10 * (ret + 99)/100;
2572                 usleep_range(ret * 1000, (ret + 1) * 1000);
2573         } while (state->tune_state != CT_TUNER_STOP);
2574
2575         return 0;
2576 }
2577
2578 static const struct dvb_tuner_ops dib0090_ops = {
2579         .info = {
2580                  .name = "DiBcom DiB0090",
2581                  .frequency_min_hz  =  45 * MHz,
2582                  .frequency_max_hz  = 860 * MHz,
2583                  .frequency_step_hz =   1 * kHz,
2584                  },
2585         .release = dib0090_release,
2586
2587         .init = dib0090_wakeup,
2588         .sleep = dib0090_sleep,
2589         .set_params = dib0090_set_params,
2590         .get_frequency = dib0090_get_frequency,
2591 };
2592
2593 static const struct dvb_tuner_ops dib0090_fw_ops = {
2594         .info = {
2595                  .name = "DiBcom DiB0090",
2596                  .frequency_min_hz  =  45 * MHz,
2597                  .frequency_max_hz  = 860 * MHz,
2598                  .frequency_step_hz =   1 * kHz,
2599                  },
2600         .release = dib0090_release,
2601
2602         .init = NULL,
2603         .sleep = NULL,
2604         .set_params = NULL,
2605         .get_frequency = NULL,
2606 };
2607
2608 static const struct dib0090_wbd_slope dib0090_wbd_table_default[] = {
2609         {470, 0, 250, 0, 100, 4},
2610         {860, 51, 866, 21, 375, 4},
2611         {1700, 0, 800, 0, 850, 4},
2612         {2900, 0, 250, 0, 100, 6},
2613         {0xFFFF, 0, 0, 0, 0, 0},
2614 };
2615
2616 struct dvb_frontend *dib0090_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config)
2617 {
2618         struct dib0090_state *st = kzalloc(sizeof(struct dib0090_state), GFP_KERNEL);
2619         if (st == NULL)
2620                 return NULL;
2621
2622         st->config = config;
2623         st->i2c = i2c;
2624         st->fe = fe;
2625         mutex_init(&st->i2c_buffer_lock);
2626         fe->tuner_priv = st;
2627
2628         if (config->wbd == NULL)
2629                 st->current_wbd_table = dib0090_wbd_table_default;
2630         else
2631                 st->current_wbd_table = config->wbd;
2632
2633         if (dib0090_reset(fe) != 0)
2634                 goto free_mem;
2635
2636         pr_info("DiB0090: successfully identified\n");
2637         memcpy(&fe->ops.tuner_ops, &dib0090_ops, sizeof(struct dvb_tuner_ops));
2638
2639         return fe;
2640  free_mem:
2641         kfree(st);
2642         fe->tuner_priv = NULL;
2643         return NULL;
2644 }
2645
2646 EXPORT_SYMBOL(dib0090_register);
2647
2648 struct dvb_frontend *dib0090_fw_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config)
2649 {
2650         struct dib0090_fw_state *st = kzalloc(sizeof(struct dib0090_fw_state), GFP_KERNEL);
2651         if (st == NULL)
2652                 return NULL;
2653
2654         st->config = config;
2655         st->i2c = i2c;
2656         st->fe = fe;
2657         mutex_init(&st->i2c_buffer_lock);
2658         fe->tuner_priv = st;
2659
2660         if (dib0090_fw_reset_digital(fe, st->config) != 0)
2661                 goto free_mem;
2662
2663         dprintk("DiB0090 FW: successfully identified\n");
2664         memcpy(&fe->ops.tuner_ops, &dib0090_fw_ops, sizeof(struct dvb_tuner_ops));
2665
2666         return fe;
2667 free_mem:
2668         kfree(st);
2669         fe->tuner_priv = NULL;
2670         return NULL;
2671 }
2672 EXPORT_SYMBOL(dib0090_fw_register);
2673
2674 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2675 MODULE_AUTHOR("Olivier Grenie <olivier.grenie@parrot.com>");
2676 MODULE_DESCRIPTION("Driver for the DiBcom 0090 base-band RF Tuner");
2677 MODULE_LICENSE("GPL");