drivers/media/dvb-frontends/dib8000.c

   1 /*
   2  * Linux-DVB Driver for DiBcom's DiB8000 chip (ISDB-T).
   3  *
   4  * Copyright (C) 2009 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, version 2.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/i2c.h>
  16 #include <linux/mutex.h>
  17 #include <asm/div64.h>
  18
  19 #include <media/dvb_math.h>
  20
  21 #include <media/dvb_frontend.h>
  22
  23 #include "dib8000.h"
  24
  25 #define LAYER_ALL -1
  26 #define LAYER_A   1
  27 #define LAYER_B   2
  28 #define LAYER_C   3
  29
  30 #define MAX_NUMBER_OF_FRONTENDS 6
  31 /* #define DIB8000_AGC_FREEZE */
  32
  33 static int debug;
  34 module_param(debug, int, 0644);
  35 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
  36
  37 #define dprintk(fmt, arg...) do {                                       \
  38         if (debug)                                                      \
  39                 printk(KERN_DEBUG pr_fmt("%s: " fmt),                   \
  40                        __func__, ##arg);                                \
  41 } while (0)
  42
  43 struct i2c_device {
  44         struct i2c_adapter *adap;
  45         u8 addr;
  46         u8 *i2c_write_buffer;
  47         u8 *i2c_read_buffer;
  48         struct mutex *i2c_buffer_lock;
  49 };
  50
  51 enum param_loop_step {
  52         LOOP_TUNE_1,
  53         LOOP_TUNE_2
  54 };
  55
  56 enum dib8000_autosearch_step {
  57         AS_START = 0,
  58         AS_SEARCHING_FFT,
  59         AS_SEARCHING_GUARD,
  60         AS_DONE = 100,
  61 };
  62
  63 enum timeout_mode {
  64         SYMBOL_DEPENDENT_OFF = 0,
  65         SYMBOL_DEPENDENT_ON,
  66 };
  67
  68 struct dib8000_state {
  69         struct dib8000_config cfg;
  70
  71         struct i2c_device i2c;
  72
  73         struct dibx000_i2c_master i2c_master;
  74
  75         u16 wbd_ref;
  76
  77         u8 current_band;
  78         u32 current_bandwidth;
  79         struct dibx000_agc_config *current_agc;
  80         u32 timf;
  81         u32 timf_default;
  82
  83         u8 div_force_off:1;
  84         u8 div_state:1;
  85         u16 div_sync_wait;
  86
  87         u8 agc_state;
  88         u8 differential_constellation;
  89         u8 diversity_onoff;
  90
  91         s16 ber_monitored_layer;
  92         u16 gpio_dir;
  93         u16 gpio_val;
  94
  95         u16 revision;
  96         u8 isdbt_cfg_loaded;
  97         enum frontend_tune_state tune_state;
  98         s32 status;
  99
 100         struct dvb_frontend *fe[MAX_NUMBER_OF_FRONTENDS];
 101
 102         /* for the I2C transfer */
 103         struct i2c_msg msg[2];
 104         u8 i2c_write_buffer[4];
 105         u8 i2c_read_buffer[2];
 106         struct mutex i2c_buffer_lock;
 107         u8 input_mode_mpeg;
 108
 109         u16 tuner_enable;
 110         struct i2c_adapter dib8096p_tuner_adap;
 111         u16 current_demod_bw;
 112
 113         u16 seg_mask;
 114         u16 seg_diff_mask;
 115         u16 mode;
 116         u8 layer_b_nb_seg;
 117         u8 layer_c_nb_seg;
 118
 119         u8 channel_parameters_set;
 120         u16 autosearch_state;
 121         u16 found_nfft;
 122         u16 found_guard;
 123         u8 subchannel;
 124         u8 symbol_duration;
 125         unsigned long timeout;
 126         u8 longest_intlv_layer;
 127         u16 output_mode;
 128
 129         /* for DVBv5 stats */
 130         s64 init_ucb;
 131         unsigned long per_jiffies_stats;
 132         unsigned long ber_jiffies_stats;
 133         unsigned long ber_jiffies_stats_layer[3];
 134
 135 #ifdef DIB8000_AGC_FREEZE
 136         u16 agc1_max;
 137         u16 agc1_min;
 138         u16 agc2_max;
 139         u16 agc2_min;
 140 #endif
 141 };
 142
 143 enum dib8000_power_mode {
 144         DIB8000_POWER_ALL = 0,
 145         DIB8000_POWER_INTERFACE_ONLY,
 146 };
 147
 148 static u16 dib8000_i2c_read16(struct i2c_device *i2c, u16 reg)
 149 {
 150         u16 ret;
 151         struct i2c_msg msg[2] = {
 152                 {.addr = i2c->addr >> 1, .flags = 0, .len = 2},
 153                 {.addr = i2c->addr >> 1, .flags = I2C_M_RD, .len = 2},
 154         };
 155
 156         if (mutex_lock_interruptible(i2c->i2c_buffer_lock) < 0) {
 157                 dprintk("could not acquire lock\n");
 158                 return 0;
 159         }
 160
 161         msg[0].buf    = i2c->i2c_write_buffer;
 162         msg[0].buf[0] = reg >> 8;
 163         msg[0].buf[1] = reg & 0xff;
 164         msg[1].buf    = i2c->i2c_read_buffer;
 165
 166         if (i2c_transfer(i2c->adap, msg, 2) != 2)
 167                 dprintk("i2c read error on %d\n", reg);
 168
 169         ret = (msg[1].buf[0] << 8) | msg[1].buf[1];
 170         mutex_unlock(i2c->i2c_buffer_lock);
 171         return ret;
 172 }
 173
 174 static u16 __dib8000_read_word(struct dib8000_state *state, u16 reg)
 175 {
 176         u16 ret;
 177
 178         state->i2c_write_buffer[0] = reg >> 8;
 179         state->i2c_write_buffer[1] = reg & 0xff;
 180
 181         memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
 182         state->msg[0].addr = state->i2c.addr >> 1;
 183         state->msg[0].flags = 0;
 184         state->msg[0].buf = state->i2c_write_buffer;
 185         state->msg[0].len = 2;
 186         state->msg[1].addr = state->i2c.addr >> 1;
 187         state->msg[1].flags = I2C_M_RD;
 188         state->msg[1].buf = state->i2c_read_buffer;
 189         state->msg[1].len = 2;
 190
 191         if (i2c_transfer(state->i2c.adap, state->msg, 2) != 2)
 192                 dprintk("i2c read error on %d\n", reg);
 193
 194         ret = (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
 195
 196         return ret;
 197 }
 198
 199 static u16 dib8000_read_word(struct dib8000_state *state, u16 reg)
 200 {
 201         u16 ret;
 202
 203         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 204                 dprintk("could not acquire lock\n");
 205                 return 0;
 206         }
 207
 208         ret = __dib8000_read_word(state, reg);
 209
 210         mutex_unlock(&state->i2c_buffer_lock);
 211
 212         return ret;
 213 }
 214
 215 static u32 dib8000_read32(struct dib8000_state *state, u16 reg)
 216 {
 217         u16 rw[2];
 218
 219         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 220                 dprintk("could not acquire lock\n");
 221                 return 0;
 222         }
 223
 224         rw[0] = __dib8000_read_word(state, reg + 0);
 225         rw[1] = __dib8000_read_word(state, reg + 1);
 226
 227         mutex_unlock(&state->i2c_buffer_lock);
 228
 229         return ((rw[0] << 16) | (rw[1]));
 230 }
 231
 232 static int dib8000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
 233 {
 234         struct i2c_msg msg = {.addr = i2c->addr >> 1, .flags = 0, .len = 4};
 235         int ret = 0;
 236
 237         if (mutex_lock_interruptible(i2c->i2c_buffer_lock) < 0) {
 238                 dprintk("could not acquire lock\n");
 239                 return -EINVAL;
 240         }
 241
 242         msg.buf    = i2c->i2c_write_buffer;
 243         msg.buf[0] = (reg >> 8) & 0xff;
 244         msg.buf[1] = reg & 0xff;
 245         msg.buf[2] = (val >> 8) & 0xff;
 246         msg.buf[3] = val & 0xff;
 247
 248         ret = i2c_transfer(i2c->adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
 249         mutex_unlock(i2c->i2c_buffer_lock);
 250
 251         return ret;
 252 }
 253
 254 static int dib8000_write_word(struct dib8000_state *state, u16 reg, u16 val)
 255 {
 256         int ret;
 257
 258         if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
 259                 dprintk("could not acquire lock\n");
 260                 return -EINVAL;
 261         }
 262
 263         state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
 264         state->i2c_write_buffer[1] = reg & 0xff;
 265         state->i2c_write_buffer[2] = (val >> 8) & 0xff;
 266         state->i2c_write_buffer[3] = val & 0xff;
 267
 268         memset(&state->msg[0], 0, sizeof(struct i2c_msg));
 269         state->msg[0].addr = state->i2c.addr >> 1;
 270         state->msg[0].flags = 0;
 271         state->msg[0].buf = state->i2c_write_buffer;
 272         state->msg[0].len = 4;
 273
 274         ret = (i2c_transfer(state->i2c.adap, state->msg, 1) != 1 ?
 275                         -EREMOTEIO : 0);
 276         mutex_unlock(&state->i2c_buffer_lock);
 277
 278         return ret;
 279 }
 280
 281 static const s16 coeff_2k_sb_1seg_dqpsk[8] = {
 282         (769 << 5) | 0x0a, (745 << 5) | 0x03, (595 << 5) | 0x0d, (769 << 5) | 0x0a, (920 << 5) | 0x09, (784 << 5) | 0x02, (519 << 5) | 0x0c,
 283                 (920 << 5) | 0x09
 284 };
 285
 286 static const s16 coeff_2k_sb_1seg[8] = {
 287         (692 << 5) | 0x0b, (683 << 5) | 0x01, (519 << 5) | 0x09, (692 << 5) | 0x0b, 0 | 0x1f, 0 | 0x1f, 0 | 0x1f, 0 | 0x1f
 288 };
 289
 290 static const s16 coeff_2k_sb_3seg_0dqpsk_1dqpsk[8] = {
 291         (832 << 5) | 0x10, (912 << 5) | 0x05, (900 << 5) | 0x12, (832 << 5) | 0x10, (-931 << 5) | 0x0f, (912 << 5) | 0x04, (807 << 5) | 0x11,
 292                 (-931 << 5) | 0x0f
 293 };
 294
 295 static const s16 coeff_2k_sb_3seg_0dqpsk[8] = {
 296         (622 << 5) | 0x0c, (941 << 5) | 0x04, (796 << 5) | 0x10, (622 << 5) | 0x0c, (982 << 5) | 0x0c, (519 << 5) | 0x02, (572 << 5) | 0x0e,
 297                 (982 << 5) | 0x0c
 298 };
 299
 300 static const s16 coeff_2k_sb_3seg_1dqpsk[8] = {
 301         (699 << 5) | 0x14, (607 << 5) | 0x04, (944 << 5) | 0x13, (699 << 5) | 0x14, (-720 << 5) | 0x0d, (640 << 5) | 0x03, (866 << 5) | 0x12,
 302                 (-720 << 5) | 0x0d
 303 };
 304
 305 static const s16 coeff_2k_sb_3seg[8] = {
 306         (664 << 5) | 0x0c, (925 << 5) | 0x03, (937 << 5) | 0x10, (664 << 5) | 0x0c, (-610 << 5) | 0x0a, (697 << 5) | 0x01, (836 << 5) | 0x0e,
 307                 (-610 << 5) | 0x0a
 308 };
 309
 310 static const s16 coeff_4k_sb_1seg_dqpsk[8] = {
 311         (-955 << 5) | 0x0e, (687 << 5) | 0x04, (818 << 5) | 0x10, (-955 << 5) | 0x0e, (-922 << 5) | 0x0d, (750 << 5) | 0x03, (665 << 5) | 0x0f,
 312                 (-922 << 5) | 0x0d
 313 };
 314
 315 static const s16 coeff_4k_sb_1seg[8] = {
 316         (638 << 5) | 0x0d, (683 << 5) | 0x02, (638 << 5) | 0x0d, (638 << 5) | 0x0d, (-655 << 5) | 0x0a, (517 << 5) | 0x00, (698 << 5) | 0x0d,
 317                 (-655 << 5) | 0x0a
 318 };
 319
 320 static const s16 coeff_4k_sb_3seg_0dqpsk_1dqpsk[8] = {
 321         (-707 << 5) | 0x14, (910 << 5) | 0x06, (889 << 5) | 0x16, (-707 << 5) | 0x14, (-958 << 5) | 0x13, (993 << 5) | 0x05, (523 << 5) | 0x14,
 322                 (-958 << 5) | 0x13
 323 };
 324
 325 static const s16 coeff_4k_sb_3seg_0dqpsk[8] = {
 326         (-723 << 5) | 0x13, (910 << 5) | 0x05, (777 << 5) | 0x14, (-723 << 5) | 0x13, (-568 << 5) | 0x0f, (547 << 5) | 0x03, (696 << 5) | 0x12,
 327                 (-568 << 5) | 0x0f
 328 };
 329
 330 static const s16 coeff_4k_sb_3seg_1dqpsk[8] = {
 331         (-940 << 5) | 0x15, (607 << 5) | 0x05, (915 << 5) | 0x16, (-940 << 5) | 0x15, (-848 << 5) | 0x13, (683 << 5) | 0x04, (543 << 5) | 0x14,
 332                 (-848 << 5) | 0x13
 333 };
 334
 335 static const s16 coeff_4k_sb_3seg[8] = {
 336         (612 << 5) | 0x12, (910 << 5) | 0x04, (864 << 5) | 0x14, (612 << 5) | 0x12, (-869 << 5) | 0x13, (683 << 5) | 0x02, (869 << 5) | 0x12,
 337                 (-869 << 5) | 0x13
 338 };
 339
 340 static const s16 coeff_8k_sb_1seg_dqpsk[8] = {
 341         (-835 << 5) | 0x12, (684 << 5) | 0x05, (735 << 5) | 0x14, (-835 << 5) | 0x12, (-598 << 5) | 0x10, (781 << 5) | 0x04, (739 << 5) | 0x13,
 342                 (-598 << 5) | 0x10
 343 };
 344
 345 static const s16 coeff_8k_sb_1seg[8] = {
 346         (673 << 5) | 0x0f, (683 << 5) | 0x03, (808 << 5) | 0x12, (673 << 5) | 0x0f, (585 << 5) | 0x0f, (512 << 5) | 0x01, (780 << 5) | 0x0f,
 347                 (585 << 5) | 0x0f
 348 };
 349
 350 static const s16 coeff_8k_sb_3seg_0dqpsk_1dqpsk[8] = {
 351         (863 << 5) | 0x17, (930 << 5) | 0x07, (878 << 5) | 0x19, (863 << 5) | 0x17, (0 << 5) | 0x14, (521 << 5) | 0x05, (980 << 5) | 0x18,
 352                 (0 << 5) | 0x14
 353 };
 354
 355 static const s16 coeff_8k_sb_3seg_0dqpsk[8] = {
 356         (-924 << 5) | 0x17, (910 << 5) | 0x06, (774 << 5) | 0x17, (-924 << 5) | 0x17, (-877 << 5) | 0x15, (565 << 5) | 0x04, (553 << 5) | 0x15,
 357                 (-877 << 5) | 0x15
 358 };
 359
 360 static const s16 coeff_8k_sb_3seg_1dqpsk[8] = {
 361         (-921 << 5) | 0x19, (607 << 5) | 0x06, (881 << 5) | 0x19, (-921 << 5) | 0x19, (-921 << 5) | 0x14, (713 << 5) | 0x05, (1018 << 5) | 0x18,
 362                 (-921 << 5) | 0x14
 363 };
 364
 365 static const s16 coeff_8k_sb_3seg[8] = {
 366         (514 << 5) | 0x14, (910 << 5) | 0x05, (861 << 5) | 0x17, (514 << 5) | 0x14, (690 << 5) | 0x14, (683 << 5) | 0x03, (662 << 5) | 0x15,
 367                 (690 << 5) | 0x14
 368 };
 369
 370 static const s16 ana_fe_coeff_3seg[24] = {
 371         81, 80, 78, 74, 68, 61, 54, 45, 37, 28, 19, 11, 4, 1022, 1017, 1013, 1010, 1008, 1008, 1008, 1008, 1010, 1014, 1017
 372 };
 373
 374 static const s16 ana_fe_coeff_1seg[24] = {
 375         249, 226, 164, 82, 5, 981, 970, 988, 1018, 20, 31, 26, 8, 1012, 1000, 1018, 1012, 8, 15, 14, 9, 3, 1017, 1003
 376 };
 377
 378 static const s16 ana_fe_coeff_13seg[24] = {
 379         396, 305, 105, -51, -77, -12, 41, 31, -11, -30, -11, 14, 15, -2, -13, -7, 5, 8, 1, -6, -7, -3, 0, 1
 380 };
 381
 382 static u16 fft_to_mode(struct dib8000_state *state)
 383 {
 384         u16 mode;
 385         switch (state->fe[0]->dtv_property_cache.transmission_mode) {
 386         case TRANSMISSION_MODE_2K:
 387                 mode = 1;
 388                 break;
 389         case TRANSMISSION_MODE_4K:
 390                 mode = 2;
 391                 break;
 392         default:
 393         case TRANSMISSION_MODE_AUTO:
 394         case TRANSMISSION_MODE_8K:
 395                 mode = 3;
 396                 break;
 397         }
 398         return mode;
 399 }
 400
 401 static void dib8000_set_acquisition_mode(struct dib8000_state *state)
 402 {
 403         u16 nud = dib8000_read_word(state, 298);
 404         nud |= (1 << 3) | (1 << 0);
 405         dprintk("acquisition mode activated\n");
 406         dib8000_write_word(state, 298, nud);
 407 }
 408 static int dib8000_set_output_mode(struct dvb_frontend *fe, int mode)
 409 {
 410         struct dib8000_state *state = fe->demodulator_priv;
 411         u16 outreg, fifo_threshold, smo_mode, sram = 0x0205;    /* by default SDRAM deintlv is enabled */
 412
 413         state->output_mode = mode;
 414         outreg = 0;
 415         fifo_threshold = 1792;
 416         smo_mode = (dib8000_read_word(state, 299) & 0x0050) | (1 << 1);
 417
 418         dprintk("-I-    Setting output mode for demod %p to %d\n",
 419                         &state->fe[0], mode);
 420
 421         switch (mode) {
 422         case OUTMODE_MPEG2_PAR_GATED_CLK:       // STBs with parallel gated clock
 423                 outreg = (1 << 10);     /* 0x0400 */
 424                 break;
 425         case OUTMODE_MPEG2_PAR_CONT_CLK:        // STBs with parallel continues clock
 426                 outreg = (1 << 10) | (1 << 6);  /* 0x0440 */
 427                 break;
 428         case OUTMODE_MPEG2_SERIAL:      // STBs with serial input
 429                 outreg = (1 << 10) | (2 << 6) | (0 << 1);       /* 0x0482 */
 430                 break;
 431         case OUTMODE_DIVERSITY:
 432                 if (state->cfg.hostbus_diversity) {
 433                         outreg = (1 << 10) | (4 << 6);  /* 0x0500 */
 434                         sram &= 0xfdff;
 435                 } else
 436                         sram |= 0x0c00;
 437                 break;
 438         case OUTMODE_MPEG2_FIFO:        // e.g. USB feeding
 439                 smo_mode |= (3 << 1);
 440                 fifo_threshold = 512;
 441                 outreg = (1 << 10) | (5 << 6);
 442                 break;
 443         case OUTMODE_HIGH_Z:    // disable
 444                 outreg = 0;
 445                 break;
 446
 447         case OUTMODE_ANALOG_ADC:
 448                 outreg = (1 << 10) | (3 << 6);
 449                 dib8000_set_acquisition_mode(state);
 450                 break;
 451
 452         default:
 453                 dprintk("Unhandled output_mode passed to be set for demod %p\n",
 454                                 &state->fe[0]);
 455                 return -EINVAL;
 456         }
 457
 458         if (state->cfg.output_mpeg2_in_188_bytes)
 459                 smo_mode |= (1 << 5);
 460
 461         dib8000_write_word(state, 299, smo_mode);
 462         dib8000_write_word(state, 300, fifo_threshold); /* synchronous fread */
 463         dib8000_write_word(state, 1286, outreg);
 464         dib8000_write_word(state, 1291, sram);
 465
 466         return 0;
 467 }
 468
 469 static int dib8000_set_diversity_in(struct dvb_frontend *fe, int onoff)
 470 {
 471         struct dib8000_state *state = fe->demodulator_priv;
 472         u16 tmp, sync_wait = dib8000_read_word(state, 273) & 0xfff0;
 473
 474         dprintk("set diversity input to %i\n", onoff);
 475         if (!state->differential_constellation) {
 476                 dib8000_write_word(state, 272, 1 << 9); //dvsy_off_lmod4 = 1
 477                 dib8000_write_word(state, 273, sync_wait | (1 << 2) | 2);       // sync_enable = 1; comb_mode = 2
 478         } else {
 479                 dib8000_write_word(state, 272, 0);      //dvsy_off_lmod4 = 0
 480                 dib8000_write_word(state, 273, sync_wait);      // sync_enable = 0; comb_mode = 0
 481         }
 482         state->diversity_onoff = onoff;
 483
 484         switch (onoff) {
 485         case 0:         /* only use the internal way - not the diversity input */
 486                 dib8000_write_word(state, 270, 1);
 487                 dib8000_write_word(state, 271, 0);
 488                 break;
 489         case 1:         /* both ways */
 490                 dib8000_write_word(state, 270, 6);
 491                 dib8000_write_word(state, 271, 6);
 492                 break;
 493         case 2:         /* only the diversity input */
 494                 dib8000_write_word(state, 270, 0);
 495                 dib8000_write_word(state, 271, 1);
 496                 break;
 497         }
 498
 499         if (state->revision == 0x8002) {
 500                 tmp = dib8000_read_word(state, 903);
 501                 dib8000_write_word(state, 903, tmp & ~(1 << 3));
 502                 msleep(30);
 503                 dib8000_write_word(state, 903, tmp | (1 << 3));
 504         }
 505         return 0;
 506 }
 507
 508 static void dib8000_set_power_mode(struct dib8000_state *state, enum dib8000_power_mode mode)
 509 {
 510         /* by default everything is going to be powered off */
 511         u16 reg_774 = 0x3fff, reg_775 = 0xffff, reg_776 = 0xffff,
 512                 reg_900 = (dib8000_read_word(state, 900) & 0xfffc) | 0x3,
 513                 reg_1280;
 514
 515         if (state->revision != 0x8090)
 516                 reg_1280 = (dib8000_read_word(state, 1280) & 0x00ff) | 0xff00;
 517         else
 518                 reg_1280 = (dib8000_read_word(state, 1280) & 0x707f) | 0x8f80;
 519
 520         /* now, depending on the requested mode, we power on */
 521         switch (mode) {
 522                 /* power up everything in the demod */
 523         case DIB8000_POWER_ALL:
 524                 reg_774 = 0x0000;
 525                 reg_775 = 0x0000;
 526                 reg_776 = 0x0000;
 527                 reg_900 &= 0xfffc;
 528                 if (state->revision != 0x8090)
 529                         reg_1280 &= 0x00ff;
 530                 else
 531                         reg_1280 &= 0x707f;
 532                 break;
 533         case DIB8000_POWER_INTERFACE_ONLY:
 534                 if (state->revision != 0x8090)
 535                         reg_1280 &= 0x00ff;
 536                 else
 537                         reg_1280 &= 0xfa7b;
 538                 break;
 539         }
 540
 541         dprintk("powermode : 774 : %x ; 775 : %x; 776 : %x ; 900 : %x; 1280 : %x\n", reg_774, reg_775, reg_776, reg_900, reg_1280);
 542         dib8000_write_word(state, 774, reg_774);
 543         dib8000_write_word(state, 775, reg_775);
 544         dib8000_write_word(state, 776, reg_776);
 545         dib8000_write_word(state, 900, reg_900);
 546         dib8000_write_word(state, 1280, reg_1280);
 547 }
 548
 549 static int dib8000_set_adc_state(struct dib8000_state *state, enum dibx000_adc_states no)
 550 {
 551         int ret = 0;
 552         u16 reg, reg_907 = dib8000_read_word(state, 907);
 553         u16 reg_908 = dib8000_read_word(state, 908);
 554
 555         switch (no) {
 556         case DIBX000_SLOW_ADC_ON:
 557                 if (state->revision != 0x8090) {
 558                         reg_908 |= (1 << 1) | (1 << 0);
 559                         ret |= dib8000_write_word(state, 908, reg_908);
 560                         reg_908 &= ~(1 << 1);
 561                 } else {
 562                         reg = dib8000_read_word(state, 1925);
 563                         /* en_slowAdc = 1 & reset_sladc = 1 */
 564                         dib8000_write_word(state, 1925, reg |
 565                                         (1<<4) | (1<<2));
 566
 567                         /* read access to make it works... strange ... */
 568                         reg = dib8000_read_word(state, 1925);
 569                         msleep(20);
 570                         /* en_slowAdc = 1 & reset_sladc = 0 */
 571                         dib8000_write_word(state, 1925, reg & ~(1<<4));
 572
 573                         reg = dib8000_read_word(state, 921) & ~((0x3 << 14)
 574                                         | (0x3 << 12));
 575                         /* ref = Vin1 => Vbg ; sel = Vin0 or Vin3 ;
 576                            (Vin2 = Vcm) */
 577                         dib8000_write_word(state, 921, reg | (1 << 14)
 578                                         | (3 << 12));
 579                 }
 580                 break;
 581
 582         case DIBX000_SLOW_ADC_OFF:
 583                 if (state->revision == 0x8090) {
 584                         reg = dib8000_read_word(state, 1925);
 585                         /* reset_sladc = 1 en_slowAdc = 0 */
 586                         dib8000_write_word(state, 1925,
 587                                         (reg & ~(1<<2)) | (1<<4));
 588                 }
 589                 reg_908 |= (1 << 1) | (1 << 0);
 590                 break;
 591
 592         case DIBX000_ADC_ON:
 593                 reg_907 &= 0x0fff;
 594                 reg_908 &= 0x0003;
 595                 break;
 596
 597         case DIBX000_ADC_OFF:   // leave the VBG voltage on
 598                 reg_907 = (1 << 13) | (1 << 12);
 599                 reg_908 = (1 << 6) | (1 << 5) | (1 << 4) | (1 << 3) | (1 << 1);
 600                 break;
 601
 602         case DIBX000_VBG_ENABLE:
 603                 reg_907 &= ~(1 << 15);
 604                 break;
 605
 606         case DIBX000_VBG_DISABLE:
 607                 reg_907 |= (1 << 15);
 608                 break;
 609
 610         default:
 611                 break;
 612         }
 613
 614         ret |= dib8000_write_word(state, 907, reg_907);
 615         ret |= dib8000_write_word(state, 908, reg_908);
 616
 617         return ret;
 618 }
 619
 620 static int dib8000_set_bandwidth(struct dvb_frontend *fe, u32 bw)
 621 {
 622         struct dib8000_state *state = fe->demodulator_priv;
 623         u32 timf;
 624
 625         if (bw == 0)
 626                 bw = 6000;
 627
 628         if (state->timf == 0) {
 629                 dprintk("using default timf\n");
 630                 timf = state->timf_default;
 631         } else {
 632                 dprintk("using updated timf\n");
 633                 timf = state->timf;
 634         }
 635
 636         dib8000_write_word(state, 29, (u16) ((timf >> 16) & 0xffff));
 637         dib8000_write_word(state, 30, (u16) ((timf) & 0xffff));
 638
 639         return 0;
 640 }
 641
 642 static int dib8000_sad_calib(struct dib8000_state *state)
 643 {
 644         u8 sad_sel = 3;
 645
 646         if (state->revision == 0x8090) {
 647                 dib8000_write_word(state, 922, (sad_sel << 2));
 648                 dib8000_write_word(state, 923, 2048);
 649
 650                 dib8000_write_word(state, 922, (sad_sel << 2) | 0x1);
 651                 dib8000_write_word(state, 922, (sad_sel << 2));
 652         } else {
 653                 /* internal */
 654                 dib8000_write_word(state, 923, (0 << 1) | (0 << 0));
 655                 dib8000_write_word(state, 924, 776);
 656
 657                 /* do the calibration */
 658                 dib8000_write_word(state, 923, (1 << 0));
 659                 dib8000_write_word(state, 923, (0 << 0));
 660         }
 661
 662         msleep(1);
 663         return 0;
 664 }
 665
 666 static int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
 667 {
 668         struct dib8000_state *state = fe->demodulator_priv;
 669         if (value > 4095)
 670                 value = 4095;
 671         state->wbd_ref = value;
 672         return dib8000_write_word(state, 106, value);
 673 }
 674
 675 static void dib8000_reset_pll_common(struct dib8000_state *state, const struct dibx000_bandwidth_config *bw)
 676 {
 677         dprintk("ifreq: %d %x, inversion: %d\n", bw->ifreq, bw->ifreq, bw->ifreq >> 25);
 678         if (state->revision != 0x8090) {
 679                 dib8000_write_word(state, 23,
 680                                 (u16) (((bw->internal * 1000) >> 16) & 0xffff));
 681                 dib8000_write_word(state, 24,
 682                                 (u16) ((bw->internal * 1000) & 0xffff));
 683         } else {
 684                 dib8000_write_word(state, 23, (u16) (((bw->internal / 2 * 1000) >> 16) & 0xffff));
 685                 dib8000_write_word(state, 24,
 686                                 (u16) ((bw->internal  / 2 * 1000) & 0xffff));
 687         }
 688         dib8000_write_word(state, 27, (u16) ((bw->ifreq >> 16) & 0x01ff));
 689         dib8000_write_word(state, 28, (u16) (bw->ifreq & 0xffff));
 690         dib8000_write_word(state, 26, (u16) ((bw->ifreq >> 25) & 0x0003));
 691
 692         if (state->revision != 0x8090)
 693                 dib8000_write_word(state, 922, bw->sad_cfg);
 694 }
 695
 696 static void dib8000_reset_pll(struct dib8000_state *state)
 697 {
 698         const struct dibx000_bandwidth_config *pll = state->cfg.pll;
 699         u16 clk_cfg1, reg;
 700
 701         if (state->revision != 0x8090) {
 702                 dib8000_write_word(state, 901,
 703                                 (pll->pll_prediv << 8) | (pll->pll_ratio << 0));
 704
 705                 clk_cfg1 = (1 << 10) | (0 << 9) | (pll->IO_CLK_en_core << 8) |
 706                         (pll->bypclk_div << 5) | (pll->enable_refdiv << 4) |
 707                         (1 << 3) | (pll->pll_range << 1) |
 708                         (pll->pll_reset << 0);
 709
 710                 dib8000_write_word(state, 902, clk_cfg1);
 711                 clk_cfg1 = (clk_cfg1 & 0xfff7) | (pll->pll_bypass << 3);
 712                 dib8000_write_word(state, 902, clk_cfg1);
 713
 714                 dprintk("clk_cfg1: 0x%04x\n", clk_cfg1);
 715
 716                 /* smpl_cfg: P_refclksel=2, P_ensmplsel=1 nodivsmpl=1 */
 717                 if (state->cfg.pll->ADClkSrc == 0)
 718                         dib8000_write_word(state, 904,
 719                                         (0 << 15) | (0 << 12) | (0 << 10) |
 720                                         (pll->modulo << 8) |
 721                                         (pll->ADClkSrc << 7) | (0 << 1));
 722                 else if (state->cfg.refclksel != 0)
 723                         dib8000_write_word(state, 904, (0 << 15) | (1 << 12) |
 724                                         ((state->cfg.refclksel & 0x3) << 10) |
 725                                         (pll->modulo << 8) |
 726                                         (pll->ADClkSrc << 7) | (0 << 1));
 727                 else
 728                         dib8000_write_word(state, 904, (0 << 15) | (1 << 12) |
 729                                         (3 << 10) | (pll->modulo << 8) |
 730                                         (pll->ADClkSrc << 7) | (0 << 1));
 731         } else {
 732                 dib8000_write_word(state, 1856, (!pll->pll_reset<<13) |
 733                                 (pll->pll_range<<12) | (pll->pll_ratio<<6) |
 734                                 (pll->pll_prediv));
 735
 736                 reg = dib8000_read_word(state, 1857);
 737                 dib8000_write_word(state, 1857, reg|(!pll->pll_bypass<<15));
 738
 739                 reg = dib8000_read_word(state, 1858); /* Force clk out pll /2 */
 740                 dib8000_write_word(state, 1858, reg | 1);
 741
 742                 dib8000_write_word(state, 904, (pll->modulo << 8));
 743         }
 744
 745         dib8000_reset_pll_common(state, pll);
 746 }
 747
 748 static int dib8000_update_pll(struct dvb_frontend *fe,
 749                 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio)
 750 {
 751         struct dib8000_state *state = fe->demodulator_priv;
 752         u16 reg_1857, reg_1856 = dib8000_read_word(state, 1856);
 753         u8 loopdiv, prediv, oldprediv = state->cfg.pll->pll_prediv ;
 754         u32 internal, xtal;
 755
 756         /* get back old values */
 757         prediv = reg_1856 & 0x3f;
 758         loopdiv = (reg_1856 >> 6) & 0x3f;
 759
 760         if ((pll == NULL) || (pll->pll_prediv == prediv &&
 761                                 pll->pll_ratio == loopdiv))
 762                 return -EINVAL;
 763
 764         dprintk("Updating pll (prediv: old =  %d new = %d ; loopdiv : old = %d new = %d)\n", prediv, pll->pll_prediv, loopdiv, pll->pll_ratio);
 765         if (state->revision == 0x8090) {
 766                 reg_1856 &= 0xf000;
 767                 reg_1857 = dib8000_read_word(state, 1857);
 768                 /* disable PLL */
 769                 dib8000_write_word(state, 1857, reg_1857 & ~(1 << 15));
 770
 771                 dib8000_write_word(state, 1856, reg_1856 |
 772                                 ((pll->pll_ratio & 0x3f) << 6) |
 773                                 (pll->pll_prediv & 0x3f));
 774
 775                 /* write new system clk into P_sec_len */
 776                 internal = dib8000_read32(state, 23) / 1000;
 777                 dprintk("Old Internal = %d\n", internal);
 778                 xtal = 2 * (internal / loopdiv) * prediv;
 779                 internal = 1000 * (xtal/pll->pll_prediv) * pll->pll_ratio;
 780                 dprintk("Xtal = %d , New Fmem = %d New Fdemod = %d, New Fsampling = %d\n", xtal, internal/1000, internal/2000, internal/8000);
 781                 dprintk("New Internal = %d\n", internal);
 782
 783                 dib8000_write_word(state, 23,
 784                                 (u16) (((internal / 2) >> 16) & 0xffff));
 785                 dib8000_write_word(state, 24, (u16) ((internal / 2) & 0xffff));
 786                 /* enable PLL */
 787                 dib8000_write_word(state, 1857, reg_1857 | (1 << 15));
 788
 789                 while (((dib8000_read_word(state, 1856)>>15)&0x1) != 1)
 790                         dprintk("Waiting for PLL to lock\n");
 791
 792                 /* verify */
 793                 reg_1856 = dib8000_read_word(state, 1856);
 794                 dprintk("PLL Updated with prediv = %d and loopdiv = %d\n",
 795                                 reg_1856&0x3f, (reg_1856>>6)&0x3f);
 796         } else {
 797                 if (bw != state->current_demod_bw) {
 798                         /** Bandwidth change => force PLL update **/
 799                         dprintk("PLL: Bandwidth Change %d MHz -> %d MHz (prediv: %d->%d)\n", state->current_demod_bw / 1000, bw / 1000, oldprediv, state->cfg.pll->pll_prediv);
 800
 801                         if (state->cfg.pll->pll_prediv != oldprediv) {
 802                                 /** Full PLL change only if prediv is changed **/
 803
 804                                 /** full update => bypass and reconfigure **/
 805                                 dprintk("PLL: New Setting for %d MHz Bandwidth (prediv: %d, ratio: %d)\n", bw/1000, state->cfg.pll->pll_prediv, state->cfg.pll->pll_ratio);
 806                                 dib8000_write_word(state, 902, dib8000_read_word(state, 902) | (1<<3)); /* bypass PLL */
 807                                 dib8000_reset_pll(state);
 808                                 dib8000_write_word(state, 898, 0x0004); /* sad */
 809                         } else
 810                                 ratio = state->cfg.pll->pll_ratio;
 811
 812                         state->current_demod_bw = bw;
 813                 }
 814
 815                 if (ratio != 0) {
 816                         /** ratio update => only change ratio **/
 817                         dprintk("PLL: Update ratio (prediv: %d, ratio: %d)\n", state->cfg.pll->pll_prediv, ratio);
 818                         dib8000_write_word(state, 901, (state->cfg.pll->pll_prediv << 8) | (ratio << 0)); /* only the PLL ratio is updated. */
 819                 }
 820         }
 821
 822         return 0;
 823 }
 824
 825 static int dib8000_reset_gpio(struct dib8000_state *st)
 826 {
 827         /* reset the GPIOs */
 828         dib8000_write_word(st, 1029, st->cfg.gpio_dir);
 829         dib8000_write_word(st, 1030, st->cfg.gpio_val);
 830
 831         /* TODO 782 is P_gpio_od */
 832
 833         dib8000_write_word(st, 1032, st->cfg.gpio_pwm_pos);
 834
 835         dib8000_write_word(st, 1037, st->cfg.pwm_freq_div);
 836         return 0;
 837 }
 838
 839 static int dib8000_cfg_gpio(struct dib8000_state *st, u8 num, u8 dir, u8 val)
 840 {
 841         st->cfg.gpio_dir = dib8000_read_word(st, 1029);
 842         st->cfg.gpio_dir &= ~(1 << num);        /* reset the direction bit */
 843         st->cfg.gpio_dir |= (dir & 0x1) << num; /* set the new direction */
 844         dib8000_write_word(st, 1029, st->cfg.gpio_dir);
 845
 846         st->cfg.gpio_val = dib8000_read_word(st, 1030);
 847         st->cfg.gpio_val &= ~(1 << num);        /* reset the direction bit */
 848         st->cfg.gpio_val |= (val & 0x01) << num;        /* set the new value */
 849         dib8000_write_word(st, 1030, st->cfg.gpio_val);
 850
 851         dprintk("gpio dir: %x: gpio val: %x\n", st->cfg.gpio_dir, st->cfg.gpio_val);
 852
 853         return 0;
 854 }
 855
 856 static int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
 857 {
 858         struct dib8000_state *state = fe->demodulator_priv;
 859         return dib8000_cfg_gpio(state, num, dir, val);
 860 }
 861
 862 static const u16 dib8000_defaults[] = {
 863         /* auto search configuration - lock0 by default waiting
 864          * for cpil_lock; lock1 cpil_lock; lock2 tmcc_sync_lock */
 865         3, 7,
 866         0x0004,
 867         0x0400,
 868         0x0814,
 869
 870         12, 11,
 871         0x001b,
 872         0x7740,
 873         0x005b,
 874         0x8d80,
 875         0x01c9,
 876         0xc380,
 877         0x0000,
 878         0x0080,
 879         0x0000,
 880         0x0090,
 881         0x0001,
 882         0xd4c0,
 883
 884         /*1, 32,
 885                 0x6680 // P_corm_thres Lock algorithms configuration */
 886
 887         11, 80,                 /* set ADC level to -16 */
 888         (1 << 13) - 825 - 117,
 889         (1 << 13) - 837 - 117,
 890         (1 << 13) - 811 - 117,
 891         (1 << 13) - 766 - 117,
 892         (1 << 13) - 737 - 117,
 893         (1 << 13) - 693 - 117,
 894         (1 << 13) - 648 - 117,
 895         (1 << 13) - 619 - 117,
 896         (1 << 13) - 575 - 117,
 897         (1 << 13) - 531 - 117,
 898         (1 << 13) - 501 - 117,
 899
 900         4, 108,
 901         0,
 902         0,
 903         0,
 904         0,
 905
 906         1, 175,
 907         0x0410,
 908         1, 179,
 909         8192,                   // P_fft_nb_to_cut
 910
 911         6, 181,
 912         0x2800,                 // P_coff_corthres_ ( 2k 4k 8k ) 0x2800
 913         0x2800,
 914         0x2800,
 915         0x2800,                 // P_coff_cpilthres_ ( 2k 4k 8k ) 0x2800
 916         0x2800,
 917         0x2800,
 918
 919         2, 193,
 920         0x0666,                 // P_pha3_thres
 921         0x0000,                 // P_cti_use_cpe, P_cti_use_prog
 922
 923         2, 205,
 924         0x200f,                 // P_cspu_regul, P_cspu_win_cut
 925         0x000f,                 // P_des_shift_work
 926
 927         5, 215,
 928         0x023d,                 // P_adp_regul_cnt
 929         0x00a4,                 // P_adp_noise_cnt
 930         0x00a4,                 // P_adp_regul_ext
 931         0x7ff0,                 // P_adp_noise_ext
 932         0x3ccc,                 // P_adp_fil
 933
 934         1, 230,
 935         0x0000,                 // P_2d_byp_ti_num
 936
 937         1, 263,
 938         0x800,                  //P_equal_thres_wgn
 939
 940         1, 268,
 941         (2 << 9) | 39,          // P_equal_ctrl_synchro, P_equal_speedmode
 942
 943         1, 270,
 944         0x0001,                 // P_div_lock0_wait
 945         1, 285,
 946         0x0020,                 //p_fec_
 947         1, 299,
 948         0x0062,                 /* P_smo_mode, P_smo_rs_discard, P_smo_fifo_flush, P_smo_pid_parse, P_smo_error_discard */
 949
 950         1, 338,
 951         (1 << 12) |             // P_ctrl_corm_thres4pre_freq_inh=1
 952                 (1 << 10) |
 953                 (0 << 9) |              /* P_ctrl_pre_freq_inh=0 */
 954                 (3 << 5) |              /* P_ctrl_pre_freq_step=3 */
 955                 (1 << 0),               /* P_pre_freq_win_len=1 */
 956
 957         0,
 958 };
 959
 960 static u16 dib8000_identify(struct i2c_device *client)
 961 {
 962         u16 value;
 963
 964         //because of glitches sometimes
 965         value = dib8000_i2c_read16(client, 896);
 966
 967         if ((value = dib8000_i2c_read16(client, 896)) != 0x01b3) {
 968                 dprintk("wrong Vendor ID (read=0x%x)\n", value);
 969                 return 0;
 970         }
 971
 972         value = dib8000_i2c_read16(client, 897);
 973         if (value != 0x8000 && value != 0x8001 &&
 974                         value != 0x8002 && value != 0x8090) {
 975                 dprintk("wrong Device ID (%x)\n", value);
 976                 return 0;
 977         }
 978
 979         switch (value) {
 980         case 0x8000:
 981                 dprintk("found DiB8000A\n");
 982                 break;
 983         case 0x8001:
 984                 dprintk("found DiB8000B\n");
 985                 break;
 986         case 0x8002:
 987                 dprintk("found DiB8000C\n");
 988                 break;
 989         case 0x8090:
 990                 dprintk("found DiB8096P\n");
 991                 break;
 992         }
 993         return value;
 994 }
 995
 996 static int dib8000_read_unc_blocks(struct dvb_frontend *fe, u32 *unc);
 997
 998 static void dib8000_reset_stats(struct dvb_frontend *fe)
 999 {
1000         struct dib8000_state *state = fe->demodulator_priv;
1001         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
1002         u32 ucb;
1003
1004         memset(&c->strength, 0, sizeof(c->strength));
1005         memset(&c->cnr, 0, sizeof(c->cnr));
1006         memset(&c->post_bit_error, 0, sizeof(c->post_bit_error));
1007         memset(&c->post_bit_count, 0, sizeof(c->post_bit_count));
1008         memset(&c->block_error, 0, sizeof(c->block_error));
1009
1010         c->strength.len = 1;
1011         c->cnr.len = 1;
1012         c->block_error.len = 1;
1013         c->block_count.len = 1;
1014         c->post_bit_error.len = 1;
1015         c->post_bit_count.len = 1;
1016
1017         c->strength.stat[0].scale = FE_SCALE_DECIBEL;
1018         c->strength.stat[0].uvalue = 0;
1019
1020         c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1021         c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1022         c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1023         c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1024         c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1025
1026         dib8000_read_unc_blocks(fe, &ucb);
1027
1028         state->init_ucb = -ucb;
1029         state->ber_jiffies_stats = 0;
1030         state->per_jiffies_stats = 0;
1031         memset(&state->ber_jiffies_stats_layer, 0,
1032                sizeof(state->ber_jiffies_stats_layer));
1033 }
1034
1035 static int dib8000_reset(struct dvb_frontend *fe)
1036 {
1037         struct dib8000_state *state = fe->demodulator_priv;
1038
1039         if ((state->revision = dib8000_identify(&state->i2c)) == 0)
1040                 return -EINVAL;
1041
1042         /* sram lead in, rdy */
1043         if (state->revision != 0x8090)
1044                 dib8000_write_word(state, 1287, 0x0003);
1045
1046         if (state->revision == 0x8000)
1047                 dprintk("error : dib8000 MA not supported\n");
1048
1049         dibx000_reset_i2c_master(&state->i2c_master);
1050
1051         dib8000_set_power_mode(state, DIB8000_POWER_ALL);
1052
1053         /* always leave the VBG voltage on - it consumes almost nothing but takes a long time to start */
1054         dib8000_set_adc_state(state, DIBX000_ADC_OFF);
1055
1056         /* restart all parts */
1057         dib8000_write_word(state, 770, 0xffff);
1058         dib8000_write_word(state, 771, 0xffff);
1059         dib8000_write_word(state, 772, 0xfffc);
1060         dib8000_write_word(state, 898, 0x000c); /* restart sad */
1061         if (state->revision == 0x8090)
1062                 dib8000_write_word(state, 1280, 0x0045);
1063         else
1064                 dib8000_write_word(state, 1280, 0x004d);
1065         dib8000_write_word(state, 1281, 0x000c);
1066
1067         dib8000_write_word(state, 770, 0x0000);
1068         dib8000_write_word(state, 771, 0x0000);
1069         dib8000_write_word(state, 772, 0x0000);
1070         dib8000_write_word(state, 898, 0x0004); // sad
1071         dib8000_write_word(state, 1280, 0x0000);
1072         dib8000_write_word(state, 1281, 0x0000);
1073
1074         /* drives */
1075         if (state->revision != 0x8090) {
1076                 if (state->cfg.drives)
1077                         dib8000_write_word(state, 906, state->cfg.drives);
1078                 else {
1079                         dprintk("using standard PAD-drive-settings, please adjust settings in config-struct to be optimal.\n");
1080                         /* min drive SDRAM - not optimal - adjust */
1081                         dib8000_write_word(state, 906, 0x2d98);
1082                 }
1083         }
1084
1085         dib8000_reset_pll(state);
1086         if (state->revision != 0x8090)
1087                 dib8000_write_word(state, 898, 0x0004);
1088
1089         if (dib8000_reset_gpio(state) != 0)
1090                 dprintk("GPIO reset was not successful.\n");
1091
1092         if ((state->revision != 0x8090) &&
1093                         (dib8000_set_output_mode(fe, OUTMODE_HIGH_Z) != 0))
1094                 dprintk("OUTPUT_MODE could not be reset.\n");
1095
1096         state->current_agc = NULL;
1097
1098         // P_iqc_alpha_pha, P_iqc_alpha_amp, P_iqc_dcc_alpha, ...
1099         /* P_iqc_ca2 = 0; P_iqc_impnc_on = 0; P_iqc_mode = 0; */
1100         if (state->cfg.pll->ifreq == 0)
1101                 dib8000_write_word(state, 40, 0x0755);  /* P_iqc_corr_inh = 0 enable IQcorr block */
1102         else
1103                 dib8000_write_word(state, 40, 0x1f55);  /* P_iqc_corr_inh = 1 disable IQcorr block */
1104
1105         {
1106                 u16 l = 0, r;
1107                 const u16 *n;
1108                 n = dib8000_defaults;
1109                 l = *n++;
1110                 while (l) {
1111                         r = *n++;
1112                         do {
1113                                 dib8000_write_word(state, r, *n++);
1114                                 r++;
1115                         } while (--l);
1116                         l = *n++;
1117                 }
1118         }
1119
1120         state->isdbt_cfg_loaded = 0;
1121
1122         //div_cfg override for special configs
1123         if ((state->revision != 8090) && (state->cfg.div_cfg != 0))
1124                 dib8000_write_word(state, 903, state->cfg.div_cfg);
1125
1126         /* unforce divstr regardless whether i2c enumeration was done or not */
1127         dib8000_write_word(state, 1285, dib8000_read_word(state, 1285) & ~(1 << 1));
1128
1129         dib8000_set_bandwidth(fe, 6000);
1130
1131         dib8000_set_adc_state(state, DIBX000_SLOW_ADC_ON);
1132         dib8000_sad_calib(state);
1133         if (state->revision != 0x8090)
1134                 dib8000_set_adc_state(state, DIBX000_SLOW_ADC_OFF);
1135
1136         /* ber_rs_len = 3 */
1137         dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & ~0x60) | (3 << 5));
1138
1139         dib8000_set_power_mode(state, DIB8000_POWER_INTERFACE_ONLY);
1140
1141         dib8000_reset_stats(fe);
1142
1143         return 0;
1144 }
1145
1146 static void dib8000_restart_agc(struct dib8000_state *state)
1147 {
1148         // P_restart_iqc & P_restart_agc
1149         dib8000_write_word(state, 770, 0x0a00);
1150         dib8000_write_word(state, 770, 0x0000);
1151 }
1152
1153 static int dib8000_update_lna(struct dib8000_state *state)
1154 {
1155         u16 dyn_gain;
1156
1157         if (state->cfg.update_lna) {
1158                 // read dyn_gain here (because it is demod-dependent and not tuner)
1159                 dyn_gain = dib8000_read_word(state, 390);
1160
1161                 if (state->cfg.update_lna(state->fe[0], dyn_gain)) {
1162                         dib8000_restart_agc(state);
1163                         return 1;
1164                 }
1165         }
1166         return 0;
1167 }
1168
1169 static int dib8000_set_agc_config(struct dib8000_state *state, u8 band)
1170 {
1171         struct dibx000_agc_config *agc = NULL;
1172         int i;
1173         u16 reg;
1174
1175         if (state->current_band == band && state->current_agc != NULL)
1176                 return 0;
1177         state->current_band = band;
1178
1179         for (i = 0; i < state->cfg.agc_config_count; i++)
1180                 if (state->cfg.agc[i].band_caps & band) {
1181                         agc = &state->cfg.agc[i];
1182                         break;
1183                 }
1184
1185         if (agc == NULL) {
1186                 dprintk("no valid AGC configuration found for band 0x%02x\n", band);
1187                 return -EINVAL;
1188         }
1189
1190         state->current_agc = agc;
1191
1192         /* AGC */
1193         dib8000_write_word(state, 76, agc->setup);
1194         dib8000_write_word(state, 77, agc->inv_gain);
1195         dib8000_write_word(state, 78, agc->time_stabiliz);
1196         dib8000_write_word(state, 101, (agc->alpha_level << 12) | agc->thlock);
1197
1198         // Demod AGC loop configuration
1199         dib8000_write_word(state, 102, (agc->alpha_mant << 5) | agc->alpha_exp);
1200         dib8000_write_word(state, 103, (agc->beta_mant << 6) | agc->beta_exp);
1201
1202         dprintk("WBD: ref: %d, sel: %d, active: %d, alpha: %d\n",
1203                 state->wbd_ref != 0 ? state->wbd_ref : agc->wbd_ref, agc->wbd_sel, !agc->perform_agc_softsplit, agc->wbd_sel);
1204
1205         /* AGC continued */
1206         if (state->wbd_ref != 0)
1207                 dib8000_write_word(state, 106, state->wbd_ref);
1208         else                    // use default
1209                 dib8000_write_word(state, 106, agc->wbd_ref);
1210
1211         if (state->revision == 0x8090) {
1212                 reg = dib8000_read_word(state, 922) & (0x3 << 2);
1213                 dib8000_write_word(state, 922, reg | (agc->wbd_sel << 2));
1214         }
1215
1216         dib8000_write_word(state, 107, (agc->wbd_alpha << 9) | (agc->perform_agc_softsplit << 8));
1217         dib8000_write_word(state, 108, agc->agc1_max);
1218         dib8000_write_word(state, 109, agc->agc1_min);
1219         dib8000_write_word(state, 110, agc->agc2_max);
1220         dib8000_write_word(state, 111, agc->agc2_min);
1221         dib8000_write_word(state, 112, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
1222         dib8000_write_word(state, 113, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
1223         dib8000_write_word(state, 114, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
1224         dib8000_write_word(state, 115, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
1225
1226         dib8000_write_word(state, 75, agc->agc1_pt3);
1227         if (state->revision != 0x8090)
1228                 dib8000_write_word(state, 923,
1229                                 (dib8000_read_word(state, 923) & 0xffe3) |
1230                                 (agc->wbd_inv << 4) | (agc->wbd_sel << 2));
1231
1232         return 0;
1233 }
1234
1235 static void dib8000_pwm_agc_reset(struct dvb_frontend *fe)
1236 {
1237         struct dib8000_state *state = fe->demodulator_priv;
1238         dib8000_set_adc_state(state, DIBX000_ADC_ON);
1239         dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000)));
1240 }
1241
1242 static int dib8000_agc_soft_split(struct dib8000_state *state)
1243 {
1244         u16 agc, split_offset;
1245
1246         if (!state->current_agc || !state->current_agc->perform_agc_softsplit || state->current_agc->split.max == 0)
1247                 return 0;
1248
1249         // n_agc_global
1250         agc = dib8000_read_word(state, 390);
1251
1252         if (agc > state->current_agc->split.min_thres)
1253                 split_offset = state->current_agc->split.min;
1254         else if (agc < state->current_agc->split.max_thres)
1255                 split_offset = state->current_agc->split.max;
1256         else
1257                 split_offset = state->current_agc->split.max *
1258                         (agc - state->current_agc->split.min_thres) /
1259                         (state->current_agc->split.max_thres - state->current_agc->split.min_thres);
1260
1261         dprintk("AGC split_offset: %d\n", split_offset);
1262
1263         // P_agc_force_split and P_agc_split_offset
1264         dib8000_write_word(state, 107, (dib8000_read_word(state, 107) & 0xff00) | split_offset);
1265         return 5000;
1266 }
1267
1268 static int dib8000_agc_startup(struct dvb_frontend *fe)
1269 {
1270         struct dib8000_state *state = fe->demodulator_priv;
1271         enum frontend_tune_state *tune_state = &state->tune_state;
1272         int ret = 0;
1273         u16 reg;
1274         u32 upd_demod_gain_period = 0x8000;
1275
1276         switch (*tune_state) {
1277         case CT_AGC_START:
1278                 // set power-up level: interf+analog+AGC
1279
1280                 if (state->revision != 0x8090)
1281                         dib8000_set_adc_state(state, DIBX000_ADC_ON);
1282                 else {
1283                         dib8000_set_power_mode(state, DIB8000_POWER_ALL);
1284
1285                         reg = dib8000_read_word(state, 1947)&0xff00;
1286                         dib8000_write_word(state, 1946,
1287                                         upd_demod_gain_period & 0xFFFF);
1288                         /* bit 14 = enDemodGain */
1289                         dib8000_write_word(state, 1947, reg | (1<<14) |
1290                                         ((upd_demod_gain_period >> 16) & 0xFF));
1291
1292                         /* enable adc i & q */
1293                         reg = dib8000_read_word(state, 1920);
1294                         dib8000_write_word(state, 1920, (reg | 0x3) &
1295                                         (~(1 << 7)));
1296                 }
1297
1298                 if (dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000))) != 0) {
1299                         *tune_state = CT_AGC_STOP;
1300                         state->status = FE_STATUS_TUNE_FAILED;
1301                         break;
1302                 }
1303
1304                 ret = 70;
1305                 *tune_state = CT_AGC_STEP_0;
1306                 break;
1307
1308         case CT_AGC_STEP_0:
1309                 //AGC initialization
1310                 if (state->cfg.agc_control)
1311                         state->cfg.agc_control(fe, 1);
1312
1313                 dib8000_restart_agc(state);
1314
1315                 // wait AGC rough lock time
1316                 ret = 50;
1317                 *tune_state = CT_AGC_STEP_1;
1318                 break;
1319
1320         case CT_AGC_STEP_1:
1321                 // wait AGC accurate lock time
1322                 ret = 70;
1323
1324                 if (dib8000_update_lna(state))
1325                         // wait only AGC rough lock time
1326                         ret = 50;
1327                 else
1328                         *tune_state = CT_AGC_STEP_2;
1329                 break;
1330
1331         case CT_AGC_STEP_2:
1332                 dib8000_agc_soft_split(state);
1333
1334                 if (state->cfg.agc_control)
1335                         state->cfg.agc_control(fe, 0);
1336
1337                 *tune_state = CT_AGC_STOP;
1338                 break;
1339         default:
1340                 ret = dib8000_agc_soft_split(state);
1341                 break;
1342         }
1343         return ret;
1344
1345 }
1346
1347 static void dib8096p_host_bus_drive(struct dib8000_state *state, u8 drive)
1348 {
1349         u16 reg;
1350
1351         drive &= 0x7;
1352
1353         /* drive host bus 2, 3, 4 */
1354         reg = dib8000_read_word(state, 1798) &
1355                 ~(0x7 | (0x7 << 6) | (0x7 << 12));
1356         reg |= (drive<<12) | (drive<<6) | drive;
1357         dib8000_write_word(state, 1798, reg);
1358
1359         /* drive host bus 5,6 */
1360         reg = dib8000_read_word(state, 1799) & ~((0x7 << 2) | (0x7 << 8));
1361         reg |= (drive<<8) | (drive<<2);
1362         dib8000_write_word(state, 1799, reg);
1363
1364         /* drive host bus 7, 8, 9 */
1365         reg = dib8000_read_word(state, 1800) &
1366                 ~(0x7 | (0x7 << 6) | (0x7 << 12));
1367         reg |= (drive<<12) | (drive<<6) | drive;
1368         dib8000_write_word(state, 1800, reg);
1369
1370         /* drive host bus 10, 11 */
1371         reg = dib8000_read_word(state, 1801) & ~((0x7 << 2) | (0x7 << 8));
1372         reg |= (drive<<8) | (drive<<2);
1373         dib8000_write_word(state, 1801, reg);
1374
1375         /* drive host bus 12, 13, 14 */
1376         reg = dib8000_read_word(state, 1802) &
1377                 ~(0x7 | (0x7 << 6) | (0x7 << 12));
1378         reg |= (drive<<12) | (drive<<6) | drive;
1379         dib8000_write_word(state, 1802, reg);
1380 }
1381
1382 static u32 dib8096p_calcSyncFreq(u32 P_Kin, u32 P_Kout,
1383                 u32 insertExtSynchro, u32 syncSize)
1384 {
1385         u32 quantif = 3;
1386         u32 nom = (insertExtSynchro * P_Kin+syncSize);
1387         u32 denom = P_Kout;
1388         u32 syncFreq = ((nom << quantif) / denom);
1389
1390         if ((syncFreq & ((1 << quantif) - 1)) != 0)
1391                 syncFreq = (syncFreq >> quantif) + 1;
1392         else
1393                 syncFreq = (syncFreq >> quantif);
1394
1395         if (syncFreq != 0)
1396                 syncFreq = syncFreq - 1;
1397
1398         return syncFreq;
1399 }
1400
1401 static void dib8096p_cfg_DibTx(struct dib8000_state *state, u32 P_Kin,
1402                 u32 P_Kout, u32 insertExtSynchro, u32 synchroMode,
1403                 u32 syncWord, u32 syncSize)
1404 {
1405         dprintk("Configure DibStream Tx\n");
1406
1407         dib8000_write_word(state, 1615, 1);
1408         dib8000_write_word(state, 1603, P_Kin);
1409         dib8000_write_word(state, 1605, P_Kout);
1410         dib8000_write_word(state, 1606, insertExtSynchro);
1411         dib8000_write_word(state, 1608, synchroMode);
1412         dib8000_write_word(state, 1609, (syncWord >> 16) & 0xffff);
1413         dib8000_write_word(state, 1610, syncWord & 0xffff);
1414         dib8000_write_word(state, 1612, syncSize);
1415         dib8000_write_word(state, 1615, 0);
1416 }
1417
1418 static void dib8096p_cfg_DibRx(struct dib8000_state *state, u32 P_Kin,
1419                 u32 P_Kout, u32 synchroMode, u32 insertExtSynchro,
1420                 u32 syncWord, u32 syncSize, u32 dataOutRate)
1421 {
1422         u32 syncFreq;
1423
1424         dprintk("Configure DibStream Rx synchroMode = %d\n", synchroMode);
1425
1426         if ((P_Kin != 0) && (P_Kout != 0)) {
1427                 syncFreq = dib8096p_calcSyncFreq(P_Kin, P_Kout,
1428                                 insertExtSynchro, syncSize);
1429                 dib8000_write_word(state, 1542, syncFreq);
1430         }
1431
1432         dib8000_write_word(state, 1554, 1);
1433         dib8000_write_word(state, 1536, P_Kin);
1434         dib8000_write_word(state, 1537, P_Kout);
1435         dib8000_write_word(state, 1539, synchroMode);
1436         dib8000_write_word(state, 1540, (syncWord >> 16) & 0xffff);
1437         dib8000_write_word(state, 1541, syncWord & 0xffff);
1438         dib8000_write_word(state, 1543, syncSize);
1439         dib8000_write_word(state, 1544, dataOutRate);
1440         dib8000_write_word(state, 1554, 0);
1441 }
1442
1443 static void dib8096p_enMpegMux(struct dib8000_state *state, int onoff)
1444 {
1445         u16 reg_1287;
1446
1447         reg_1287 = dib8000_read_word(state, 1287);
1448
1449         switch (onoff) {
1450         case 1:
1451                         reg_1287 &= ~(1 << 8);
1452                         break;
1453         case 0:
1454                         reg_1287 |= (1 << 8);
1455                         break;
1456         }
1457
1458         dib8000_write_word(state, 1287, reg_1287);
1459 }
1460
1461 static void dib8096p_configMpegMux(struct dib8000_state *state,
1462                 u16 pulseWidth, u16 enSerialMode, u16 enSerialClkDiv2)
1463 {
1464         u16 reg_1287;
1465
1466         dprintk("Enable Mpeg mux\n");
1467
1468         dib8096p_enMpegMux(state, 0);
1469
1470         /* If the input mode is MPEG do not divide the serial clock */
1471         if ((enSerialMode == 1) && (state->input_mode_mpeg == 1))
1472                 enSerialClkDiv2 = 0;
1473
1474         reg_1287 = ((pulseWidth & 0x1f) << 3) |
1475                 ((enSerialMode & 0x1) << 2) | (enSerialClkDiv2 & 0x1);
1476         dib8000_write_word(state, 1287, reg_1287);
1477
1478         dib8096p_enMpegMux(state, 1);
1479 }
1480
1481 static void dib8096p_setDibTxMux(struct dib8000_state *state, int mode)
1482 {
1483         u16 reg_1288 = dib8000_read_word(state, 1288) & ~(0x7 << 7);
1484
1485         switch (mode) {
1486         case MPEG_ON_DIBTX:
1487                         dprintk("SET MPEG ON DIBSTREAM TX\n");
1488                         dib8096p_cfg_DibTx(state, 8, 5, 0, 0, 0, 0);
1489                         reg_1288 |= (1 << 9); break;
1490         case DIV_ON_DIBTX:
1491                         dprintk("SET DIV_OUT ON DIBSTREAM TX\n");
1492                         dib8096p_cfg_DibTx(state, 5, 5, 0, 0, 0, 0);
1493                         reg_1288 |= (1 << 8); break;
1494         case ADC_ON_DIBTX:
1495                         dprintk("SET ADC_OUT ON DIBSTREAM TX\n");
1496                         dib8096p_cfg_DibTx(state, 20, 5, 10, 0, 0, 0);
1497                         reg_1288 |= (1 << 7); break;
1498         default:
1499                         break;
1500         }
1501         dib8000_write_word(state, 1288, reg_1288);
1502 }
1503
1504 static void dib8096p_setHostBusMux(struct dib8000_state *state, int mode)
1505 {
1506         u16 reg_1288 = dib8000_read_word(state, 1288) & ~(0x7 << 4);
1507
1508         switch (mode) {
1509         case DEMOUT_ON_HOSTBUS:
1510                         dprintk("SET DEM OUT OLD INTERF ON HOST BUS\n");
1511                         dib8096p_enMpegMux(state, 0);
1512                         reg_1288 |= (1 << 6);
1513                         break;
1514         case DIBTX_ON_HOSTBUS:
1515                         dprintk("SET DIBSTREAM TX ON HOST BUS\n");
1516                         dib8096p_enMpegMux(state, 0);
1517                         reg_1288 |= (1 << 5);
1518                         break;
1519         case MPEG_ON_HOSTBUS:
1520                         dprintk("SET MPEG MUX ON HOST BUS\n");
1521                         reg_1288 |= (1 << 4);
1522                         break;
1523         default:
1524                         break;
1525         }
1526         dib8000_write_word(state, 1288, reg_1288);
1527 }
1528
1529 static int dib8096p_set_diversity_in(struct dvb_frontend *fe, int onoff)
1530 {
1531         struct dib8000_state *state = fe->demodulator_priv;
1532         u16 reg_1287;
1533
1534         switch (onoff) {
1535         case 0: /* only use the internal way - not the diversity input */
1536                         dprintk("%s mode OFF : by default Enable Mpeg INPUT\n",
1537                                         __func__);
1538                         /* outputRate = 8 */
1539                         dib8096p_cfg_DibRx(state, 8, 5, 0, 0, 0, 8, 0);
1540
1541                         /* Do not divide the serial clock of MPEG MUX in
1542                            SERIAL MODE in case input mode MPEG is used */
1543                         reg_1287 = dib8000_read_word(state, 1287);
1544                         /* enSerialClkDiv2 == 1 ? */
1545                         if ((reg_1287 & 0x1) == 1) {
1546                                 /* force enSerialClkDiv2 = 0 */
1547                                 reg_1287 &= ~0x1;
1548                                 dib8000_write_word(state, 1287, reg_1287);
1549                         }
1550                         state->input_mode_mpeg = 1;
1551                         break;
1552         case 1: /* both ways */
1553         case 2: /* only the diversity input */
1554                         dprintk("%s ON : Enable diversity INPUT\n", __func__);
1555                         dib8096p_cfg_DibRx(state, 5, 5, 0, 0, 0, 0, 0);
1556                         state->input_mode_mpeg = 0;
1557                         break;
1558         }
1559
1560         dib8000_set_diversity_in(state->fe[0], onoff);
1561         return 0;
1562 }
1563
1564 static int dib8096p_set_output_mode(struct dvb_frontend *fe, int mode)
1565 {
1566         struct dib8000_state *state = fe->demodulator_priv;
1567         u16 outreg, smo_mode, fifo_threshold;
1568         u8 prefer_mpeg_mux_use = 1;
1569         int ret = 0;
1570
1571         state->output_mode = mode;
1572         dib8096p_host_bus_drive(state, 1);
1573
1574         fifo_threshold = 1792;
1575         smo_mode = (dib8000_read_word(state, 299) & 0x0050) | (1 << 1);
1576         outreg   = dib8000_read_word(state, 1286) &
1577                 ~((1 << 10) | (0x7 << 6) | (1 << 1));
1578
1579         switch (mode) {
1580         case OUTMODE_HIGH_Z:
1581                         outreg = 0;
1582                         break;
1583
1584         case OUTMODE_MPEG2_SERIAL:
1585                         if (prefer_mpeg_mux_use) {
1586                                 dprintk("dib8096P setting output mode TS_SERIAL using Mpeg Mux\n");
1587                                 dib8096p_configMpegMux(state, 3, 1, 1);
1588                                 dib8096p_setHostBusMux(state, MPEG_ON_HOSTBUS);
1589                         } else {/* Use Smooth block */
1590                                 dprintk("dib8096P setting output mode TS_SERIAL using Smooth bloc\n");
1591                                 dib8096p_setHostBusMux(state,
1592                                                 DEMOUT_ON_HOSTBUS);
1593                                 outreg |= (2 << 6) | (0 << 1);
1594                         }
1595                         break;
1596
1597         case OUTMODE_MPEG2_PAR_GATED_CLK:
1598                         if (prefer_mpeg_mux_use) {
1599                                 dprintk("dib8096P setting output mode TS_PARALLEL_GATED using Mpeg Mux\n");
1600                                 dib8096p_configMpegMux(state, 2, 0, 0);
1601                                 dib8096p_setHostBusMux(state, MPEG_ON_HOSTBUS);
1602                         } else { /* Use Smooth block */
1603                                 dprintk("dib8096P setting output mode TS_PARALLEL_GATED using Smooth block\n");
1604                                 dib8096p_setHostBusMux(state,
1605                                                 DEMOUT_ON_HOSTBUS);
1606                                 outreg |= (0 << 6);
1607                         }
1608                         break;
1609
1610         case OUTMODE_MPEG2_PAR_CONT_CLK: /* Using Smooth block only */
1611                         dprintk("dib8096P setting output mode TS_PARALLEL_CONT using Smooth block\n");
1612                         dib8096p_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
1613                         outreg |= (1 << 6);
1614                         break;
1615
1616         case OUTMODE_MPEG2_FIFO:
1617                         /* Using Smooth block because not supported
1618                            by new Mpeg Mux bloc */
1619                         dprintk("dib8096P setting output mode TS_FIFO using Smooth block\n");
1620                         dib8096p_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
1621                         outreg |= (5 << 6);
1622                         smo_mode |= (3 << 1);
1623                         fifo_threshold = 512;
1624                         break;
1625
1626         case OUTMODE_DIVERSITY:
1627                         dprintk("dib8096P setting output mode MODE_DIVERSITY\n");
1628                         dib8096p_setDibTxMux(state, DIV_ON_DIBTX);
1629                         dib8096p_setHostBusMux(state, DIBTX_ON_HOSTBUS);
1630                         break;
1631
1632         case OUTMODE_ANALOG_ADC:
1633                         dprintk("dib8096P setting output mode MODE_ANALOG_ADC\n");
1634                         dib8096p_setDibTxMux(state, ADC_ON_DIBTX);
1635                         dib8096p_setHostBusMux(state, DIBTX_ON_HOSTBUS);
1636                         break;
1637         }
1638
1639         if (mode != OUTMODE_HIGH_Z)
1640                 outreg |= (1<<10);
1641
1642         dprintk("output_mpeg2_in_188_bytes = %d\n",
1643                         state->cfg.output_mpeg2_in_188_bytes);
1644         if (state->cfg.output_mpeg2_in_188_bytes)
1645                 smo_mode |= (1 << 5);
1646
1647         ret |= dib8000_write_word(state, 299, smo_mode);
1648         /* synchronous fread */
1649         ret |= dib8000_write_word(state, 299 + 1, fifo_threshold);
1650         ret |= dib8000_write_word(state, 1286, outreg);
1651
1652         return ret;
1653 }
1654
1655 static int map_addr_to_serpar_number(struct i2c_msg *msg)
1656 {
1657         if (msg->buf[0] <= 15)
1658                 msg->buf[0] -= 1;
1659         else if (msg->buf[0] == 17)
1660                 msg->buf[0] = 15;
1661         else if (msg->buf[0] == 16)
1662                 msg->buf[0] = 17;
1663         else if (msg->buf[0] == 19)
1664                 msg->buf[0] = 16;
1665         else if (msg->buf[0] >= 21 && msg->buf[0] <= 25)
1666                 msg->buf[0] -= 3;
1667         else if (msg->buf[0] == 28)
1668                 msg->buf[0] = 23;
1669         else if (msg->buf[0] == 99)
1670                 msg->buf[0] = 99;
1671         else
1672                 return -EINVAL;
1673         return 0;
1674 }
1675
1676 static int dib8096p_tuner_write_serpar(struct i2c_adapter *i2c_adap,
1677                 struct i2c_msg msg[], int num)
1678 {
1679         struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1680         u8 n_overflow = 1;
1681         u16 i = 1000;
1682         u16 serpar_num = msg[0].buf[0];
1683
1684         while (n_overflow == 1 && i) {
1685                 n_overflow = (dib8000_read_word(state, 1984) >> 1) & 0x1;
1686                 i--;
1687                 if (i == 0)
1688                         dprintk("Tuner ITF: write busy (overflow)\n");
1689         }
1690         dib8000_write_word(state, 1985, (1 << 6) | (serpar_num & 0x3f));
1691         dib8000_write_word(state, 1986, (msg[0].buf[1] << 8) | msg[0].buf[2]);
1692
1693         return num;
1694 }
1695
1696 static int dib8096p_tuner_read_serpar(struct i2c_adapter *i2c_adap,
1697                 struct i2c_msg msg[], int num)
1698 {
1699         struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1700         u8 n_overflow = 1, n_empty = 1;
1701         u16 i = 1000;
1702         u16 serpar_num = msg[0].buf[0];
1703         u16 read_word;
1704
1705         while (n_overflow == 1 && i) {
1706                 n_overflow = (dib8000_read_word(state, 1984) >> 1) & 0x1;
1707                 i--;
1708                 if (i == 0)
1709                         dprintk("TunerITF: read busy (overflow)\n");
1710         }
1711         dib8000_write_word(state, 1985, (0<<6) | (serpar_num&0x3f));
1712
1713         i = 1000;
1714         while (n_empty == 1 && i) {
1715                 n_empty = dib8000_read_word(state, 1984)&0x1;
1716                 i--;
1717                 if (i == 0)
1718                         dprintk("TunerITF: read busy (empty)\n");
1719         }
1720
1721         read_word = dib8000_read_word(state, 1987);
1722         msg[1].buf[0] = (read_word >> 8) & 0xff;
1723         msg[1].buf[1] = (read_word) & 0xff;
1724
1725         return num;
1726 }
1727
1728 static int dib8096p_tuner_rw_serpar(struct i2c_adapter *i2c_adap,
1729                 struct i2c_msg msg[], int num)
1730 {
1731         if (map_addr_to_serpar_number(&msg[0]) == 0) {
1732                 if (num == 1) /* write */
1733                         return dib8096p_tuner_write_serpar(i2c_adap, msg, 1);
1734                 else /* read */
1735                         return dib8096p_tuner_read_serpar(i2c_adap, msg, 2);
1736         }
1737         return num;
1738 }
1739
1740 static int dib8096p_rw_on_apb(struct i2c_adapter *i2c_adap,
1741                 struct i2c_msg msg[], int num, u16 apb_address)
1742 {
1743         struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1744         u16 word;
1745
1746         if (num == 1) {         /* write */
1747                 dib8000_write_word(state, apb_address,
1748                                 ((msg[0].buf[1] << 8) | (msg[0].buf[2])));
1749         } else {
1750                 word = dib8000_read_word(state, apb_address);
1751                 msg[1].buf[0] = (word >> 8) & 0xff;
1752                 msg[1].buf[1] = (word) & 0xff;
1753         }
1754         return num;
1755 }
1756
1757 static int dib8096p_tuner_xfer(struct i2c_adapter *i2c_adap,
1758                 struct i2c_msg msg[], int num)
1759 {
1760         struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1761         u16 apb_address = 0, word;
1762         int i = 0;
1763
1764         switch (msg[0].buf[0]) {
1765         case 0x12:
1766                         apb_address = 1920;
1767                         break;
1768         case 0x14:
1769                         apb_address = 1921;
1770                         break;
1771         case 0x24:
1772                         apb_address = 1922;
1773                         break;
1774         case 0x1a:
1775                         apb_address = 1923;
1776                         break;
1777         case 0x22:
1778                         apb_address = 1924;
1779                         break;
1780         case 0x33:
1781                         apb_address = 1926;
1782                         break;
1783         case 0x34:
1784                         apb_address = 1927;
1785                         break;
1786         case 0x35:
1787                         apb_address = 1928;
1788                         break;
1789         case 0x36:
1790                         apb_address = 1929;
1791                         break;
1792         case 0x37:
1793                         apb_address = 1930;
1794                         break;
1795         case 0x38:
1796                         apb_address = 1931;
1797                         break;
1798         case 0x39:
1799                         apb_address = 1932;
1800                         break;
1801         case 0x2a:
1802                         apb_address = 1935;
1803                         break;
1804         case 0x2b:
1805                         apb_address = 1936;
1806                         break;
1807         case 0x2c:
1808                         apb_address = 1937;
1809                         break;
1810         case 0x2d:
1811                         apb_address = 1938;
1812                         break;
1813         case 0x2e:
1814                         apb_address = 1939;
1815                         break;
1816         case 0x2f:
1817                         apb_address = 1940;
1818                         break;
1819         case 0x30:
1820                         apb_address = 1941;
1821                         break;
1822         case 0x31:
1823                         apb_address = 1942;
1824                         break;
1825         case 0x32:
1826                         apb_address = 1943;
1827                         break;
1828         case 0x3e:
1829                         apb_address = 1944;
1830                         break;
1831         case 0x3f:
1832                         apb_address = 1945;
1833                         break;
1834         case 0x40:
1835                         apb_address = 1948;
1836                         break;
1837         case 0x25:
1838                         apb_address = 936;
1839                         break;
1840         case 0x26:
1841                         apb_address = 937;
1842                         break;
1843         case 0x27:
1844                         apb_address = 938;
1845                         break;
1846         case 0x28:
1847                         apb_address = 939;
1848                         break;
1849         case 0x1d:
1850                         /* get sad sel request */
1851                         i = ((dib8000_read_word(state, 921) >> 12)&0x3);
1852                         word = dib8000_read_word(state, 924+i);
1853                         msg[1].buf[0] = (word >> 8) & 0xff;
1854                         msg[1].buf[1] = (word) & 0xff;
1855                         return num;
1856         case 0x1f:
1857                         if (num == 1) { /* write */
1858                                 word = (u16) ((msg[0].buf[1] << 8) |
1859                                                 msg[0].buf[2]);
1860                                 /* in the VGAMODE Sel are located on bit 0/1 */
1861                                 word &= 0x3;
1862                                 word = (dib8000_read_word(state, 921) &
1863                                                 ~(3<<12)) | (word<<12);
1864                                 /* Set the proper input */
1865                                 dib8000_write_word(state, 921, word);
1866                                 return num;
1867                         }
1868         }
1869
1870         if (apb_address != 0) /* R/W access via APB */
1871                 return dib8096p_rw_on_apb(i2c_adap, msg, num, apb_address);
1872         else  /* R/W access via SERPAR  */
1873                 return dib8096p_tuner_rw_serpar(i2c_adap, msg, num);
1874
1875         return 0;
1876 }
1877
1878 static u32 dib8096p_i2c_func(struct i2c_adapter *adapter)
1879 {
1880         return I2C_FUNC_I2C;
1881 }
1882
1883 static const struct i2c_algorithm dib8096p_tuner_xfer_algo = {
1884         .master_xfer = dib8096p_tuner_xfer,
1885         .functionality = dib8096p_i2c_func,
1886 };
1887
1888 static struct i2c_adapter *dib8096p_get_i2c_tuner(struct dvb_frontend *fe)
1889 {
1890         struct dib8000_state *st = fe->demodulator_priv;
1891         return &st->dib8096p_tuner_adap;
1892 }
1893
1894 static int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff)
1895 {
1896         struct dib8000_state *state = fe->demodulator_priv;
1897         u16 en_cur_state;
1898
1899         dprintk("sleep dib8096p: %d\n", onoff);
1900
1901         en_cur_state = dib8000_read_word(state, 1922);
1902
1903         /* LNAs and MIX are ON and therefore it is a valid configuration */
1904         if (en_cur_state > 0xff)
1905                 state->tuner_enable = en_cur_state ;
1906
1907         if (onoff)
1908                 en_cur_state &= 0x00ff;
1909         else {
1910                 if (state->tuner_enable != 0)
1911                         en_cur_state = state->tuner_enable;
1912         }
1913
1914         dib8000_write_word(state, 1922, en_cur_state);
1915
1916         return 0;
1917 }
1918
1919 static const s32 lut_1000ln_mant[] =
1920 {
1921         908, 7003, 7090, 7170, 7244, 7313, 7377, 7438, 7495, 7549, 7600
1922 };
1923
1924 static s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode)
1925 {
1926         struct dib8000_state *state = fe->demodulator_priv;
1927         u32 ix = 0, tmp_val = 0, exp = 0, mant = 0;
1928         s32 val;
1929
1930         val = dib8000_read32(state, 384);
1931         if (mode) {
1932                 tmp_val = val;
1933                 while (tmp_val >>= 1)
1934                         exp++;
1935                 mant = (val * 1000 / (1<<exp));
1936                 ix = (u8)((mant-1000)/100); /* index of the LUT */
1937                 val = (lut_1000ln_mant[ix] + 693*(exp-20) - 6908);
1938                 val = (val*256)/1000;
1939         }
1940         return val;
1941 }
1942
1943 static int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ)
1944 {
1945         struct dib8000_state *state = fe->demodulator_priv;
1946         int val = 0;
1947
1948         switch (IQ) {
1949         case 1:
1950                         val = dib8000_read_word(state, 403);
1951                         break;
1952         case 0:
1953                         val = dib8000_read_word(state, 404);
1954                         break;
1955         }
1956         if (val  & 0x200)
1957                 val -= 1024;
1958
1959         return val;
1960 }
1961
1962 static void dib8000_update_timf(struct dib8000_state *state)
1963 {
1964         u32 timf = state->timf = dib8000_read32(state, 435);
1965
1966         dib8000_write_word(state, 29, (u16) (timf >> 16));
1967         dib8000_write_word(state, 30, (u16) (timf & 0xffff));
1968         dprintk("Updated timing frequency: %d (default: %d)\n", state->timf, state->timf_default);
1969 }
1970
1971 static u32 dib8000_ctrl_timf(struct dvb_frontend *fe, uint8_t op, uint32_t timf)
1972 {
1973         struct dib8000_state *state = fe->demodulator_priv;
1974
1975         switch (op) {
1976         case DEMOD_TIMF_SET:
1977                         state->timf = timf;
1978                         break;
1979         case DEMOD_TIMF_UPDATE:
1980                         dib8000_update_timf(state);
1981                         break;
1982         case DEMOD_TIMF_GET:
1983                         break;
1984         }
1985         dib8000_set_bandwidth(state->fe[0], 6000);
1986
1987         return state->timf;
1988 }
1989
1990 static const u16 adc_target_16dB[11] = {
1991         7250, 7238, 7264, 7309, 7338, 7382, 7427, 7456, 7500, 7544, 7574
1992 };
1993
1994 static const u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 };
1995
1996 static u16 dib8000_set_layer(struct dib8000_state *state, u8 layer_index, u16 max_constellation)
1997 {
1998         u8  cr, constellation, time_intlv;
1999         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2000
2001         switch (c->layer[layer_index].modulation) {
2002         case DQPSK:
2003                         constellation = 0;
2004                         break;
2005         case  QPSK:
2006                         constellation = 1;
2007                         break;
2008         case QAM_16:
2009                         constellation = 2;
2010                         break;
2011         case QAM_64:
2012         default:
2013                         constellation = 3;
2014                         break;
2015         }
2016
2017         switch (c->layer[layer_index].fec) {
2018         case FEC_1_2:
2019                         cr = 1;
2020                         break;
2021         case FEC_2_3:
2022                         cr = 2;
2023                         break;
2024         case FEC_3_4:
2025                         cr = 3;
2026                         break;
2027         case FEC_5_6:
2028                         cr = 5;
2029                         break;
2030         case FEC_7_8:
2031         default:
2032                         cr = 7;
2033                         break;
2034         }
2035
2036         time_intlv = fls(c->layer[layer_index].interleaving);
2037         if (time_intlv > 3 && !(time_intlv == 4 && c->isdbt_sb_mode == 1))
2038                 time_intlv = 0;
2039
2040         dib8000_write_word(state, 2 + layer_index, (constellation << 10) | ((c->layer[layer_index].segment_count & 0xf) << 6) | (cr << 3) | time_intlv);
2041         if (c->layer[layer_index].segment_count > 0) {
2042                 switch (max_constellation) {
2043                 case DQPSK:
2044                 case QPSK:
2045                                 if (c->layer[layer_index].modulation == QAM_16 || c->layer[layer_index].modulation == QAM_64)
2046                                         max_constellation = c->layer[layer_index].modulation;
2047                                 break;
2048                 case QAM_16:
2049                                 if (c->layer[layer_index].modulation == QAM_64)
2050                                         max_constellation = c->layer[layer_index].modulation;
2051                                 break;
2052                 }
2053         }
2054
2055         return  max_constellation;
2056 }
2057
2058 static const u16 adp_Q64[4] = {0x0148, 0xfff0, 0x00a4, 0xfff8}; /* P_adp_regul_cnt 0.04, P_adp_noise_cnt -0.002, P_adp_regul_ext 0.02, P_adp_noise_ext -0.001 */
2059 static const u16 adp_Q16[4] = {0x023d, 0xffdf, 0x00a4, 0xfff0}; /* P_adp_regul_cnt 0.07, P_adp_noise_cnt -0.004, P_adp_regul_ext 0.02, P_adp_noise_ext -0.002 */
2060 static const u16 adp_Qdefault[4] = {0x099a, 0xffae, 0x0333, 0xfff8}; /* P_adp_regul_cnt 0.3,  P_adp_noise_cnt -0.01,  P_adp_regul_ext 0.1,  P_adp_noise_ext -0.002 */
2061 static u16 dib8000_adp_fine_tune(struct dib8000_state *state, u16 max_constellation)
2062 {
2063         u16 i, ana_gain = 0;
2064         const u16 *adp;
2065
2066         /* channel estimation fine configuration */
2067         switch (max_constellation) {
2068         case QAM_64:
2069                         ana_gain = 0x7;
2070                         adp = &adp_Q64[0];
2071                         break;
2072         case QAM_16:
2073                         ana_gain = 0x7;
2074                         adp = &adp_Q16[0];
2075                         break;
2076         default:
2077                         ana_gain = 0;
2078                         adp = &adp_Qdefault[0];
2079                         break;
2080         }
2081
2082         for (i = 0; i < 4; i++)
2083                 dib8000_write_word(state, 215 + i, adp[i]);
2084
2085         return ana_gain;
2086 }
2087
2088 static void dib8000_update_ana_gain(struct dib8000_state *state, u16 ana_gain)
2089 {
2090         u16 i;
2091
2092         dib8000_write_word(state, 116, ana_gain);
2093
2094         /* update ADC target depending on ana_gain */
2095         if (ana_gain) { /* set -16dB ADC target for ana_gain=-1 */
2096                 for (i = 0; i < 10; i++)
2097                         dib8000_write_word(state, 80 + i, adc_target_16dB[i]);
2098         } else { /* set -22dB ADC target for ana_gain=0 */
2099                 for (i = 0; i < 10; i++)
2100                         dib8000_write_word(state, 80 + i, adc_target_16dB[i] - 355);
2101         }
2102 }
2103
2104 static void dib8000_load_ana_fe_coefs(struct dib8000_state *state, const s16 *ana_fe)
2105 {
2106         u16 mode = 0;
2107
2108         if (state->isdbt_cfg_loaded == 0)
2109                 for (mode = 0; mode < 24; mode++)
2110                         dib8000_write_word(state, 117 + mode, ana_fe[mode]);
2111 }
2112
2113 static const u16 lut_prbs_2k[14] = {
2114         0, 0x423, 0x009, 0x5C7, 0x7A6, 0x3D8, 0x527, 0x7FF, 0x79B, 0x3D6, 0x3A2, 0x53B, 0x2F4, 0x213
2115 };
2116 static const u16 lut_prbs_4k[14] = {
2117         0, 0x208, 0x0C3, 0x7B9, 0x423, 0x5C7, 0x3D8, 0x7FF, 0x3D6, 0x53B, 0x213, 0x029, 0x0D0, 0x48E
2118 };
2119 static const u16 lut_prbs_8k[14] = {
2120         0, 0x740, 0x069, 0x7DD, 0x208, 0x7B9, 0x5C7, 0x7FF, 0x53B, 0x029, 0x48E, 0x4C4, 0x367, 0x684
2121 };
2122
2123 static u16 dib8000_get_init_prbs(struct dib8000_state *state, u16 subchannel)
2124 {
2125         int sub_channel_prbs_group = 0;
2126
2127         sub_channel_prbs_group = (subchannel / 3) + 1;
2128         dprintk("sub_channel_prbs_group = %d , subchannel =%d prbs = 0x%04x\n", sub_channel_prbs_group, subchannel, lut_prbs_8k[sub_channel_prbs_group]);
2129
2130         switch (state->fe[0]->dtv_property_cache.transmission_mode) {
2131         case TRANSMISSION_MODE_2K:
2132                         return lut_prbs_2k[sub_channel_prbs_group];
2133         case TRANSMISSION_MODE_4K:
2134                         return lut_prbs_4k[sub_channel_prbs_group];
2135         default:
2136         case TRANSMISSION_MODE_8K:
2137                         return lut_prbs_8k[sub_channel_prbs_group];
2138         }
2139 }
2140
2141 static void dib8000_set_13seg_channel(struct dib8000_state *state)
2142 {
2143         u16 i;
2144         u16 coff_pow = 0x2800;
2145
2146         state->seg_mask = 0x1fff; /* All 13 segments enabled */
2147
2148         /* ---- COFF ---- Carloff, the most robust --- */
2149         if (state->isdbt_cfg_loaded == 0) {  /* if not Sound Broadcasting mode : put default values for 13 segments */
2150                 dib8000_write_word(state, 180, (16 << 6) | 9);
2151                 dib8000_write_word(state, 187, (4 << 12) | (8 << 5) | 0x2);
2152                 coff_pow = 0x2800;
2153                 for (i = 0; i < 6; i++)
2154                         dib8000_write_word(state, 181+i, coff_pow);
2155
2156                 /* P_ctrl_corm_thres4pre_freq_inh=1, P_ctrl_pre_freq_mode_sat=1 */
2157                 /* P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 3, P_pre_freq_win_len=1 */
2158                 dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (3 << 5) | 1);
2159
2160                 /* P_ctrl_pre_freq_win_len=8, P_ctrl_pre_freq_thres_lockin=6 */
2161                 dib8000_write_word(state, 340, (8 << 6) | (6 << 0));
2162                 /* P_ctrl_pre_freq_thres_lockout=4, P_small_use_tmcc/ac/cp=1 */
2163                 dib8000_write_word(state, 341, (4 << 3) | (1 << 2) | (1 << 1) | (1 << 0));
2164
2165                 dib8000_write_word(state, 228, 0);  /* default value */
2166                 dib8000_write_word(state, 265, 31); /* default value */
2167                 dib8000_write_word(state, 205, 0x200f); /* init value */
2168         }
2169
2170         /*
2171          * make the cpil_coff_lock more robust but slower p_coff_winlen
2172          * 6bits; p_coff_thres_lock 6bits (for coff lock if needed)
2173          */
2174
2175         if (state->cfg.pll->ifreq == 0)
2176                 dib8000_write_word(state, 266, ~state->seg_mask | state->seg_diff_mask | 0x40); /* P_equal_noise_seg_inh */
2177
2178         dib8000_load_ana_fe_coefs(state, ana_fe_coeff_13seg);
2179 }
2180
2181 static void dib8000_set_subchannel_prbs(struct dib8000_state *state, u16 init_prbs)
2182 {
2183         u16 reg_1;
2184
2185         reg_1 = dib8000_read_word(state, 1);
2186         dib8000_write_word(state, 1, (init_prbs << 2) | (reg_1 & 0x3)); /* ADDR 1 */
2187 }
2188
2189 static void dib8000_small_fine_tune(struct dib8000_state *state)
2190 {
2191         u16 i;
2192         const s16 *ncoeff;
2193         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2194
2195         dib8000_write_word(state, 352, state->seg_diff_mask);
2196         dib8000_write_word(state, 353, state->seg_mask);
2197
2198         /* P_small_coef_ext_enable=ISDB-Tsb, P_small_narrow_band=ISDB-Tsb, P_small_last_seg=13, P_small_offset_num_car=5 */
2199         dib8000_write_word(state, 351, (c->isdbt_sb_mode << 9) | (c->isdbt_sb_mode << 8) | (13 << 4) | 5);
2200
2201         if (c->isdbt_sb_mode) {
2202                 /* ---- SMALL ---- */
2203                 switch (c->transmission_mode) {
2204                 case TRANSMISSION_MODE_2K:
2205                                 if (c->isdbt_partial_reception == 0) { /* 1-seg */
2206                                         if (c->layer[0].modulation == DQPSK) /* DQPSK */
2207                                                 ncoeff = coeff_2k_sb_1seg_dqpsk;
2208                                         else /* QPSK or QAM */
2209                                                 ncoeff = coeff_2k_sb_1seg;
2210                                 } else { /* 3-segments */
2211                                         if (c->layer[0].modulation == DQPSK) { /* DQPSK on central segment */
2212                                                 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2213                                                         ncoeff = coeff_2k_sb_3seg_0dqpsk_1dqpsk;
2214                                                 else /* QPSK or QAM on external segments */
2215                                                         ncoeff = coeff_2k_sb_3seg_0dqpsk;
2216                                         } else { /* QPSK or QAM on central segment */
2217                                                 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2218                                                         ncoeff = coeff_2k_sb_3seg_1dqpsk;
2219                                                 else /* QPSK or QAM on external segments */
2220                                                         ncoeff = coeff_2k_sb_3seg;
2221                                         }
2222                                 }
2223                                 break;
2224                 case TRANSMISSION_MODE_4K:
2225                                 if (c->isdbt_partial_reception == 0) { /* 1-seg */
2226                                         if (c->layer[0].modulation == DQPSK) /* DQPSK */
2227                                                 ncoeff = coeff_4k_sb_1seg_dqpsk;
2228                                         else /* QPSK or QAM */
2229                                                 ncoeff = coeff_4k_sb_1seg;
2230                                 } else { /* 3-segments */
2231                                         if (c->layer[0].modulation == DQPSK) { /* DQPSK on central segment */
2232                                                 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2233                                                         ncoeff = coeff_4k_sb_3seg_0dqpsk_1dqpsk;
2234                                                 else /* QPSK or QAM on external segments */
2235                                                         ncoeff = coeff_4k_sb_3seg_0dqpsk;
2236                                         } else { /* QPSK or QAM on central segment */
2237                                                 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2238                                                         ncoeff = coeff_4k_sb_3seg_1dqpsk;
2239                                                 else /* QPSK or QAM on external segments */
2240                                                         ncoeff = coeff_4k_sb_3seg;
2241                                         }
2242                                 }
2243                                 break;
2244                 case TRANSMISSION_MODE_AUTO:
2245                 case TRANSMISSION_MODE_8K:
2246                 default:
2247                                 if (c->isdbt_partial_reception == 0) { /* 1-seg */
2248                                         if (c->layer[0].modulation == DQPSK) /* DQPSK */
2249                                                 ncoeff = coeff_8k_sb_1seg_dqpsk;
2250                                         else /* QPSK or QAM */
2251                                                 ncoeff = coeff_8k_sb_1seg;
2252                                 } else { /* 3-segments */
2253                                         if (c->layer[0].modulation == DQPSK) { /* DQPSK on central segment */
2254                                                 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2255                                                         ncoeff = coeff_8k_sb_3seg_0dqpsk_1dqpsk;
2256                                                 else /* QPSK or QAM on external segments */
2257                                                         ncoeff = coeff_8k_sb_3seg_0dqpsk;
2258                                         } else { /* QPSK or QAM on central segment */
2259                                                 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2260                                                         ncoeff = coeff_8k_sb_3seg_1dqpsk;
2261                                                 else /* QPSK or QAM on external segments */
2262                                                         ncoeff = coeff_8k_sb_3seg;
2263                                         }
2264                                 }
2265                                 break;
2266                 }
2267
2268                 for (i = 0; i < 8; i++)
2269                         dib8000_write_word(state, 343 + i, ncoeff[i]);
2270         }
2271 }
2272
2273 static const u16 coff_thres_1seg[3] = {300, 150, 80};
2274 static const u16 coff_thres_3seg[3] = {350, 300, 250};
2275 static void dib8000_set_sb_channel(struct dib8000_state *state)
2276 {
2277         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2278         const u16 *coff;
2279         u16 i;
2280
2281         if (c->transmission_mode == TRANSMISSION_MODE_2K || c->transmission_mode == TRANSMISSION_MODE_4K) {
2282                 dib8000_write_word(state, 219, dib8000_read_word(state, 219) | 0x1); /* adp_pass =1 */
2283                 dib8000_write_word(state, 190, dib8000_read_word(state, 190) | (0x1 << 14)); /* pha3_force_pha_shift = 1 */
2284         } else {
2285                 dib8000_write_word(state, 219, dib8000_read_word(state, 219) & 0xfffe); /* adp_pass =0 */
2286                 dib8000_write_word(state, 190, dib8000_read_word(state, 190) & 0xbfff); /* pha3_force_pha_shift = 0 */
2287         }
2288
2289         if (c->isdbt_partial_reception == 1) /* 3-segments */
2290                 state->seg_mask = 0x00E0;
2291         else /* 1-segment */
2292                 state->seg_mask = 0x0040;
2293
2294         dib8000_write_word(state, 268, (dib8000_read_word(state, 268) & 0xF9FF) | 0x0200);
2295
2296         /* ---- COFF ---- Carloff, the most robust --- */
2297         /* P_coff_cpil_alpha=4, P_coff_inh=0, P_coff_cpil_winlen=64, P_coff_narrow_band=1, P_coff_square_val=1, P_coff_one_seg=~partial_rcpt, P_coff_use_tmcc=1, P_coff_use_ac=1 */
2298         dib8000_write_word(state, 187, (4 << 12) | (0 << 11) | (63 << 5) | (0x3 << 3) | ((~c->isdbt_partial_reception & 1) << 2) | 0x3);
2299
2300         dib8000_write_word(state, 340, (16 << 6) | (8 << 0)); /* P_ctrl_pre_freq_win_len=16, P_ctrl_pre_freq_thres_lockin=8 */
2301         dib8000_write_word(state, 341, (6 << 3) | (1 << 2) | (1 << 1) | (1 << 0));/* P_ctrl_pre_freq_thres_lockout=6, P_small_use_tmcc/ac/cp=1 */
2302
2303         /* Sound Broadcasting mode 1 seg */
2304         if (c->isdbt_partial_reception == 0) {
2305                 /* P_coff_winlen=63, P_coff_thres_lock=15, P_coff_one_seg_width = (P_mode == 3) , P_coff_one_seg_sym = (P_mode-1) */
2306                 if (state->mode == 3)
2307                         dib8000_write_word(state, 180, 0x1fcf | ((state->mode - 1) << 14));
2308                 else
2309                         dib8000_write_word(state, 180, 0x0fcf | ((state->mode - 1) << 14));
2310
2311                 /* P_ctrl_corm_thres4pre_freq_inh=1,P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 5, P_pre_freq_win_len=4 */
2312                 dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (5 << 5) | 4);
2313                 coff = &coff_thres_1seg[0];
2314         } else {   /* Sound Broadcasting mode 3 seg */
2315                 dib8000_write_word(state, 180, 0x1fcf | (1 << 14));
2316                 /* P_ctrl_corm_thres4pre_freq_inh = 1, P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 4, P_pre_freq_win_len=4 */
2317                 dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (4 << 5) | 4);
2318                 coff = &coff_thres_3seg[0];
2319         }
2320
2321         dib8000_write_word(state, 228, 1); /* P_2d_mode_byp=1 */
2322         dib8000_write_word(state, 205, dib8000_read_word(state, 205) & 0xfff0); /* P_cspu_win_cut = 0 */
2323
2324         if (c->isdbt_partial_reception == 0 && c->transmission_mode == TRANSMISSION_MODE_2K)
2325                 dib8000_write_word(state, 265, 15); /* P_equal_noise_sel = 15 */
2326
2327         /* Write COFF thres */
2328         for (i = 0 ; i < 3; i++) {
2329                 dib8000_write_word(state, 181+i, coff[i]);
2330                 dib8000_write_word(state, 184+i, coff[i]);
2331         }
2332
2333         /*
2334          * make the cpil_coff_lock more robust but slower p_coff_winlen
2335          * 6bits; p_coff_thres_lock 6bits (for coff lock if needed)
2336          */
2337
2338         dib8000_write_word(state, 266, ~state->seg_mask | state->seg_diff_mask); /* P_equal_noise_seg_inh */
2339
2340         if (c->isdbt_partial_reception == 0)
2341                 dib8000_write_word(state, 178, 64); /* P_fft_powrange = 64 */
2342         else
2343                 dib8000_write_word(state, 178, 32); /* P_fft_powrange = 32 */
2344 }
2345
2346 static void dib8000_set_isdbt_common_channel(struct dib8000_state *state, u8 seq, u8 autosearching)
2347 {
2348         u16 p_cfr_left_edge  = 0, p_cfr_right_edge = 0;
2349         u16 tmcc_pow = 0, ana_gain = 0, tmp = 0, i = 0, nbseg_diff = 0 ;
2350         u16 max_constellation = DQPSK;
2351         int init_prbs;
2352         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2353
2354         if (autosearching)
2355                 c->isdbt_partial_reception = 1;
2356
2357         /* P_mode */
2358         dib8000_write_word(state, 10, (seq << 4));
2359
2360         /* init mode */
2361         state->mode = fft_to_mode(state);
2362
2363         /* set guard */
2364         tmp = dib8000_read_word(state, 1);
2365         dib8000_write_word(state, 1, (tmp&0xfffc) | (c->guard_interval & 0x3));
2366
2367         dib8000_write_word(state, 274, (dib8000_read_word(state, 274) & 0xffcf) | ((c->isdbt_partial_reception & 1) << 5) | ((c->isdbt_sb_mode & 1) << 4));
2368
2369         /* signal optimization parameter */
2370         if (c->isdbt_partial_reception) {
2371                 state->seg_diff_mask = (c->layer[0].modulation == DQPSK) << permu_seg[0];
2372                 for (i = 1; i < 3; i++)
2373                         nbseg_diff += (c->layer[i].modulation == DQPSK) * c->layer[i].segment_count;
2374                 for (i = 0; i < nbseg_diff; i++)
2375                         state->seg_diff_mask |= 1 << permu_seg[i+1];
2376         } else {
2377                 for (i = 0; i < 3; i++)
2378                         nbseg_diff += (c->layer[i].modulation == DQPSK) * c->layer[i].segment_count;
2379                 for (i = 0; i < nbseg_diff; i++)
2380                         state->seg_diff_mask |= 1 << permu_seg[i];
2381         }
2382
2383         if (state->seg_diff_mask)
2384                 dib8000_write_word(state, 268, (dib8000_read_word(state, 268) & 0xF9FF) | 0x0200);
2385         else
2386                 dib8000_write_word(state, 268, (2 << 9) | 39); /*init value */
2387
2388         for (i = 0; i < 3; i++)
2389                 max_constellation = dib8000_set_layer(state, i, max_constellation);
2390         if (autosearching == 0) {
2391                 state->layer_b_nb_seg = c->layer[1].segment_count;
2392                 state->layer_c_nb_seg = c->layer[2].segment_count;
2393         }
2394
2395         /* WRITE: Mode & Diff mask */
2396         dib8000_write_word(state, 0, (state->mode << 13) | state->seg_diff_mask);
2397
2398         state->differential_constellation = (state->seg_diff_mask != 0);
2399
2400         /* channel estimation fine configuration */
2401         ana_gain = dib8000_adp_fine_tune(state, max_constellation);
2402
2403         /* update ana_gain depending on max constellation */
2404         dib8000_update_ana_gain(state, ana_gain);
2405
2406         /* ---- ANA_FE ---- */
2407         if (c->isdbt_partial_reception) /* 3-segments */
2408                 dib8000_load_ana_fe_coefs(state, ana_fe_coeff_3seg);
2409         else
2410                 dib8000_load_ana_fe_coefs(state, ana_fe_coeff_1seg); /* 1-segment */
2411
2412         /* TSB or ISDBT ? apply it now */
2413         if (c->isdbt_sb_mode) {
2414                 dib8000_set_sb_channel(state);
2415                 if (c->isdbt_sb_subchannel < 14)
2416                         init_prbs = dib8000_get_init_prbs(state, c->isdbt_sb_subchannel);
2417                 else
2418                         init_prbs = 0;
2419         } else {
2420                 dib8000_set_13seg_channel(state);
2421                 init_prbs = 0xfff;
2422         }
2423
2424         /* SMALL */
2425         dib8000_small_fine_tune(state);
2426
2427         dib8000_set_subchannel_prbs(state, init_prbs);
2428
2429         /* ---- CHAN_BLK ---- */
2430         for (i = 0; i < 13; i++) {
2431                 if ((((~state->seg_diff_mask) >> i) & 1) == 1) {
2432                         p_cfr_left_edge  += (1 << i) * ((i == 0) || ((((state->seg_mask & (~state->seg_diff_mask)) >> (i - 1)) & 1) == 0));
2433                         p_cfr_right_edge += (1 << i) * ((i == 12) || ((((state->seg_mask & (~state->seg_diff_mask)) >> (i + 1)) & 1) == 0));
2434                 }
2435         }
2436         dib8000_write_word(state, 222, p_cfr_left_edge); /* p_cfr_left_edge */
2437         dib8000_write_word(state, 223, p_cfr_right_edge); /* p_cfr_right_edge */
2438         /* "P_cspu_left_edge" & "P_cspu_right_edge" not used => do not care */
2439
2440         dib8000_write_word(state, 189, ~state->seg_mask | state->seg_diff_mask); /* P_lmod4_seg_inh */
2441         dib8000_write_word(state, 192, ~state->seg_mask | state->seg_diff_mask); /* P_pha3_seg_inh */
2442         dib8000_write_word(state, 225, ~state->seg_mask | state->seg_diff_mask); /* P_tac_seg_inh */
2443
2444         if (!autosearching)
2445                 dib8000_write_word(state, 288, (~state->seg_mask | state->seg_diff_mask) & 0x1fff); /* P_tmcc_seg_eq_inh */
2446         else
2447                 dib8000_write_word(state, 288, 0x1fff); /*disable equalisation of the tmcc when autosearch to be able to find the DQPSK channels. */
2448
2449         dib8000_write_word(state, 211, state->seg_mask & (~state->seg_diff_mask)); /* P_des_seg_enabled */
2450         dib8000_write_word(state, 287, ~state->seg_mask | 0x1000); /* P_tmcc_seg_inh */
2451
2452         dib8000_write_word(state, 178, 32); /* P_fft_powrange = 32 */
2453
2454         /* ---- TMCC ---- */
2455         for (i = 0; i < 3; i++)
2456                 tmcc_pow += (((c->layer[i].modulation == DQPSK) * 4 + 1) * c->layer[i].segment_count) ;
2457
2458         /* Quantif of "P_tmcc_dec_thres_?k" is (0, 5+mode, 9); */
2459         /* Threshold is set at 1/4 of max power. */
2460         tmcc_pow *= (1 << (9-2));
2461         dib8000_write_word(state, 290, tmcc_pow); /* P_tmcc_dec_thres_2k */
2462         dib8000_write_word(state, 291, tmcc_pow); /* P_tmcc_dec_thres_4k */
2463         dib8000_write_word(state, 292, tmcc_pow); /* P_tmcc_dec_thres_8k */
2464         /*dib8000_write_word(state, 287, (1 << 13) | 0x1000 ); */
2465
2466         /* ---- PHA3 ---- */
2467         if (state->isdbt_cfg_loaded == 0)
2468                 dib8000_write_word(state, 250, 3285); /* p_2d_hspeed_thr0 */
2469
2470         state->isdbt_cfg_loaded = 0;
2471 }
2472
2473 static u32 dib8000_wait_lock(struct dib8000_state *state, u32 internal,
2474                              u32 wait0_ms, u32 wait1_ms, u32 wait2_ms)
2475 {
2476         u32 value = 0;  /* P_search_end0 wait time */
2477         u16 reg = 11;   /* P_search_end0 start addr */
2478
2479         for (reg = 11; reg < 16; reg += 2) {
2480                 if (reg == 11) {
2481                         if (state->revision == 0x8090)
2482                                 value = internal * wait1_ms;
2483                         else
2484                                 value = internal * wait0_ms;
2485                 } else if (reg == 13)
2486                         value = internal * wait1_ms;
2487                 else if (reg == 15)
2488                         value = internal * wait2_ms;
2489                 dib8000_write_word(state, reg, (u16)((value >> 16) & 0xffff));
2490                 dib8000_write_word(state, (reg + 1), (u16)(value & 0xffff));
2491         }
2492         return value;
2493 }
2494
2495 static int dib8000_autosearch_start(struct dvb_frontend *fe)
2496 {
2497         struct dib8000_state *state = fe->demodulator_priv;
2498         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2499         u8 slist = 0;
2500         u32 value, internal = state->cfg.pll->internal;
2501
2502         if (state->revision == 0x8090)
2503                 internal = dib8000_read32(state, 23) / 1000;
2504
2505         if ((state->revision >= 0x8002) &&
2506             (state->autosearch_state == AS_SEARCHING_FFT)) {
2507                 dib8000_write_word(state,  37, 0x0065); /* P_ctrl_pha_off_max default values */
2508                 dib8000_write_word(state, 116, 0x0000); /* P_ana_gain to 0 */
2509
2510                 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x1fff) | (0 << 13) | (1 << 15)); /* P_mode = 0, P_restart_search=1 */
2511                 dib8000_write_word(state, 1, (dib8000_read_word(state, 1) & 0xfffc) | 0); /* P_guard = 0 */
2512                 dib8000_write_word(state, 6, 0); /* P_lock0_mask = 0 */
2513                 dib8000_write_word(state, 7, 0); /* P_lock1_mask = 0 */
2514                 dib8000_write_word(state, 8, 0); /* P_lock2_mask = 0 */
2515                 dib8000_write_word(state, 10, (dib8000_read_word(state, 10) & 0x200) | (16 << 4) | (0 << 0)); /* P_search_list=16, P_search_maxtrial=0 */
2516
2517                 if (state->revision == 0x8090)
2518                         value = dib8000_wait_lock(state, internal, 10, 10, 10); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2519                 else
2520                         value = dib8000_wait_lock(state, internal, 20, 20, 20); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2521
2522                 dib8000_write_word(state, 17, 0);
2523                 dib8000_write_word(state, 18, 200); /* P_search_rstst = 200 */
2524                 dib8000_write_word(state, 19, 0);
2525                 dib8000_write_word(state, 20, 400); /* P_search_rstend = 400 */
2526                 dib8000_write_word(state, 21, (value >> 16) & 0xffff); /* P_search_checkst */
2527                 dib8000_write_word(state, 22, value & 0xffff);
2528
2529                 if (state->revision == 0x8090)
2530                         dib8000_write_word(state, 32, (dib8000_read_word(state, 32) & 0xf0ff) | (0 << 8)); /* P_corm_alpha = 0 */
2531                 else
2532                         dib8000_write_word(state, 32, (dib8000_read_word(state, 32) & 0xf0ff) | (9 << 8)); /* P_corm_alpha = 3 */
2533                 dib8000_write_word(state, 355, 2); /* P_search_param_max = 2 */
2534
2535                 /* P_search_param_select = (1 | 1<<4 | 1 << 8) */
2536                 dib8000_write_word(state, 356, 0);
2537                 dib8000_write_word(state, 357, 0x111);
2538
2539                 dib8000_write_word(state, 770, (dib8000_read_word(state, 770) & 0xdfff) | (1 << 13)); /* P_restart_ccg = 1 */
2540                 dib8000_write_word(state, 770, (dib8000_read_word(state, 770) & 0xdfff) | (0 << 13)); /* P_restart_ccg = 0 */
2541                 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x7ff) | (0 << 15) | (1 << 13)); /* P_restart_search = 0; */
2542         } else if ((state->revision >= 0x8002) &&
2543                    (state->autosearch_state == AS_SEARCHING_GUARD)) {
2544                 c->transmission_mode = TRANSMISSION_MODE_8K;
2545                 c->guard_interval = GUARD_INTERVAL_1_8;
2546                 c->inversion = 0;
2547                 c->layer[0].modulation = QAM_64;
2548                 c->layer[0].fec = FEC_2_3;
2549                 c->layer[0].interleaving = 0;
2550                 c->layer[0].segment_count = 13;
2551
2552                 slist = 16;
2553                 c->transmission_mode = state->found_nfft;
2554
2555                 dib8000_set_isdbt_common_channel(state, slist, 1);
2556
2557                 /* set lock_mask values */
2558                 dib8000_write_word(state, 6, 0x4);
2559                 if (state->revision == 0x8090)
2560                         dib8000_write_word(state, 7, ((1 << 12) | (1 << 11) | (1 << 10)));/* tmcc_dec_lock, tmcc_sync_lock, tmcc_data_lock, tmcc_bch_uncor */
2561                 else
2562                         dib8000_write_word(state, 7, 0x8);
2563                 dib8000_write_word(state, 8, 0x1000);
2564
2565                 /* set lock_mask wait time values */
2566                 if (state->revision == 0x8090)
2567                         dib8000_wait_lock(state, internal, 50, 100, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2568                 else
2569                         dib8000_wait_lock(state, internal, 50, 200, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2570
2571                 dib8000_write_word(state, 355, 3); /* P_search_param_max = 3 */
2572
2573                 /* P_search_param_select = 0xf; look for the 4 different guard intervals */
2574                 dib8000_write_word(state, 356, 0);
2575                 dib8000_write_word(state, 357, 0xf);
2576
2577                 value = dib8000_read_word(state, 0);
2578                 dib8000_write_word(state, 0, (u16)((1 << 15) | value));
2579                 dib8000_read_word(state, 1284);  /* reset the INT. n_irq_pending */
2580                 dib8000_write_word(state, 0, (u16)value);
2581         } else {
2582                 c->inversion = 0;
2583                 c->layer[0].modulation = QAM_64;
2584                 c->layer[0].fec = FEC_2_3;
2585                 c->layer[0].interleaving = 0;
2586                 c->layer[0].segment_count = 13;
2587                 if (!c->isdbt_sb_mode)
2588                         c->layer[0].segment_count = 13;
2589
2590                 /* choose the right list, in sb, always do everything */
2591                 if (c->isdbt_sb_mode) {
2592                         slist = 7;
2593                         dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));
2594                 } else {
2595                         if (c->guard_interval == GUARD_INTERVAL_AUTO) {
2596                                 if (c->transmission_mode == TRANSMISSION_MODE_AUTO) {
2597                                         c->transmission_mode = TRANSMISSION_MODE_8K;
2598                                         c->guard_interval = GUARD_INTERVAL_1_8;
2599                                         slist = 7;
2600                                         dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));  /* P_mode = 1 to have autosearch start ok with mode2 */
2601                                 } else {
2602                                         c->guard_interval = GUARD_INTERVAL_1_8;
2603                                         slist = 3;
2604                                 }
2605                         } else {
2606                                 if (c->transmission_mode == TRANSMISSION_MODE_AUTO) {
2607                                         c->transmission_mode = TRANSMISSION_MODE_8K;
2608                                         slist = 2;
2609                                         dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));  /* P_mode = 1 */
2610                                 } else
2611                                         slist = 0;
2612                         }
2613                 }
2614                 dprintk("Using list for autosearch : %d\n", slist);
2615
2616                 dib8000_set_isdbt_common_channel(state, slist, 1);
2617
2618                 /* set lock_mask values */
2619                 dib8000_write_word(state, 6, 0x4);
2620                 if (state->revision == 0x8090)
2621                         dib8000_write_word(state, 7, (1 << 12) | (1 << 11) | (1 << 10));
2622                 else
2623                         dib8000_write_word(state, 7, 0x8);
2624                 dib8000_write_word(state, 8, 0x1000);
2625
2626                 /* set lock_mask wait time values */
2627                 if (state->revision == 0x8090)
2628                         dib8000_wait_lock(state, internal, 50, 200, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2629                 else
2630                         dib8000_wait_lock(state, internal, 50, 100, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2631
2632                 value = dib8000_read_word(state, 0);
2633                 dib8000_write_word(state, 0, (u16)((1 << 15) | value));
2634                 dib8000_read_word(state, 1284);  /* reset the INT. n_irq_pending */
2635                 dib8000_write_word(state, 0, (u16)value);
2636         }
2637         return 0;
2638 }
2639
2640 static int dib8000_autosearch_irq(struct dvb_frontend *fe)
2641 {
2642         struct dib8000_state *state = fe->demodulator_priv;
2643         u16 irq_pending = dib8000_read_word(state, 1284);
2644
2645         if ((state->revision >= 0x8002) &&
2646             (state->autosearch_state == AS_SEARCHING_FFT)) {
2647                 if (irq_pending & 0x1) {
2648                         dprintk("dib8000_autosearch_irq: max correlation result available\n");
2649                         return 3;
2650                 }
2651         } else {
2652                 if (irq_pending & 0x1) {        /* failed */
2653                         dprintk("dib8000_autosearch_irq failed\n");
2654                         return 1;
2655                 }
2656
2657                 if (irq_pending & 0x2) {        /* succeeded */
2658                         dprintk("dib8000_autosearch_irq succeeded\n");
2659                         return 2;
2660                 }
2661         }
2662
2663         return 0;               // still pending
2664 }
2665
2666 static void dib8000_viterbi_state(struct dib8000_state *state, u8 onoff)
2667 {
2668         u16 tmp;
2669
2670         tmp = dib8000_read_word(state, 771);
2671         if (onoff) /* start P_restart_chd : channel_decoder */
2672                 dib8000_write_word(state, 771, tmp & 0xfffd);
2673         else /* stop P_restart_chd : channel_decoder */
2674                 dib8000_write_word(state, 771, tmp | (1<<1));
2675 }
2676
2677 static void dib8000_set_dds(struct dib8000_state *state, s32 offset_khz)
2678 {
2679         s16 unit_khz_dds_val;
2680         u32 abs_offset_khz = abs(offset_khz);
2681         u32 dds = state->cfg.pll->ifreq & 0x1ffffff;
2682         u8 invert = !!(state->cfg.pll->ifreq & (1 << 25));
2683         u8 ratio;
2684
2685         if (state->revision == 0x8090) {
2686                 ratio = 4;
2687                 unit_khz_dds_val = (1<<26) / (dib8000_read32(state, 23) / 1000);
2688                 if (offset_khz < 0)
2689                         dds = (1 << 26) - (abs_offset_khz * unit_khz_dds_val);
2690                 else
2691                         dds = (abs_offset_khz * unit_khz_dds_val);
2692
2693                 if (invert)
2694                         dds = (1<<26) - dds;
2695         } else {
2696                 ratio = 2;
2697                 unit_khz_dds_val = (u16) (67108864 / state->cfg.pll->internal);
2698
2699                 if (offset_khz < 0)
2700                         unit_khz_dds_val *= -1;
2701
2702                 /* IF tuner */
2703                 if (invert)
2704                         dds -= abs_offset_khz * unit_khz_dds_val;
2705                 else
2706                         dds += abs_offset_khz * unit_khz_dds_val;
2707         }
2708
2709         dprintk("setting a DDS frequency offset of %c%dkHz\n", invert ? '-' : ' ', dds / unit_khz_dds_val);
2710
2711         if (abs_offset_khz <= (state->cfg.pll->internal / ratio)) {
2712                 /* Max dds offset is the half of the demod freq */
2713                 dib8000_write_word(state, 26, invert);
2714                 dib8000_write_word(state, 27, (u16)(dds >> 16) & 0x1ff);
2715                 dib8000_write_word(state, 28, (u16)(dds & 0xffff));
2716         }
2717 }
2718
2719 static void dib8000_set_frequency_offset(struct dib8000_state *state)
2720 {
2721         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2722         int i;
2723         u32 current_rf;
2724         int total_dds_offset_khz;
2725
2726         if (state->fe[0]->ops.tuner_ops.get_frequency)
2727                 state->fe[0]->ops.tuner_ops.get_frequency(state->fe[0], &current_rf);
2728         else
2729                 current_rf = c->frequency;
2730         current_rf /= 1000;
2731         total_dds_offset_khz = (int)current_rf - (int)c->frequency / 1000;
2732
2733         if (c->isdbt_sb_mode) {
2734                 state->subchannel = c->isdbt_sb_subchannel;
2735
2736                 i = dib8000_read_word(state, 26) & 1; /* P_dds_invspec */
2737                 dib8000_write_word(state, 26, c->inversion ^ i);
2738
2739                 if (state->cfg.pll->ifreq == 0) { /* low if tuner */
2740                         if ((c->inversion ^ i) == 0)
2741                                 dib8000_write_word(state, 26, dib8000_read_word(state, 26) | 1);
2742                 } else {
2743                         if ((c->inversion ^ i) == 0)
2744                                 total_dds_offset_khz *= -1;
2745                 }
2746         }
2747
2748         dprintk("%dkhz tuner offset (frequency = %dHz & current_rf = %dHz) total_dds_offset_hz = %d\n", c->frequency - current_rf, c->frequency, current_rf, total_dds_offset_khz);
2749
2750         /* apply dds offset now */
2751         dib8000_set_dds(state, total_dds_offset_khz);
2752 }
2753
2754 static u16 LUT_isdbt_symbol_duration[4] = { 26, 101, 63 };
2755
2756 static u32 dib8000_get_symbol_duration(struct dib8000_state *state)
2757 {
2758         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2759         u16 i;
2760
2761         switch (c->transmission_mode) {
2762         case TRANSMISSION_MODE_2K:
2763                         i = 0;
2764                         break;
2765         case TRANSMISSION_MODE_4K:
2766                         i = 2;
2767                         break;
2768         default:
2769         case TRANSMISSION_MODE_AUTO:
2770         case TRANSMISSION_MODE_8K:
2771                         i = 1;
2772                         break;
2773         }
2774
2775         return (LUT_isdbt_symbol_duration[i] / (c->bandwidth_hz / 1000)) + 1;
2776 }
2777
2778 static void dib8000_set_isdbt_loop_params(struct dib8000_state *state, enum param_loop_step loop_step)
2779 {
2780         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2781         u16 reg_32 = 0, reg_37 = 0;
2782
2783         switch (loop_step) {
2784         case LOOP_TUNE_1:
2785                         if (c->isdbt_sb_mode)  {
2786                                 if (c->isdbt_partial_reception == 0) {
2787                                         reg_32 = ((11 - state->mode) << 12) | (6 << 8) | 0x40; /* P_timf_alpha = (11-P_mode), P_corm_alpha=6, P_corm_thres=0x40 */
2788                                         reg_37 = (3 << 5) | (0 << 4) | (10 - state->mode); /* P_ctrl_pha_off_max=3   P_ctrl_sfreq_inh =0  P_ctrl_sfreq_step = (10-P_mode)  */
2789                                 } else { /* Sound Broadcasting mode 3 seg */
2790                                         reg_32 = ((10 - state->mode) << 12) | (6 << 8) | 0x60; /* P_timf_alpha = (10-P_mode), P_corm_alpha=6, P_corm_thres=0x60 */
2791                                         reg_37 = (3 << 5) | (0 << 4) | (9 - state->mode); /* P_ctrl_pha_off_max=3   P_ctrl_sfreq_inh =0  P_ctrl_sfreq_step = (9-P_mode)  */
2792                                 }
2793                         } else { /* 13-seg start conf offset loop parameters */
2794                                 reg_32 = ((9 - state->mode) << 12) | (6 << 8) | 0x80; /* P_timf_alpha = (9-P_mode, P_corm_alpha=6, P_corm_thres=0x80 */
2795                                 reg_37 = (3 << 5) | (0 << 4) | (8 - state->mode); /* P_ctrl_pha_off_max=3   P_ctrl_sfreq_inh =0  P_ctrl_sfreq_step = 9  */
2796                         }
2797                         break;
2798         case LOOP_TUNE_2:
2799                         if (c->isdbt_sb_mode)  {
2800                                 if (c->isdbt_partial_reception == 0) {  /* Sound Broadcasting mode 1 seg */
2801                                         reg_32 = ((13-state->mode) << 12) | (6 << 8) | 0x40; /* P_timf_alpha = (13-P_mode) , P_corm_alpha=6, P_corm_thres=0x40*/
2802                                         reg_37 = (12-state->mode) | ((5 + state->mode) << 5);
2803                                 } else {  /* Sound Broadcasting mode 3 seg */
2804                                         reg_32 = ((12-state->mode) << 12) | (6 << 8) | 0x60; /* P_timf_alpha = (12-P_mode) , P_corm_alpha=6, P_corm_thres=0x60 */
2805                                         reg_37 = (11-state->mode) | ((5 + state->mode) << 5);
2806                                 }
2807                         } else {  /* 13 seg */
2808                                 reg_32 = ((11-state->mode) << 12) | (6 << 8) | 0x80; /* P_timf_alpha = 8 , P_corm_alpha=6, P_corm_thres=0x80 */
2809                                 reg_37 = ((5+state->mode) << 5) | (10 - state->mode);
2810                         }
2811                         break;
2812         }
2813         dib8000_write_word(state, 32, reg_32);
2814         dib8000_write_word(state, 37, reg_37);
2815 }
2816
2817 static void dib8000_demod_restart(struct dib8000_state *state)
2818 {
2819         dib8000_write_word(state, 770, 0x4000);
2820         dib8000_write_word(state, 770, 0x0000);
2821         return;
2822 }
2823
2824 static void dib8000_set_sync_wait(struct dib8000_state *state)
2825 {
2826         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2827         u16 sync_wait = 64;
2828
2829         /* P_dvsy_sync_wait - reuse mode */
2830         switch (c->transmission_mode) {
2831         case TRANSMISSION_MODE_8K:
2832                         sync_wait = 256;
2833                         break;
2834         case TRANSMISSION_MODE_4K:
2835                         sync_wait = 128;
2836                         break;
2837         default:
2838         case TRANSMISSION_MODE_2K:
2839                         sync_wait =  64;
2840                         break;
2841         }
2842
2843         if (state->cfg.diversity_delay == 0)
2844                 sync_wait = (sync_wait * (1 << (c->guard_interval)) * 3) / 2 + 48; /* add 50% SFN margin + compensate for one DVSY-fifo */
2845         else
2846                 sync_wait = (sync_wait * (1 << (c->guard_interval)) * 3) / 2 + state->cfg.diversity_delay; /* add 50% SFN margin + compensate for DVSY-fifo */
2847
2848         dib8000_write_word(state, 273, (dib8000_read_word(state, 273) & 0x000f) | (sync_wait << 4));
2849 }
2850
2851 static unsigned long dib8000_get_timeout(struct dib8000_state *state, u32 delay, enum timeout_mode mode)
2852 {
2853         if (mode == SYMBOL_DEPENDENT_ON)
2854                 delay *= state->symbol_duration;
2855
2856         return jiffies + usecs_to_jiffies(delay * 100);
2857 }
2858
2859 static s32 dib8000_get_status(struct dvb_frontend *fe)
2860 {
2861         struct dib8000_state *state = fe->demodulator_priv;
2862         return state->status;
2863 }
2864
2865 static enum frontend_tune_state dib8000_get_tune_state(struct dvb_frontend *fe)
2866 {
2867         struct dib8000_state *state = fe->demodulator_priv;
2868         return state->tune_state;
2869 }
2870
2871 static int dib8000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
2872 {
2873         struct dib8000_state *state = fe->demodulator_priv;
2874
2875         state->tune_state = tune_state;
2876         return 0;
2877 }
2878
2879 static int dib8000_tune_restart_from_demod(struct dvb_frontend *fe)
2880 {
2881         struct dib8000_state *state = fe->demodulator_priv;
2882
2883         state->status = FE_STATUS_TUNE_PENDING;
2884         state->tune_state = CT_DEMOD_START;
2885         return 0;
2886 }
2887
2888 static u16 dib8000_read_lock(struct dvb_frontend *fe)
2889 {
2890         struct dib8000_state *state = fe->demodulator_priv;
2891
2892         if (state->revision == 0x8090)
2893                 return dib8000_read_word(state, 570);
2894         return dib8000_read_word(state, 568);
2895 }
2896
2897 static int dib8090p_init_sdram(struct dib8000_state *state)
2898 {
2899         u16 reg = 0;
2900         dprintk("init sdram\n");
2901
2902         reg = dib8000_read_word(state, 274) & 0xfff0;
2903         dib8000_write_word(state, 274, reg | 0x7); /* P_dintlv_delay_ram = 7 because of MobileSdram */
2904
2905         dib8000_write_word(state, 1803, (7 << 2));
2906
2907         reg = dib8000_read_word(state, 1280);
2908         dib8000_write_word(state, 1280,  reg | (1 << 2)); /* force restart P_restart_sdram */
2909         dib8000_write_word(state, 1280,  reg); /* release restart P_restart_sdram */
2910
2911         return 0;
2912 }
2913
2914 /**
2915  * is_manual_mode - Check if TMCC should be used for parameters settings
2916  * @c:  struct dvb_frontend_properties
2917  *
2918  * By default, TMCC table should be used for parameter settings on most
2919  * usercases. However, sometimes it is desirable to lock the demod to
2920  * use the manual parameters.
2921  *
2922  * On manual mode, the current dib8000_tune state machine is very restrict:
2923  * It requires that both per-layer and per-transponder parameters to be
2924  * properly specified, otherwise the device won't lock.
2925  *
2926  * Check if all those conditions are properly satisfied before allowing
2927  * the device to use the manual frequency lock mode.
2928  */
2929 static int is_manual_mode(struct dtv_frontend_properties *c)
2930 {
2931         int i, n_segs = 0;
2932
2933         /* Use auto mode on DVB-T compat mode */
2934         if (c->delivery_system != SYS_ISDBT)
2935                 return 0;
2936
2937         /*
2938          * Transmission mode is only detected on auto mode, currently
2939          */
2940         if (c->transmission_mode == TRANSMISSION_MODE_AUTO) {
2941                 dprintk("transmission mode auto\n");
2942                 return 0;
2943         }
2944
2945         /*
2946          * Guard interval is only detected on auto mode, currently
2947          */
2948         if (c->guard_interval == GUARD_INTERVAL_AUTO) {
2949                 dprintk("guard interval auto\n");
2950                 return 0;
2951         }
2952
2953         /*
2954          * If no layer is enabled, assume auto mode, as at least one
2955          * layer should be enabled
2956          */
2957         if (!c->isdbt_layer_enabled) {
2958                 dprintk("no layer modulation specified\n");
2959                 return 0;
2960         }
2961
2962         /*
2963          * Check if the per-layer parameters aren't auto and
2964          * disable a layer if segment count is 0 or invalid.
2965          */
2966         for (i = 0; i < 3; i++) {
2967                 if (!(c->isdbt_layer_enabled & 1 << i))
2968                         continue;
2969
2970                 if ((c->layer[i].segment_count > 13) ||
2971                     (c->layer[i].segment_count == 0)) {
2972                         c->isdbt_layer_enabled &= ~(1 << i);
2973                         continue;
2974                 }
2975
2976                 n_segs += c->layer[i].segment_count;
2977
2978                 if ((c->layer[i].modulation == QAM_AUTO) ||
2979                     (c->layer[i].fec == FEC_AUTO)) {
2980                         dprintk("layer %c has either modulation or FEC auto\n",
2981                                 'A' + i);
2982                         return 0;
2983                 }
2984         }
2985
2986         /*
2987          * Userspace specified a wrong number of segments.
2988          *      fallback to auto mode.
2989          */
2990         if (n_segs == 0 || n_segs > 13) {
2991                 dprintk("number of segments is invalid\n");
2992                 return 0;
2993         }
2994
2995         /* Everything looks ok for manual mode */
2996         return 1;
2997 }
2998
2999 static int dib8000_tune(struct dvb_frontend *fe)
3000 {
3001         struct dib8000_state *state = fe->demodulator_priv;
3002         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3003         enum frontend_tune_state *tune_state = &state->tune_state;
3004
3005         u16 locks, deeper_interleaver = 0, i;
3006         int ret = 1; /* 1 symbol duration (in 100us unit) delay most of the time */
3007
3008         unsigned long *timeout = &state->timeout;
3009         unsigned long now = jiffies;
3010 #ifdef DIB8000_AGC_FREEZE
3011         u16 agc1, agc2;
3012 #endif
3013
3014         u32 corm[4] = {0, 0, 0, 0};
3015         u8 find_index, max_value;
3016
3017 #if 0
3018         if (*tune_state < CT_DEMOD_STOP)
3019                 dprintk("IN: context status = %d, TUNE_STATE %d autosearch step = %u jiffies = %lu\n",
3020                         state->channel_parameters_set, *tune_state, state->autosearch_state, now);
3021 #endif
3022
3023         switch (*tune_state) {
3024         case CT_DEMOD_START: /* 30 */
3025                 dib8000_reset_stats(fe);
3026
3027                 if (state->revision == 0x8090)
3028                         dib8090p_init_sdram(state);
3029                 state->status = FE_STATUS_TUNE_PENDING;
3030                 state->channel_parameters_set = is_manual_mode(c);
3031
3032                 dprintk("Tuning channel on %s search mode\n",
3033                         state->channel_parameters_set ? "manual" : "auto");
3034
3035                 dib8000_viterbi_state(state, 0); /* force chan dec in restart */
3036
3037                 /* Layer monitor */
3038                 dib8000_write_word(state, 285, dib8000_read_word(state, 285) & 0x60);
3039
3040                 dib8000_set_frequency_offset(state);
3041                 dib8000_set_bandwidth(fe, c->bandwidth_hz / 1000);
3042
3043                 if (state->channel_parameters_set == 0) { /* The channel struct is unknown, search it ! */
3044 #ifdef DIB8000_AGC_FREEZE
3045                         if (state->revision != 0x8090) {
3046                                 state->agc1_max = dib8000_read_word(state, 108);
3047                                 state->agc1_min = dib8000_read_word(state, 109);
3048                                 state->agc2_max = dib8000_read_word(state, 110);
3049                                 state->agc2_min = dib8000_read_word(state, 111);
3050                                 agc1 = dib8000_read_word(state, 388);
3051                                 agc2 = dib8000_read_word(state, 389);
3052                                 dib8000_write_word(state, 108, agc1);
3053                                 dib8000_write_word(state, 109, agc1);
3054                                 dib8000_write_word(state, 110, agc2);
3055                                 dib8000_write_word(state, 111, agc2);
3056                         }
3057 #endif
3058                         state->autosearch_state = AS_SEARCHING_FFT;
3059                         state->found_nfft = TRANSMISSION_MODE_AUTO;
3060                         state->found_guard = GUARD_INTERVAL_AUTO;
3061                         *tune_state = CT_DEMOD_SEARCH_NEXT;
3062                 } else { /* we already know the channel struct so TUNE only ! */
3063                         state->autosearch_state = AS_DONE;
3064                         *tune_state = CT_DEMOD_STEP_3;
3065                 }
3066                 state->symbol_duration = dib8000_get_symbol_duration(state);
3067                 break;
3068
3069         case CT_DEMOD_SEARCH_NEXT: /* 51 */
3070                 dib8000_autosearch_start(fe);
3071                 if (state->revision == 0x8090)
3072                         ret = 50;
3073                 else
3074                         ret = 15;
3075                 *tune_state = CT_DEMOD_STEP_1;
3076                 break;
3077
3078         case CT_DEMOD_STEP_1: /* 31 */
3079                 switch (dib8000_autosearch_irq(fe)) {
3080                 case 1: /* fail */
3081                         state->status = FE_STATUS_TUNE_FAILED;
3082                         state->autosearch_state = AS_DONE;
3083                         *tune_state = CT_DEMOD_STOP; /* else we are done here */
3084                         break;
3085                 case 2: /* Success */
3086                         state->status = FE_STATUS_FFT_SUCCESS; /* signal to the upper layer, that there was a channel found and the parameters can be read */
3087                         *tune_state = CT_DEMOD_STEP_3;
3088                         if (state->autosearch_state == AS_SEARCHING_GUARD)
3089                                 *tune_state = CT_DEMOD_STEP_2;
3090                         else
3091                                 state->autosearch_state = AS_DONE;
3092                         break;
3093                 case 3: /* Autosearch FFT max correlation endded */
3094                         *tune_state = CT_DEMOD_STEP_2;
3095                         break;
3096                 }
3097                 break;
3098
3099         case CT_DEMOD_STEP_2:
3100                 switch (state->autosearch_state) {
3101                 case AS_SEARCHING_FFT:
3102                         /* searching for the correct FFT */
3103                         if (state->revision == 0x8090) {
3104                                 corm[2] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597));
3105                                 corm[1] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599));
3106                                 corm[0] = (dib8000_read_word(state, 600) << 16) | (dib8000_read_word(state, 601));
3107                         } else {
3108                                 corm[2] = (dib8000_read_word(state, 594) << 16) | (dib8000_read_word(state, 595));
3109                                 corm[1] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597));
3110                                 corm[0] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599));
3111                         }
3112                         /* dprintk("corm fft: %u %u %u\n", corm[0], corm[1], corm[2]); */
3113
3114                         max_value = 0;
3115                         for (find_index = 1 ; find_index < 3 ; find_index++) {
3116                                 if (corm[max_value] < corm[find_index])
3117                                         max_value = find_index ;
3118                         }
3119
3120                         switch (max_value) {
3121                         case 0:
3122                                 state->found_nfft = TRANSMISSION_MODE_2K;
3123                                 break;
3124                         case 1:
3125                                 state->found_nfft = TRANSMISSION_MODE_4K;
3126                                 break;
3127                         case 2:
3128                         default:
3129                                 state->found_nfft = TRANSMISSION_MODE_8K;
3130                                 break;
3131                         }
3132                         /* dprintk("Autosearch FFT has found Mode %d\n", max_value + 1); */
3133
3134                         *tune_state = CT_DEMOD_SEARCH_NEXT;
3135                         state->autosearch_state = AS_SEARCHING_GUARD;
3136                         if (state->revision == 0x8090)
3137                                 ret = 50;
3138                         else
3139                                 ret = 10;
3140                         break;
3141                 case AS_SEARCHING_GUARD:
3142                         /* searching for the correct guard interval */
3143                         if (state->revision == 0x8090)
3144                                 state->found_guard = dib8000_read_word(state, 572) & 0x3;
3145                         else
3146                                 state->found_guard = dib8000_read_word(state, 570) & 0x3;
3147                         /* dprintk("guard interval found=%i\n", state->found_guard); */
3148
3149                         *tune_state = CT_DEMOD_STEP_3;
3150                         break;
3151                 default:
3152                         /* the demod should never be in this state */
3153                         state->status = FE_STATUS_TUNE_FAILED;
3154                         state->autosearch_state = AS_DONE;
3155                         *tune_state = CT_DEMOD_STOP; /* else we are done here */
3156                         break;
3157                 }
3158                 break;
3159
3160         case CT_DEMOD_STEP_3: /* 33 */
3161                 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_1);
3162                 dib8000_set_isdbt_common_channel(state, 0, 0);/* setting the known channel parameters here */
3163                 *tune_state = CT_DEMOD_STEP_4;
3164                 break;
3165
3166         case CT_DEMOD_STEP_4: /* (34) */
3167                 dib8000_demod_restart(state);
3168
3169                 dib8000_set_sync_wait(state);
3170                 dib8000_set_diversity_in(state->fe[0], state->diversity_onoff);
3171
3172                 locks = (dib8000_read_word(state, 180) >> 6) & 0x3f; /* P_coff_winlen ? */
3173                 /* coff should lock over P_coff_winlen ofdm symbols : give 3 times this length to lock */
3174                 *timeout = dib8000_get_timeout(state, 2 * locks, SYMBOL_DEPENDENT_ON);
3175                 *tune_state = CT_DEMOD_STEP_5;
3176                 break;
3177
3178         case CT_DEMOD_STEP_5: /* (35) */
3179                 locks = dib8000_read_lock(fe);
3180                 if (locks & (0x3 << 11)) { /* coff-lock and off_cpil_lock achieved */
3181                         dib8000_update_timf(state); /* we achieved a coff_cpil_lock - it's time to update the timf */
3182                         if (!state->differential_constellation) {
3183                                 /* 2 times lmod4_win_len + 10 symbols (pipe delay after coff + nb to compute a 1st correlation) */
3184                                 *timeout = dib8000_get_timeout(state, (20 * ((dib8000_read_word(state, 188)>>5)&0x1f)), SYMBOL_DEPENDENT_ON);
3185                                 *tune_state = CT_DEMOD_STEP_7;
3186                         } else {
3187                                 *tune_state = CT_DEMOD_STEP_8;
3188                         }
3189                 } else if (time_after(now, *timeout)) {
3190                         *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3191                 }
3192                 break;
3193
3194         case CT_DEMOD_STEP_6: /* (36)  if there is an input (diversity) */
3195                 if ((state->fe[1] != NULL) && (state->output_mode != OUTMODE_DIVERSITY)) {
3196                         /* if there is a diversity fe in input and this fe is has not already failed : wait here until this this fe has succedeed or failed */
3197                         if (dib8000_get_status(state->fe[1]) <= FE_STATUS_STD_SUCCESS) /* Something is locked on the input fe */
3198                                 *tune_state = CT_DEMOD_STEP_8; /* go for mpeg */
3199                         else if (dib8000_get_status(state->fe[1]) >= FE_STATUS_TUNE_TIME_TOO_SHORT) { /* fe in input failed also, break the current one */
3200                                 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3201                                 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3202                                 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3203                                 state->status = FE_STATUS_TUNE_FAILED;
3204                         }
3205                 } else {
3206                         dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3207                         dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3208                         *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3209                         state->status = FE_STATUS_TUNE_FAILED;
3210                 }
3211                 break;
3212
3213         case CT_DEMOD_STEP_7: /* 37 */
3214                 locks = dib8000_read_lock(fe);
3215                 if (locks & (1<<10)) { /* lmod4_lock */
3216                         ret = 14; /* wait for 14 symbols */
3217                         *tune_state = CT_DEMOD_STEP_8;
3218                 } else if (time_after(now, *timeout))
3219                         *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3220                 break;
3221
3222         case CT_DEMOD_STEP_8: /* 38 */
3223                 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3224                 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3225
3226                 /* mpeg will never lock on this condition because init_prbs is not set : search for it !*/
3227                 if (c->isdbt_sb_mode
3228                     && c->isdbt_sb_subchannel < 14
3229                     && !state->differential_constellation) {
3230                         state->subchannel = 0;
3231                         *tune_state = CT_DEMOD_STEP_11;
3232                 } else {
3233                         *tune_state = CT_DEMOD_STEP_9;
3234                         state->status = FE_STATUS_LOCKED;
3235                 }
3236                 break;
3237
3238         case CT_DEMOD_STEP_9: /* 39 */
3239                 if ((state->revision == 0x8090) || ((dib8000_read_word(state, 1291) >> 9) & 0x1)) { /* fe capable of deinterleaving : esram */
3240                         /* defines timeout for mpeg lock depending on interleaver length of longest layer */
3241                         for (i = 0; i < 3; i++) {
3242                                 if (c->layer[i].interleaving >= deeper_interleaver) {
3243                                         dprintk("layer%i: time interleaver = %d\n", i, c->layer[i].interleaving);
3244                                         if (c->layer[i].segment_count > 0) { /* valid layer */
3245                                                 deeper_interleaver = c->layer[0].interleaving;
3246                                                 state->longest_intlv_layer = i;
3247                                         }
3248                                 }
3249                         }
3250
3251                         if (deeper_interleaver == 0)
3252                                 locks = 2; /* locks is the tmp local variable name */
3253                         else if (deeper_interleaver == 3)
3254                                 locks = 8;
3255                         else
3256                                 locks = 2 * deeper_interleaver;
3257
3258                         if (state->diversity_onoff != 0) /* because of diversity sync */
3259                                 locks *= 2;
3260
3261                         *timeout = now + msecs_to_jiffies(200 * locks); /* give the mpeg lock 800ms if sram is present */
3262                         dprintk("Deeper interleaver mode = %d on layer %d : timeout mult factor = %d => will use timeout = %ld\n",
3263                                 deeper_interleaver, state->longest_intlv_layer, locks, *timeout);
3264
3265                         *tune_state = CT_DEMOD_STEP_10;
3266                 } else
3267                         *tune_state = CT_DEMOD_STOP;
3268                 break;
3269
3270         case CT_DEMOD_STEP_10: /* 40 */
3271                 locks = dib8000_read_lock(fe);
3272                 if (locks&(1<<(7-state->longest_intlv_layer))) { /* mpeg lock : check the longest one */
3273                         dprintk("ISDB-T layer locks: Layer A %s, Layer B %s, Layer C %s\n",
3274                                 c->layer[0].segment_count ? (locks >> 7) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3275                                 c->layer[1].segment_count ? (locks >> 6) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3276                                 c->layer[2].segment_count ? (locks >> 5) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled");
3277                         if (c->isdbt_sb_mode
3278                             && c->isdbt_sb_subchannel < 14
3279                             && !state->differential_constellation)
3280                                 /* signal to the upper layer, that there was a channel found and the parameters can be read */
3281                                 state->status = FE_STATUS_DEMOD_SUCCESS;
3282                         else
3283                                 state->status = FE_STATUS_DATA_LOCKED;
3284                         *tune_state = CT_DEMOD_STOP;
3285                 } else if (time_after(now, *timeout)) {
3286                         if (c->isdbt_sb_mode
3287                             && c->isdbt_sb_subchannel < 14
3288                             && !state->differential_constellation) { /* continue to try init prbs autosearch */
3289                                 state->subchannel += 3;
3290                                 *tune_state = CT_DEMOD_STEP_11;
3291                         } else { /* we are done mpeg of the longest interleaver xas not locking but let's try if an other layer has locked in the same time */
3292                                 if (locks & (0x7 << 5)) {
3293                                         dprintk("Not all ISDB-T layers locked in %d ms: Layer A %s, Layer B %s, Layer C %s\n",
3294                                                 jiffies_to_msecs(now - *timeout),
3295                                                 c->layer[0].segment_count ? (locks >> 7) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3296                                                 c->layer[1].segment_count ? (locks >> 6) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3297                                                 c->layer[2].segment_count ? (locks >> 5) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled");
3298
3299                                         state->status = FE_STATUS_DATA_LOCKED;
3300                                 } else
3301                                         state->status = FE_STATUS_TUNE_FAILED;
3302                                 *tune_state = CT_DEMOD_STOP;
3303                         }
3304                 }
3305                 break;
3306
3307         case CT_DEMOD_STEP_11:  /* 41 : init prbs autosearch */
3308                 if (state->subchannel <= 41) {
3309                         dib8000_set_subchannel_prbs(state, dib8000_get_init_prbs(state, state->subchannel));
3310                         *tune_state = CT_DEMOD_STEP_9;
3311                 } else {
3312                         *tune_state = CT_DEMOD_STOP;
3313                         state->status = FE_STATUS_TUNE_FAILED;
3314                 }
3315                 break;
3316
3317         default:
3318                 break;
3319         }
3320
3321         /* tuning is finished - cleanup the demod */
3322         switch (*tune_state) {
3323         case CT_DEMOD_STOP: /* (42) */
3324 #ifdef DIB8000_AGC_FREEZE
3325                 if ((state->revision != 0x8090) && (state->agc1_max != 0)) {
3326                         dib8000_write_word(state, 108, state->agc1_max);
3327                         dib8000_write_word(state, 109, state->agc1_min);
3328                         dib8000_write_word(state, 110, state->agc2_max);
3329                         dib8000_write_word(state, 111, state->agc2_min);
3330                         state->agc1_max = 0;
3331                         state->agc1_min = 0;
3332                         state->agc2_max = 0;
3333                         state->agc2_min = 0;
3334                 }
3335 #endif
3336                 ret = 0;
3337                 break;
3338         default:
3339                 break;
3340         }
3341
3342         if ((ret > 0) && (*tune_state > CT_DEMOD_STEP_3))
3343                 return ret * state->symbol_duration;
3344         if ((ret > 0) && (ret < state->symbol_duration))
3345                 return state->symbol_duration; /* at least one symbol */
3346         return ret;
3347 }
3348
3349 static int dib8000_wakeup(struct dvb_frontend *fe)
3350 {
3351         struct dib8000_state *state = fe->demodulator_priv;
3352         u8 index_frontend;
3353         int ret;
3354
3355         dib8000_set_power_mode(state, DIB8000_POWER_ALL);
3356         dib8000_set_adc_state(state, DIBX000_ADC_ON);
3357         if (dib8000_set_adc_state(state, DIBX000_SLOW_ADC_ON) != 0)
3358                 dprintk("could not start Slow ADC\n");
3359
3360         if (state->revision == 0x8090)
3361                 dib8000_sad_calib(state);
3362
3363         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3364                 ret = state->fe[index_frontend]->ops.init(state->fe[index_frontend]);
3365                 if (ret < 0)
3366                         return ret;
3367         }
3368
3369         return 0;
3370 }
3371
3372 static int dib8000_sleep(struct dvb_frontend *fe)
3373 {
3374         struct dib8000_state *state = fe->demodulator_priv;
3375         u8 index_frontend;
3376         int ret;
3377
3378         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3379                 ret = state->fe[index_frontend]->ops.sleep(state->fe[index_frontend]);
3380                 if (ret < 0)
3381                         return ret;
3382         }
3383
3384         if (state->revision != 0x8090)
3385                 dib8000_set_output_mode(fe, OUTMODE_HIGH_Z);
3386         dib8000_set_power_mode(state, DIB8000_POWER_INTERFACE_ONLY);
3387         return dib8000_set_adc_state(state, DIBX000_SLOW_ADC_OFF) | dib8000_set_adc_state(state, DIBX000_ADC_OFF);
3388 }
3389
3390 static int dib8000_read_status(struct dvb_frontend *fe, enum fe_status *stat);
3391
3392 static int dib8000_get_frontend(struct dvb_frontend *fe,
3393                                 struct dtv_frontend_properties *c)
3394 {
3395         struct dib8000_state *state = fe->demodulator_priv;
3396         u16 i, val = 0;
3397         enum fe_status stat = 0;
3398         u8 index_frontend, sub_index_frontend;
3399
3400         c->bandwidth_hz = 6000000;
3401
3402         /*
3403          * If called to early, get_frontend makes dib8000_tune to either
3404          * not lock or not sync. This causes dvbv5-scan/dvbv5-zap to fail.
3405          * So, let's just return if frontend 0 has not locked.
3406          */
3407         dib8000_read_status(fe, &stat);
3408         if (!(stat & FE_HAS_SYNC))
3409                 return 0;
3410
3411         dprintk("dib8000_get_frontend: TMCC lock\n");
3412         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3413                 state->fe[index_frontend]->ops.read_status(state->fe[index_frontend], &stat);
3414                 if (stat&FE_HAS_SYNC) {
3415                         dprintk("TMCC lock on the slave%i\n", index_frontend);
3416                         /* synchronize the cache with the other frontends */
3417                         state->fe[index_frontend]->ops.get_frontend(state->fe[index_frontend], c);
3418                         for (sub_index_frontend = 0; (sub_index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[sub_index_frontend] != NULL); sub_index_frontend++) {
3419                                 if (sub_index_frontend != index_frontend) {
3420                                         state->fe[sub_index_frontend]->dtv_property_cache.isdbt_sb_mode = state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode;
3421                                         state->fe[sub_index_frontend]->dtv_property_cache.inversion = state->fe[index_frontend]->dtv_property_cache.inversion;
3422                                         state->fe[sub_index_frontend]->dtv_property_cache.transmission_mode = state->fe[index_frontend]->dtv_property_cache.transmission_mode;
3423                                         state->fe[sub_index_frontend]->dtv_property_cache.guard_interval = state->fe[index_frontend]->dtv_property_cache.guard_interval;
3424                                         state->fe[sub_index_frontend]->dtv_property_cache.isdbt_partial_reception = state->fe[index_frontend]->dtv_property_cache.isdbt_partial_reception;
3425                                         for (i = 0; i < 3; i++) {
3426                                                 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].segment_count = state->fe[index_frontend]->dtv_property_cache.layer[i].segment_count;
3427                                                 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].interleaving = state->fe[index_frontend]->dtv_property_cache.layer[i].interleaving;
3428                                                 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].fec = state->fe[index_frontend]->dtv_property_cache.layer[i].fec;
3429                                                 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].modulation = state->fe[index_frontend]->dtv_property_cache.layer[i].modulation;
3430                                         }
3431                                 }
3432                         }
3433                         return 0;
3434                 }
3435         }
3436
3437         c->isdbt_sb_mode = dib8000_read_word(state, 508) & 0x1;
3438
3439         if (state->revision == 0x8090)
3440                 val = dib8000_read_word(state, 572);
3441         else
3442                 val = dib8000_read_word(state, 570);
3443         c->inversion = (val & 0x40) >> 6;
3444         switch ((val & 0x30) >> 4) {
3445         case 1:
3446                 c->transmission_mode = TRANSMISSION_MODE_2K;
3447                 dprintk("dib8000_get_frontend: transmission mode 2K\n");
3448                 break;
3449         case 2:
3450                 c->transmission_mode = TRANSMISSION_MODE_4K;
3451                 dprintk("dib8000_get_frontend: transmission mode 4K\n");
3452                 break;
3453         case 3:
3454         default:
3455                 c->transmission_mode = TRANSMISSION_MODE_8K;
3456                 dprintk("dib8000_get_frontend: transmission mode 8K\n");
3457                 break;
3458         }
3459
3460         switch (val & 0x3) {
3461         case 0:
3462                 c->guard_interval = GUARD_INTERVAL_1_32;
3463                 dprintk("dib8000_get_frontend: Guard Interval = 1/32\n");
3464                 break;
3465         case 1:
3466                 c->guard_interval = GUARD_INTERVAL_1_16;
3467                 dprintk("dib8000_get_frontend: Guard Interval = 1/16\n");
3468                 break;
3469         case 2:
3470                 dprintk("dib8000_get_frontend: Guard Interval = 1/8\n");
3471                 c->guard_interval = GUARD_INTERVAL_1_8;
3472                 break;
3473         case 3:
3474                 dprintk("dib8000_get_frontend: Guard Interval = 1/4\n");
3475                 c->guard_interval = GUARD_INTERVAL_1_4;
3476                 break;
3477         }
3478
3479         val = dib8000_read_word(state, 505);
3480         c->isdbt_partial_reception = val & 1;
3481         dprintk("dib8000_get_frontend: partial_reception = %d\n", c->isdbt_partial_reception);
3482
3483         for (i = 0; i < 3; i++) {
3484                 int show;
3485
3486                 val = dib8000_read_word(state, 493 + i) & 0x0f;
3487                 c->layer[i].segment_count = val;
3488
3489                 if (val == 0 || val > 13)
3490                         show = 0;
3491                 else
3492                         show = 1;
3493
3494                 if (show)
3495                         dprintk("dib8000_get_frontend: Layer %d segments = %d\n",
3496                                 i, c->layer[i].segment_count);
3497
3498                 val = dib8000_read_word(state, 499 + i) & 0x3;
3499                 /* Interleaving can be 0, 1, 2 or 4 */
3500                 if (val == 3)
3501                         val = 4;
3502                 c->layer[i].interleaving = val;
3503                 if (show)
3504                         dprintk("dib8000_get_frontend: Layer %d time_intlv = %d\n",
3505                                 i, c->layer[i].interleaving);
3506
3507                 val = dib8000_read_word(state, 481 + i);
3508                 switch (val & 0x7) {
3509                 case 1:
3510                         c->layer[i].fec = FEC_1_2;
3511                         if (show)
3512                                 dprintk("dib8000_get_frontend: Layer %d Code Rate = 1/2\n", i);
3513                         break;
3514                 case 2:
3515                         c->layer[i].fec = FEC_2_3;
3516                         if (show)
3517                                 dprintk("dib8000_get_frontend: Layer %d Code Rate = 2/3\n", i);
3518                         break;
3519                 case 3:
3520                         c->layer[i].fec = FEC_3_4;
3521                         if (show)
3522                                 dprintk("dib8000_get_frontend: Layer %d Code Rate = 3/4\n", i);
3523                         break;
3524                 case 5:
3525                         c->layer[i].fec = FEC_5_6;
3526                         if (show)
3527                                 dprintk("dib8000_get_frontend: Layer %d Code Rate = 5/6\n", i);
3528                         break;
3529                 default:
3530                         c->layer[i].fec = FEC_7_8;
3531                         if (show)
3532                                 dprintk("dib8000_get_frontend: Layer %d Code Rate = 7/8\n", i);
3533                         break;
3534                 }
3535
3536                 val = dib8000_read_word(state, 487 + i);
3537                 switch (val & 0x3) {
3538                 case 0:
3539                         c->layer[i].modulation = DQPSK;
3540                         if (show)
3541                                 dprintk("dib8000_get_frontend: Layer %d DQPSK\n", i);
3542                         break;
3543                 case 1:
3544                         c->layer[i].modulation = QPSK;
3545                         if (show)
3546                                 dprintk("dib8000_get_frontend: Layer %d QPSK\n", i);
3547                         break;
3548                 case 2:
3549                         c->layer[i].modulation = QAM_16;
3550                         if (show)
3551                                 dprintk("dib8000_get_frontend: Layer %d QAM16\n", i);
3552                         break;
3553                 case 3:
3554                 default:
3555                         c->layer[i].modulation = QAM_64;
3556                         if (show)
3557                                 dprintk("dib8000_get_frontend: Layer %d QAM64\n", i);
3558                         break;
3559                 }
3560         }
3561
3562         /* synchronize the cache with the other frontends */
3563         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3564                 state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode = c->isdbt_sb_mode;
3565                 state->fe[index_frontend]->dtv_property_cache.inversion = c->inversion;
3566                 state->fe[index_frontend]->dtv_property_cache.transmission_mode = c->transmission_mode;
3567                 state->fe[index_frontend]->dtv_property_cache.guard_interval = c->guard_interval;
3568                 state->fe[index_frontend]->dtv_property_cache.isdbt_partial_reception = c->isdbt_partial_reception;
3569                 for (i = 0; i < 3; i++) {
3570                         state->fe[index_frontend]->dtv_property_cache.layer[i].segment_count = c->layer[i].segment_count;
3571                         state->fe[index_frontend]->dtv_property_cache.layer[i].interleaving = c->layer[i].interleaving;
3572                         state->fe[index_frontend]->dtv_property_cache.layer[i].fec = c->layer[i].fec;
3573                         state->fe[index_frontend]->dtv_property_cache.layer[i].modulation = c->layer[i].modulation;
3574                 }
3575         }
3576         return 0;
3577 }
3578
3579 static int dib8000_set_frontend(struct dvb_frontend *fe)
3580 {
3581         struct dib8000_state *state = fe->demodulator_priv;
3582         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3583         int l, i, active, time, time_slave = 0;
3584         u8 exit_condition, index_frontend;
3585         unsigned long delay, callback_time;
3586
3587         if (c->frequency == 0) {
3588                 dprintk("dib8000: must at least specify frequency\n");
3589                 return 0;
3590         }
3591
3592         if (c->bandwidth_hz == 0) {
3593                 dprintk("dib8000: no bandwidth specified, set to default\n");
3594                 c->bandwidth_hz = 6000000;
3595         }
3596
3597         for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3598                 /* synchronization of the cache */
3599                 state->fe[index_frontend]->dtv_property_cache.delivery_system = SYS_ISDBT;
3600                 memcpy(&state->fe[index_frontend]->dtv_property_cache, &fe->dtv_property_cache, sizeof(struct dtv_frontend_properties));
3601
3602                 /* set output mode and diversity input */
3603                 if (state->revision != 0x8090) {
3604                         dib8000_set_diversity_in(state->fe[index_frontend], 1);
3605                         if (index_frontend != 0)
3606                                 dib8000_set_output_mode(state->fe[index_frontend],
3607                                                 OUTMODE_DIVERSITY);
3608                         else
3609                                 dib8000_set_output_mode(state->fe[0], OUTMODE_HIGH_Z);
3610                 } else {
3611                         dib8096p_set_diversity_in(state->fe[index_frontend], 1);
3612                         if (index_frontend != 0)
3613                                 dib8096p_set_output_mode(state->fe[index_frontend],
3614                                                 OUTMODE_DIVERSITY);
3615                         else
3616                                 dib8096p_set_output_mode(state->fe[0], OUTMODE_HIGH_Z);
3617                 }
3618
3619                 /* tune the tuner */
3620                 if (state->fe[index_frontend]->ops.tuner_ops.set_params)
3621                         state->fe[index_frontend]->ops.tuner_ops.set_params(state->fe[index_frontend]);
3622
3623                 dib8000_set_tune_state(state->fe[index_frontend], CT_AGC_START);
3624         }
3625
3626         /* turn off the diversity of the last chip */
3627         if (state->revision != 0x8090)
3628                 dib8000_set_diversity_in(state->fe[index_frontend - 1], 0);
3629         else
3630                 dib8096p_set_diversity_in(state->fe[index_frontend - 1], 0);
3631
3632         /* start up the AGC */
3633         do {
3634                 time = dib8000_agc_startup(state->fe[0]);
3635                 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3636                         time_slave = dib8000_agc_startup(state->fe[index_frontend]);
3637                         if (time == 0)
3638                                 time = time_slave;
3639                         else if ((time_slave != 0) && (time_slave > time))
3640                                 time = time_slave;
3641                 }
3642                 if (time == 0)
3643                         break;
3644
3645                 /*
3646                  * Despite dib8000_agc_startup returns time at a 0.1 ms range,
3647                  * the actual sleep time depends on CONFIG_HZ. The worse case
3648                  * is when CONFIG_HZ=100. In such case, the minimum granularity
3649                  * is 10ms. On some real field tests, the tuner sometimes don't
3650                  * lock when this timer is lower than 10ms. So, enforce a 10ms
3651                  * granularity.
3652                  */
3653                 time = 10 * (time + 99)/100;
3654                 usleep_range(time * 1000, (time + 1) * 1000);
3655                 exit_condition = 1;
3656                 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3657                         if (dib8000_get_tune_state(state->fe[index_frontend]) != CT_AGC_STOP) {
3658                                 exit_condition = 0;
3659                                 break;
3660                         }
3661                 }
3662         } while (exit_condition == 0);
3663
3664         for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
3665                 dib8000_set_tune_state(state->fe[index_frontend], CT_DEMOD_START);
3666
3667         active = 1;
3668         do {
3669                 callback_time = 0;
3670                 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3671                         delay = dib8000_tune(state->fe[index_frontend]);
3672                         if (delay != 0) {
3673                                 delay = jiffies + usecs_to_jiffies(100 * delay);
3674                                 if (!callback_time || delay < callback_time)
3675                                         callback_time = delay;
3676                         }
3677
3678                         /* we are in autosearch */
3679                         if (state->channel_parameters_set == 0) { /* searching */
3680                                 if ((dib8000_get_status(state->fe[index_frontend]) == FE_STATUS_DEMOD_SUCCESS) || (dib8000_get_status(state->fe[index_frontend]) == FE_STATUS_FFT_SUCCESS)) {
3681                                         dprintk("autosearch succeeded on fe%i\n", index_frontend);
3682                                         dib8000_get_frontend(state->fe[index_frontend], c); /* we read the channel parameters from the frontend which was successful */
3683                                         state->channel_parameters_set = 1;
3684
3685                                         for (l = 0; (l < MAX_NUMBER_OF_FRONTENDS) && (state->fe[l] != NULL); l++) {
3686                                                 if (l != index_frontend) { /* and for all frontend except the successful one */
3687                                                         dprintk("Restarting frontend %d\n", l);
3688                                                         dib8000_tune_restart_from_demod(state->fe[l]);
3689
3690                                                         state->fe[l]->dtv_property_cache.isdbt_sb_mode = state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode;
3691                                                         state->fe[l]->dtv_property_cache.inversion = state->fe[index_frontend]->dtv_property_cache.inversion;
3692                                                         state->fe[l]->dtv_property_cache.transmission_mode = state->fe[index_frontend]->dtv_property_cache.transmission_mode;
3693                                                         state->fe[l]->dtv_property_cache.guard_interval = state->fe[index_frontend]->dtv_property_cache.guard_interval;
3694                                                         state->fe[l]->dtv_property_cache.isdbt_partial_reception = state->fe[index_frontend]->dtv_property_cache.isdbt_partial_reception;
3695                                                         for (i = 0; i < 3; i++) {
3696                                                                 state->fe[l]->dtv_property_cache.layer[i].segment_count = state->fe[index_frontend]->dtv_property_cache.layer[i].segment_count;
3697                                                                 state->fe[l]->dtv_property_cache.layer[i].interleaving = state->fe[index_frontend]->dtv_property_cache.layer[i].interleaving;
3698                                                                 state->fe[l]->dtv_property_cache.layer[i].fec = state->fe[index_frontend]->dtv_property_cache.layer[i].fec;
3699                                                                 state->fe[l]->dtv_property_cache.layer[i].modulation = state->fe[index_frontend]->dtv_property_cache.layer[i].modulation;
3700                                                         }
3701
3702                                                 }
3703                                         }
3704                                 }
3705                         }
3706                 }
3707                 /* tuning is done when the master frontend is done (failed or success) */
3708                 if (dib8000_get_status(state->fe[0]) == FE_STATUS_TUNE_FAILED ||
3709                                 dib8000_get_status(state->fe[0]) == FE_STATUS_LOCKED ||
3710                                 dib8000_get_status(state->fe[0]) == FE_STATUS_DATA_LOCKED) {
3711                         active = 0;
3712                         /* we need to wait for all frontends to be finished */
3713                         for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3714                                 if (dib8000_get_tune_state(state->fe[index_frontend]) != CT_DEMOD_STOP)
3715                                         active = 1;
3716                         }
3717                         if (active == 0)
3718                                 dprintk("tuning done with status %d\n", dib8000_get_status(state->fe[0]));
3719                 }
3720
3721                 if ((active == 1) && (callback_time == 0)) {
3722                         dprintk("strange callback time something went wrong\n");
3723                         active = 0;
3724                 }
3725
3726                 while ((active == 1) && (time_before(jiffies, callback_time)))
3727                         msleep(100);
3728         } while (active);
3729
3730         /* set output mode */
3731         if (state->revision != 0x8090)
3732                 dib8000_set_output_mode(state->fe[0], state->cfg.output_mode);
3733         else {
3734                 dib8096p_set_output_mode(state->fe[0], state->cfg.output_mode);
3735                 if (state->cfg.enMpegOutput == 0) {
3736                         dib8096p_setDibTxMux(state, MPEG_ON_DIBTX);
3737                         dib8096p_setHostBusMux(state, DIBTX_ON_HOSTBUS);
3738                 }
3739         }
3740
3741         return 0;
3742 }
3743
3744 static int dib8000_get_stats(struct dvb_frontend *fe, enum fe_status stat);
3745
3746 static int dib8000_read_status(struct dvb_frontend *fe, enum fe_status *stat)
3747 {
3748         struct dib8000_state *state = fe->demodulator_priv;
3749         u16 lock_slave = 0, lock;
3750         u8 index_frontend;
3751
3752         lock = dib8000_read_lock(fe);
3753         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
3754                 lock_slave |= dib8000_read_lock(state->fe[index_frontend]);
3755
3756         *stat = 0;
3757
3758         if (((lock >> 13) & 1) || ((lock_slave >> 13) & 1))
3759                 *stat |= FE_HAS_SIGNAL;
3760
3761         if (((lock >> 8) & 1) || ((lock_slave >> 8) & 1)) /* Equal */
3762                 *stat |= FE_HAS_CARRIER;
3763
3764         if ((((lock >> 1) & 0xf) == 0xf) || (((lock_slave >> 1) & 0xf) == 0xf)) /* TMCC_SYNC */
3765                 *stat |= FE_HAS_SYNC;
3766
3767         if ((((lock >> 12) & 1) || ((lock_slave >> 12) & 1)) && ((lock >> 5) & 7)) /* FEC MPEG */
3768                 *stat |= FE_HAS_LOCK;
3769
3770         if (((lock >> 12) & 1) || ((lock_slave >> 12) & 1)) {
3771                 lock = dib8000_read_word(state, 554); /* Viterbi Layer A */
3772                 if (lock & 0x01)
3773                         *stat |= FE_HAS_VITERBI;
3774
3775                 lock = dib8000_read_word(state, 555); /* Viterbi Layer B */
3776                 if (lock & 0x01)
3777                         *stat |= FE_HAS_VITERBI;
3778
3779                 lock = dib8000_read_word(state, 556); /* Viterbi Layer C */
3780                 if (lock & 0x01)
3781                         *stat |= FE_HAS_VITERBI;
3782         }
3783         dib8000_get_stats(fe, *stat);
3784
3785         return 0;
3786 }
3787
3788 static int dib8000_read_ber(struct dvb_frontend *fe, u32 * ber)
3789 {
3790         struct dib8000_state *state = fe->demodulator_priv;
3791
3792         /* 13 segments */
3793         if (state->revision == 0x8090)
3794                 *ber = (dib8000_read_word(state, 562) << 16) |
3795                         dib8000_read_word(state, 563);
3796         else
3797                 *ber = (dib8000_read_word(state, 560) << 16) |
3798                         dib8000_read_word(state, 561);
3799         return 0;
3800 }
3801
3802 static int dib8000_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
3803 {
3804         struct dib8000_state *state = fe->demodulator_priv;
3805
3806         /* packet error on 13 seg */
3807         if (state->revision == 0x8090)
3808                 *unc = dib8000_read_word(state, 567);
3809         else
3810                 *unc = dib8000_read_word(state, 565);
3811         return 0;
3812 }
3813
3814 static int dib8000_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
3815 {
3816         struct dib8000_state *state = fe->demodulator_priv;
3817         u8 index_frontend;
3818         u16 val;
3819
3820         *strength = 0;
3821         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3822                 state->fe[index_frontend]->ops.read_signal_strength(state->fe[index_frontend], &val);
3823                 if (val > 65535 - *strength)
3824                         *strength = 65535;
3825                 else
3826                         *strength += val;
3827         }
3828
3829         val = 65535 - dib8000_read_word(state, 390);
3830         if (val > 65535 - *strength)
3831                 *strength = 65535;
3832         else
3833                 *strength += val;
3834         return 0;
3835 }
3836
3837 static u32 dib8000_get_snr(struct dvb_frontend *fe)
3838 {
3839         struct dib8000_state *state = fe->demodulator_priv;
3840         u32 n, s, exp;
3841         u16 val;
3842
3843         if (state->revision != 0x8090)
3844                 val = dib8000_read_word(state, 542);
3845         else
3846                 val = dib8000_read_word(state, 544);
3847         n = (val >> 6) & 0xff;
3848         exp = (val & 0x3f);
3849         if ((exp & 0x20) != 0)
3850                 exp -= 0x40;
3851         n <<= exp+16;
3852
3853         if (state->revision != 0x8090)
3854                 val = dib8000_read_word(state, 543);
3855         else
3856                 val = dib8000_read_word(state, 545);
3857         s = (val >> 6) & 0xff;
3858         exp = (val & 0x3f);
3859         if ((exp & 0x20) != 0)
3860                 exp -= 0x40;
3861         s <<= exp+16;
3862
3863         if (n > 0) {
3864                 u32 t = (s/n) << 16;
3865                 return t + ((s << 16) - n*t) / n;
3866         }
3867         return 0xffffffff;
3868 }
3869
3870 static int dib8000_read_snr(struct dvb_frontend *fe, u16 * snr)
3871 {
3872         struct dib8000_state *state = fe->demodulator_priv;
3873         u8 index_frontend;
3874         u32 snr_master;
3875
3876         snr_master = dib8000_get_snr(fe);
3877         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
3878                 snr_master += dib8000_get_snr(state->fe[index_frontend]);
3879
3880         if ((snr_master >> 16) != 0) {
3881                 snr_master = 10*intlog10(snr_master>>16);
3882                 *snr = snr_master / ((1 << 24) / 10);
3883         }
3884         else
3885                 *snr = 0;
3886
3887         return 0;
3888 }
3889
3890 struct per_layer_regs {
3891         u16 lock, ber, per;
3892 };
3893
3894 static const struct per_layer_regs per_layer_regs[] = {
3895         { 554, 560, 562 },
3896         { 555, 576, 578 },
3897         { 556, 581, 583 },
3898 };
3899
3900 struct linear_segments {
3901         unsigned x;
3902         signed y;
3903 };
3904
3905 /*
3906  * Table to estimate signal strength in dBm.
3907  * This table was empirically determinated by measuring the signal
3908  * strength generated by a DTA-2111 RF generator directly connected into
3909  * a dib8076 device (a PixelView PV-D231U stick), using a good quality
3910  * 3 meters RC6 cable and good RC6 connectors.
3911  * The real value can actually be different on other devices, depending
3912  * on several factors, like if LNA is enabled or not, if diversity is
3913  * enabled, type of connectors, etc.
3914  * Yet, it is better to use this measure in dB than a random non-linear
3915  * percentage value, especially for antenna adjustments.
3916  * On my tests, the precision of the measure using this table is about
3917  * 0.5 dB, with sounds reasonable enough.
3918  */
3919 static struct linear_segments strength_to_db_table[] = {
3920         { 55953, 108500 },      /* -22.5 dBm */
3921         { 55394, 108000 },
3922         { 53834, 107000 },
3923         { 52863, 106000 },
3924         { 52239, 105000 },
3925         { 52012, 104000 },
3926         { 51803, 103000 },
3927         { 51566, 102000 },
3928         { 51356, 101000 },
3929         { 51112, 100000 },
3930         { 50869,  99000 },
3931         { 50600,  98000 },
3932         { 50363,  97000 },
3933         { 50117,  96000 },      /* -35 dBm */
3934         { 49889,  95000 },
3935         { 49680,  94000 },
3936         { 49493,  93000 },
3937         { 49302,  92000 },
3938         { 48929,  91000 },
3939         { 48416,  90000 },
3940         { 48035,  89000 },
3941         { 47593,  88000 },
3942         { 47282,  87000 },
3943         { 46953,  86000 },
3944         { 46698,  85000 },
3945         { 45617,  84000 },
3946         { 44773,  83000 },
3947         { 43845,  82000 },
3948         { 43020,  81000 },
3949         { 42010,  80000 },      /* -51 dBm */
3950         {     0,      0 },
3951 };
3952
3953 static u32 interpolate_value(u32 value, struct linear_segments *segments,
3954                              unsigned len)
3955 {
3956         u64 tmp64;
3957         u32 dx;
3958         s32 dy;
3959         int i, ret;
3960
3961         if (value >= segments[0].x)
3962                 return segments[0].y;
3963         if (value < segments[len-1].x)
3964                 return segments[len-1].y;
3965
3966         for (i = 1; i < len - 1; i++) {
3967                 /* If value is identical, no need to interpolate */
3968                 if (value == segments[i].x)
3969                         return segments[i].y;
3970                 if (value > segments[i].x)
3971                         break;
3972         }
3973
3974         /* Linear interpolation between the two (x,y) points */
3975         dy = segments[i - 1].y - segments[i].y;
3976         dx = segments[i - 1].x - segments[i].x;
3977
3978         tmp64 = value - segments[i].x;
3979         tmp64 *= dy;
3980         do_div(tmp64, dx);
3981         ret = segments[i].y + tmp64;
3982
3983         return ret;
3984 }
3985
3986 static u32 dib8000_get_time_us(struct dvb_frontend *fe, int layer)
3987 {
3988         struct dib8000_state *state = fe->demodulator_priv;
3989         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3990         int ini_layer, end_layer, i;
3991         u64 time_us, tmp64;
3992         u32 tmp, denom;
3993         int guard, rate_num, rate_denum = 1, bits_per_symbol, nsegs;
3994         int interleaving = 0, fft_div;
3995
3996         if (layer >= 0) {
3997                 ini_layer = layer;
3998                 end_layer = layer + 1;
3999         } else {
4000                 ini_layer = 0;
4001                 end_layer = 3;
4002         }
4003
4004         switch (c->guard_interval) {
4005         case GUARD_INTERVAL_1_4:
4006                 guard = 4;
4007                 break;
4008         case GUARD_INTERVAL_1_8:
4009                 guard = 8;
4010                 break;
4011         case GUARD_INTERVAL_1_16:
4012                 guard = 16;
4013                 break;
4014         default:
4015         case GUARD_INTERVAL_1_32:
4016                 guard = 32;
4017                 break;
4018         }
4019
4020         switch (c->transmission_mode) {
4021         case TRANSMISSION_MODE_2K:
4022                 fft_div = 4;
4023                 break;
4024         case TRANSMISSION_MODE_4K:
4025                 fft_div = 2;
4026                 break;
4027         default:
4028         case TRANSMISSION_MODE_8K:
4029                 fft_div = 1;
4030                 break;
4031         }
4032
4033         denom = 0;
4034         for (i = ini_layer; i < end_layer; i++) {
4035                 nsegs = c->layer[i].segment_count;
4036                 if (nsegs == 0 || nsegs > 13)
4037                         continue;
4038
4039                 switch (c->layer[i].modulation) {
4040                 case DQPSK:
4041                 case QPSK:
4042                         bits_per_symbol = 2;
4043                         break;
4044                 case QAM_16:
4045                         bits_per_symbol = 4;
4046                         break;
4047                 default:
4048                 case QAM_64:
4049                         bits_per_symbol = 6;
4050                         break;
4051                 }
4052
4053                 switch (c->layer[i].fec) {
4054                 case FEC_1_2:
4055                         rate_num = 1;
4056                         rate_denum = 2;
4057                         break;
4058                 case FEC_2_3:
4059                         rate_num = 2;
4060                         rate_denum = 3;
4061                         break;
4062                 case FEC_3_4:
4063                         rate_num = 3;
4064                         rate_denum = 4;
4065                         break;
4066                 case FEC_5_6:
4067                         rate_num = 5;
4068                         rate_denum = 6;
4069                         break;
4070                 default:
4071                 case FEC_7_8:
4072                         rate_num = 7;
4073                         rate_denum = 8;
4074                         break;
4075                 }
4076
4077                 interleaving = c->layer[i].interleaving;
4078
4079                 denom += bits_per_symbol * rate_num * fft_div * nsegs * 384;
4080         }
4081
4082         /* If all goes wrong, wait for 1s for the next stats */
4083         if (!denom)
4084                 return 0;
4085
4086         /* Estimate the period for the total bit rate */
4087         time_us = rate_denum * (1008 * 1562500L);
4088         tmp64 = time_us;
4089         do_div(tmp64, guard);
4090         time_us = time_us + tmp64;
4091         time_us += denom / 2;
4092         do_div(time_us, denom);
4093
4094         tmp = 1008 * 96 * interleaving;
4095         time_us += tmp + tmp / guard;
4096
4097         return time_us;
4098 }
4099
4100 static int dib8000_get_stats(struct dvb_frontend *fe, enum fe_status stat)
4101 {
4102         struct dib8000_state *state = fe->demodulator_priv;
4103         struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
4104         int i;
4105         int show_per_stats = 0;
4106         u32 time_us = 0, snr, val;
4107         u64 blocks;
4108         s32 db;
4109         u16 strength;
4110
4111         /* Get Signal strength */
4112         dib8000_read_signal_strength(fe, &strength);
4113         val = strength;
4114         db = interpolate_value(val,
4115                                strength_to_db_table,
4116                                ARRAY_SIZE(strength_to_db_table)) - 131000;
4117         c->strength.stat[0].svalue = db;
4118
4119         /* UCB/BER/CNR measures require lock */
4120         if (!(stat & FE_HAS_LOCK)) {
4121                 c->cnr.len = 1;
4122                 c->block_count.len = 1;
4123                 c->block_error.len = 1;
4124                 c->post_bit_error.len = 1;
4125                 c->post_bit_count.len = 1;
4126                 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4127                 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4128                 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4129                 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4130                 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4131                 return 0;
4132         }
4133
4134         /* Check if time for stats was elapsed */
4135         if (time_after(jiffies, state->per_jiffies_stats)) {
4136                 state->per_jiffies_stats = jiffies + msecs_to_jiffies(1000);
4137
4138                 /* Get SNR */
4139                 snr = dib8000_get_snr(fe);
4140                 for (i = 1; i < MAX_NUMBER_OF_FRONTENDS; i++) {
4141                         if (state->fe[i])
4142                                 snr += dib8000_get_snr(state->fe[i]);
4143                 }
4144                 snr = snr >> 16;
4145
4146                 if (snr) {
4147                         snr = 10 * intlog10(snr);
4148                         snr = (1000L * snr) >> 24;
4149                 } else {
4150                         snr = 0;
4151                 }
4152                 c->cnr.stat[0].svalue = snr;
4153                 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
4154
4155                 /* Get UCB measures */
4156                 dib8000_read_unc_blocks(fe, &val);
4157                 if (val < state->init_ucb)
4158                         state->init_ucb += 0x100000000LL;
4159
4160                 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
4161                 c->block_error.stat[0].uvalue = val + state->init_ucb;
4162
4163                 /* Estimate the number of packets based on bitrate */
4164                 if (!time_us)
4165                         time_us = dib8000_get_time_us(fe, -1);
4166
4167                 if (time_us) {
4168                         blocks = 1250000ULL * 1000000ULL;
4169                         do_div(blocks, time_us * 8 * 204);
4170                         c->block_count.stat[0].scale = FE_SCALE_COUNTER;
4171                         c->block_count.stat[0].uvalue += blocks;
4172                 }
4173
4174                 show_per_stats = 1;
4175         }
4176
4177         /* Get post-BER measures */
4178         if (time_after(jiffies, state->ber_jiffies_stats)) {
4179                 time_us = dib8000_get_time_us(fe, -1);
4180                 state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
4181
4182                 dprintk("Next all layers stats available in %u us.\n", time_us);
4183
4184                 dib8000_read_ber(fe, &val);
4185                 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
4186                 c->post_bit_error.stat[0].uvalue += val;
4187
4188                 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
4189                 c->post_bit_count.stat[0].uvalue += 100000000;
4190         }
4191
4192         if (state->revision < 0x8002)
4193                 return 0;
4194
4195         c->block_error.len = 4;
4196         c->post_bit_error.len = 4;
4197         c->post_bit_count.len = 4;
4198
4199         for (i = 0; i < 3; i++) {
4200                 unsigned nsegs = c->layer[i].segment_count;
4201
4202                 if (nsegs == 0 || nsegs > 13)
4203                         continue;
4204
4205                 time_us = 0;
4206
4207                 if (time_after(jiffies, state->ber_jiffies_stats_layer[i])) {
4208                         time_us = dib8000_get_time_us(fe, i);
4209
4210                         state->ber_jiffies_stats_layer[i] = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
4211                         dprintk("Next layer %c  stats will be available in %u us\n",
4212                                 'A' + i, time_us);
4213
4214                         val = dib8000_read_word(state, per_layer_regs[i].ber);
4215                         c->post_bit_error.stat[1 + i].scale = FE_SCALE_COUNTER;
4216                         c->post_bit_error.stat[1 + i].uvalue += val;
4217
4218                         c->post_bit_count.stat[1 + i].scale = FE_SCALE_COUNTER;
4219                         c->post_bit_count.stat[1 + i].uvalue += 100000000;
4220                 }
4221
4222                 if (show_per_stats) {
4223                         val = dib8000_read_word(state, per_layer_regs[i].per);
4224
4225                         c->block_error.stat[1 + i].scale = FE_SCALE_COUNTER;
4226                         c->block_error.stat[1 + i].uvalue += val;
4227
4228                         if (!time_us)
4229                                 time_us = dib8000_get_time_us(fe, i);
4230                         if (time_us) {
4231                                 blocks = 1250000ULL * 1000000ULL;
4232                                 do_div(blocks, time_us * 8 * 204);
4233                                 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
4234                                 c->block_count.stat[0].uvalue += blocks;
4235                         }
4236                 }
4237         }
4238         return 0;
4239 }
4240
4241 static int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave)
4242 {
4243         struct dib8000_state *state = fe->demodulator_priv;
4244         u8 index_frontend = 1;
4245
4246         while ((index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL))
4247                 index_frontend++;
4248         if (index_frontend < MAX_NUMBER_OF_FRONTENDS) {
4249                 dprintk("set slave fe %p to index %i\n", fe_slave, index_frontend);
4250                 state->fe[index_frontend] = fe_slave;
4251                 return 0;
4252         }
4253
4254         dprintk("too many slave frontend\n");
4255         return -ENOMEM;
4256 }
4257
4258 static struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int slave_index)
4259 {
4260         struct dib8000_state *state = fe->demodulator_priv;
4261
4262         if (slave_index >= MAX_NUMBER_OF_FRONTENDS)
4263                 return NULL;
4264         return state->fe[slave_index];
4265 }
4266
4267 static int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods,
4268                 u8 default_addr, u8 first_addr, u8 is_dib8096p)
4269 {
4270         int k = 0, ret = 0;
4271         u8 new_addr = 0;
4272         struct i2c_device client = {.adap = host };
4273
4274         client.i2c_write_buffer = kzalloc(4, GFP_KERNEL);
4275         if (!client.i2c_write_buffer) {
4276                 dprintk("%s: not enough memory\n", __func__);
4277                 return -ENOMEM;
4278         }
4279         client.i2c_read_buffer = kzalloc(4, GFP_KERNEL);
4280         if (!client.i2c_read_buffer) {
4281                 dprintk("%s: not enough memory\n", __func__);
4282                 ret = -ENOMEM;
4283                 goto error_memory_read;
4284         }
4285         client.i2c_buffer_lock = kzalloc(sizeof(struct mutex), GFP_KERNEL);
4286         if (!client.i2c_buffer_lock) {
4287                 dprintk("%s: not enough memory\n", __func__);
4288                 ret = -ENOMEM;
4289                 goto error_memory_lock;
4290         }
4291         mutex_init(client.i2c_buffer_lock);
4292
4293         for (k = no_of_demods - 1; k >= 0; k--) {
4294                 /* designated i2c address */
4295                 new_addr = first_addr + (k << 1);
4296
4297                 client.addr = new_addr;
4298                 if (!is_dib8096p)
4299                         dib8000_i2c_write16(&client, 1287, 0x0003);     /* sram lead in, rdy */
4300                 if (dib8000_identify(&client) == 0) {
4301                         /* sram lead in, rdy */
4302                         if (!is_dib8096p)
4303                                 dib8000_i2c_write16(&client, 1287, 0x0003);
4304                         client.addr = default_addr;
4305                         if (dib8000_identify(&client) == 0) {
4306                                 dprintk("#%d: not identified\n", k);
4307                                 ret  = -EINVAL;
4308                                 goto error;
4309                         }
4310                 }
4311
4312                 /* start diversity to pull_down div_str - just for i2c-enumeration */
4313                 dib8000_i2c_write16(&client, 1286, (1 << 10) | (4 << 6));
4314
4315                 /* set new i2c address and force divstart */
4316                 dib8000_i2c_write16(&client, 1285, (new_addr << 2) | 0x2);
4317                 client.addr = new_addr;
4318                 dib8000_identify(&client);
4319
4320                 dprintk("IC %d initialized (to i2c_address 0x%x)\n", k, new_addr);
4321         }
4322
4323         for (k = 0; k < no_of_demods; k++) {
4324                 new_addr = first_addr | (k << 1);
4325                 client.addr = new_addr;
4326
4327                 // unforce divstr
4328                 dib8000_i2c_write16(&client, 1285, new_addr << 2);
4329
4330                 /* deactivate div - it was just for i2c-enumeration */
4331                 dib8000_i2c_write16(&client, 1286, 0);
4332         }
4333
4334 error:
4335         kfree(client.i2c_buffer_lock);
4336 error_memory_lock:
4337         kfree(client.i2c_read_buffer);
4338 error_memory_read:
4339         kfree(client.i2c_write_buffer);
4340
4341         return ret;
4342 }
4343
4344 static int dib8000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
4345 {
4346         tune->min_delay_ms = 1000;
4347         tune->step_size = 0;
4348         tune->max_drift = 0;
4349         return 0;
4350 }
4351
4352 static void dib8000_release(struct dvb_frontend *fe)
4353 {
4354         struct dib8000_state *st = fe->demodulator_priv;
4355         u8 index_frontend;
4356
4357         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (st->fe[index_frontend] != NULL); index_frontend++)
4358                 dvb_frontend_detach(st->fe[index_frontend]);
4359
4360         dibx000_exit_i2c_master(&st->i2c_master);
4361         i2c_del_adapter(&st->dib8096p_tuner_adap);
4362         kfree(st->fe[0]);
4363         kfree(st);
4364 }
4365
4366 static struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating)
4367 {
4368         struct dib8000_state *st = fe->demodulator_priv;
4369         return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
4370 }
4371
4372 static int dib8000_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
4373 {
4374         struct dib8000_state *st = fe->demodulator_priv;
4375         u16 val = dib8000_read_word(st, 299) & 0xffef;
4376         val |= (onoff & 0x1) << 4;
4377
4378         dprintk("pid filter enabled %d\n", onoff);
4379         return dib8000_write_word(st, 299, val);
4380 }
4381
4382 static int dib8000_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
4383 {
4384         struct dib8000_state *st = fe->demodulator_priv;
4385         dprintk("Index %x, PID %d, OnOff %d\n", id, pid, onoff);
4386         return dib8000_write_word(st, 305 + id, onoff ? (1 << 13) | pid : 0);
4387 }
4388
4389 static const struct dvb_frontend_ops dib8000_ops = {
4390         .delsys = { SYS_ISDBT },
4391         .info = {
4392                  .name = "DiBcom 8000 ISDB-T",
4393                  .frequency_min_hz =  44250 * kHz,
4394                  .frequency_max_hz = 867250 * kHz,
4395                  .frequency_stepsize_hz = 62500,
4396                  .caps = FE_CAN_INVERSION_AUTO |
4397                  FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
4398                  FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
4399                  FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
4400                  FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
4401                  },
4402
4403         .release = dib8000_release,
4404
4405         .init = dib8000_wakeup,
4406         .sleep = dib8000_sleep,
4407
4408         .set_frontend = dib8000_set_frontend,
4409         .get_tune_settings = dib8000_fe_get_tune_settings,
4410         .get_frontend = dib8000_get_frontend,
4411
4412         .read_status = dib8000_read_status,
4413         .read_ber = dib8000_read_ber,
4414         .read_signal_strength = dib8000_read_signal_strength,
4415         .read_snr = dib8000_read_snr,
4416         .read_ucblocks = dib8000_read_unc_blocks,
4417 };
4418
4419 static struct dvb_frontend *dib8000_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg)
4420 {
4421         struct dvb_frontend *fe;
4422         struct dib8000_state *state;
4423
4424         dprintk("dib8000_init\n");
4425
4426         state = kzalloc(sizeof(struct dib8000_state), GFP_KERNEL);
4427         if (state == NULL)
4428                 return NULL;
4429         fe = kzalloc(sizeof(struct dvb_frontend), GFP_KERNEL);
4430         if (fe == NULL)
4431                 goto error;
4432
4433         memcpy(&state->cfg, cfg, sizeof(struct dib8000_config));
4434         state->i2c.adap = i2c_adap;
4435         state->i2c.addr = i2c_addr;
4436         state->i2c.i2c_write_buffer = state->i2c_write_buffer;
4437         state->i2c.i2c_read_buffer = state->i2c_read_buffer;
4438         mutex_init(&state->i2c_buffer_lock);
4439         state->i2c.i2c_buffer_lock = &state->i2c_buffer_lock;
4440         state->gpio_val = cfg->gpio_val;
4441         state->gpio_dir = cfg->gpio_dir;
4442
4443         /* Ensure the output mode remains at the previous default if it's
4444          * not specifically set by the caller.
4445          */
4446         if ((state->cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (state->cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
4447                 state->cfg.output_mode = OUTMODE_MPEG2_FIFO;
4448
4449         state->fe[0] = fe;
4450         fe->demodulator_priv = state;
4451         memcpy(&state->fe[0]->ops, &dib8000_ops, sizeof(struct dvb_frontend_ops));
4452
4453         state->timf_default = cfg->pll->timf;
4454
4455         if (dib8000_identify(&state->i2c) == 0)
4456                 goto error;
4457
4458         dibx000_init_i2c_master(&state->i2c_master, DIB8000, state->i2c.adap, state->i2c.addr);
4459
4460         /* init 8096p tuner adapter */
4461         strscpy(state->dib8096p_tuner_adap.name, "DiB8096P tuner interface",
4462                 sizeof(state->dib8096p_tuner_adap.name));
4463         state->dib8096p_tuner_adap.algo = &dib8096p_tuner_xfer_algo;
4464         state->dib8096p_tuner_adap.algo_data = NULL;
4465         state->dib8096p_tuner_adap.dev.parent = state->i2c.adap->dev.parent;
4466         i2c_set_adapdata(&state->dib8096p_tuner_adap, state);
4467         i2c_add_adapter(&state->dib8096p_tuner_adap);
4468
4469         dib8000_reset(fe);
4470
4471         dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & ~0x60) | (3 << 5));     /* ber_rs_len = 3 */
4472         state->current_demod_bw = 6000;
4473
4474         return fe;
4475
4476 error:
4477         kfree(state);
4478         return NULL;
4479 }
4480
4481 void *dib8000_attach(struct dib8000_ops *ops)
4482 {
4483         if (!ops)
4484                 return NULL;
4485
4486         ops->pwm_agc_reset = dib8000_pwm_agc_reset;
4487         ops->get_dc_power = dib8090p_get_dc_power;
4488         ops->set_gpio = dib8000_set_gpio;
4489         ops->get_slave_frontend = dib8000_get_slave_frontend;
4490         ops->set_tune_state = dib8000_set_tune_state;
4491         ops->pid_filter_ctrl = dib8000_pid_filter_ctrl;
4492         ops->get_adc_power = dib8000_get_adc_power;
4493         ops->update_pll = dib8000_update_pll;
4494         ops->tuner_sleep = dib8096p_tuner_sleep;
4495         ops->get_tune_state = dib8000_get_tune_state;
4496         ops->get_i2c_tuner = dib8096p_get_i2c_tuner;
4497         ops->set_slave_frontend = dib8000_set_slave_frontend;
4498         ops->pid_filter = dib8000_pid_filter;
4499         ops->ctrl_timf = dib8000_ctrl_timf;
4500         ops->init = dib8000_init;
4501         ops->get_i2c_master = dib8000_get_i2c_master;
4502         ops->i2c_enumeration = dib8000_i2c_enumeration;
4503         ops->set_wbd_ref = dib8000_set_wbd_ref;
4504
4505         return ops;
4506 }
4507 EXPORT_SYMBOL(dib8000_attach);
4508
4509 MODULE_AUTHOR("Olivier Grenie <Olivier.Grenie@parrot.com, Patrick Boettcher <patrick.boettcher@posteo.de>");
4510 MODULE_DESCRIPTION("Driver for the DiBcom 8000 ISDB-T demodulator");
4511 MODULE_LICENSE("GPL");