drivers/media/dvb-frontends/stv0367.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * stv0367.c
   4  *
   5  * Driver for ST STV0367 DVB-T & DVB-C demodulator IC.
   6  *
   7  * Copyright (C) ST Microelectronics.
   8  * Copyright (C) 2010,2011 NetUP Inc.
   9  * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/string.h>
  15 #include <linux/slab.h>
  16 #include <linux/i2c.h>
  17
  18 #include <media/dvb_math.h>
  19
  20 #include "stv0367.h"
  21 #include "stv0367_defs.h"
  22 #include "stv0367_regs.h"
  23 #include "stv0367_priv.h"
  24
  25 /* Max transfer size done by I2C transfer functions */
  26 #define MAX_XFER_SIZE  64
  27
  28 static int stvdebug;
  29 module_param_named(debug, stvdebug, int, 0644);
  30
  31 static int i2cdebug;
  32 module_param_named(i2c_debug, i2cdebug, int, 0644);
  33
  34 #define dprintk(args...) \
  35         do { \
  36                 if (stvdebug) \
  37                         printk(KERN_DEBUG args); \
  38         } while (0)
  39         /* DVB-C */
  40
  41 enum active_demod_state { demod_none, demod_ter, demod_cab };
  42
  43 struct stv0367cab_state {
  44         enum stv0367_cab_signal_type    state;
  45         u32     mclk;
  46         u32     adc_clk;
  47         s32     search_range;
  48         s32     derot_offset;
  49         /* results */
  50         int locked;                     /* channel found                */
  51         u32 freq_khz;                   /* found frequency (in kHz)     */
  52         u32 symbol_rate;                /* found symbol rate (in Bds)   */
  53         enum fe_spectral_inversion spect_inv; /* Spectrum Inversion     */
  54         u32 qamfec_status_reg;          /* status reg to poll for FEC Lock */
  55 };
  56
  57 struct stv0367ter_state {
  58         /* DVB-T */
  59         enum stv0367_ter_signal_type state;
  60         enum stv0367_ter_if_iq_mode if_iq_mode;
  61         enum stv0367_ter_mode mode;/* mode 2K or 8K */
  62         enum fe_guard_interval guard;
  63         enum stv0367_ter_hierarchy hierarchy;
  64         u32 frequency;
  65         enum fe_spectral_inversion sense; /*  current search spectrum */
  66         u8  force; /* force mode/guard */
  67         u8  bw; /* channel width 6, 7 or 8 in MHz */
  68         u8  pBW; /* channel width used during previous lock */
  69         u32 pBER;
  70         u32 pPER;
  71         u32 ucblocks;
  72         s8  echo_pos; /* echo position */
  73         u8  first_lock;
  74         u8  unlock_counter;
  75         u32 agc_val;
  76 };
  77
  78 struct stv0367_state {
  79         struct dvb_frontend fe;
  80         struct i2c_adapter *i2c;
  81         /* config settings */
  82         const struct stv0367_config *config;
  83         u8 chip_id;
  84         /* DVB-C */
  85         struct stv0367cab_state *cab_state;
  86         /* DVB-T */
  87         struct stv0367ter_state *ter_state;
  88         /* flags for operation control */
  89         u8 use_i2c_gatectrl;
  90         u8 deftabs;
  91         u8 reinit_on_setfrontend;
  92         u8 auto_if_khz;
  93         enum active_demod_state activedemod;
  94 };
  95
  96 #define RF_LOOKUP_TABLE_SIZE  31
  97 #define RF_LOOKUP_TABLE2_SIZE 16
  98 /* RF Level (for RF AGC->AGC1) Lookup Table, depends on the board and tuner.*/
  99 static const s32 stv0367cab_RF_LookUp1[RF_LOOKUP_TABLE_SIZE][RF_LOOKUP_TABLE_SIZE] = {
 100         {/*AGC1*/
 101                 48, 50, 51, 53, 54, 56, 57, 58, 60, 61, 62, 63,
 102                 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
 103                 76, 77, 78, 80, 83, 85, 88,
 104         }, {/*RF(dbm)*/
 105                 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
 106                 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 46, 47,
 107                 49, 50, 52, 53, 54, 55, 56,
 108         }
 109 };
 110 /* RF Level (for IF AGC->AGC2) Lookup Table, depends on the board and tuner.*/
 111 static const s32 stv0367cab_RF_LookUp2[RF_LOOKUP_TABLE2_SIZE][RF_LOOKUP_TABLE2_SIZE] = {
 112         {/*AGC2*/
 113                 28, 29, 31, 32, 34, 35, 36, 37,
 114                 38, 39, 40, 41, 42, 43, 44, 45,
 115         }, {/*RF(dbm)*/
 116                 57, 58, 59, 60, 61, 62, 63, 64,
 117                 65, 66, 67, 68, 69, 70, 71, 72,
 118         }
 119 };
 120
 121 static
 122 int stv0367_writeregs(struct stv0367_state *state, u16 reg, u8 *data, int len)
 123 {
 124         u8 buf[MAX_XFER_SIZE];
 125         struct i2c_msg msg = {
 126                 .addr = state->config->demod_address,
 127                 .flags = 0,
 128                 .buf = buf,
 129                 .len = len + 2
 130         };
 131         int ret;
 132
 133         if (2 + len > sizeof(buf)) {
 134                 printk(KERN_WARNING
 135                        "%s: i2c wr reg=%04x: len=%d is too big!\n",
 136                        KBUILD_MODNAME, reg, len);
 137                 return -EINVAL;
 138         }
 139
 140
 141         buf[0] = MSB(reg);
 142         buf[1] = LSB(reg);
 143         memcpy(buf + 2, data, len);
 144
 145         if (i2cdebug)
 146                 printk(KERN_DEBUG "%s: [%02x] %02x: %02x\n", __func__,
 147                         state->config->demod_address, reg, buf[2]);
 148
 149         ret = i2c_transfer(state->i2c, &msg, 1);
 150         if (ret != 1)
 151                 printk(KERN_ERR "%s: i2c write error! ([%02x] %02x: %02x)\n",
 152                         __func__, state->config->demod_address, reg, buf[2]);
 153
 154         return (ret != 1) ? -EREMOTEIO : 0;
 155 }
 156
 157 static int stv0367_writereg(struct stv0367_state *state, u16 reg, u8 data)
 158 {
 159         u8 tmp = data; /* see gcc.gnu.org/bugzilla/show_bug.cgi?id=81715 */
 160
 161         return stv0367_writeregs(state, reg, &tmp, 1);
 162 }
 163
 164 static u8 stv0367_readreg(struct stv0367_state *state, u16 reg)
 165 {
 166         u8 b0[] = { 0, 0 };
 167         u8 b1[] = { 0 };
 168         struct i2c_msg msg[] = {
 169                 {
 170                         .addr = state->config->demod_address,
 171                         .flags = 0,
 172                         .buf = b0,
 173                         .len = 2
 174                 }, {
 175                         .addr = state->config->demod_address,
 176                         .flags = I2C_M_RD,
 177                         .buf = b1,
 178                         .len = 1
 179                 }
 180         };
 181         int ret;
 182
 183         b0[0] = MSB(reg);
 184         b0[1] = LSB(reg);
 185
 186         ret = i2c_transfer(state->i2c, msg, 2);
 187         if (ret != 2)
 188                 printk(KERN_ERR "%s: i2c read error ([%02x] %02x: %02x)\n",
 189                         __func__, state->config->demod_address, reg, b1[0]);
 190
 191         if (i2cdebug)
 192                 printk(KERN_DEBUG "%s: [%02x] %02x: %02x\n", __func__,
 193                         state->config->demod_address, reg, b1[0]);
 194
 195         return b1[0];
 196 }
 197
 198 static void extract_mask_pos(u32 label, u8 *mask, u8 *pos)
 199 {
 200         u8 position = 0, i = 0;
 201
 202         (*mask) = label & 0xff;
 203
 204         while ((position == 0) && (i < 8)) {
 205                 position = ((*mask) >> i) & 0x01;
 206                 i++;
 207         }
 208
 209         (*pos) = (i - 1);
 210 }
 211
 212 static void stv0367_writebits(struct stv0367_state *state, u32 label, u8 val)
 213 {
 214         u8 reg, mask, pos;
 215
 216         reg = stv0367_readreg(state, (label >> 16) & 0xffff);
 217         extract_mask_pos(label, &mask, &pos);
 218
 219         val = mask & (val << pos);
 220
 221         reg = (reg & (~mask)) | val;
 222         stv0367_writereg(state, (label >> 16) & 0xffff, reg);
 223
 224 }
 225
 226 static void stv0367_setbits(u8 *reg, u32 label, u8 val)
 227 {
 228         u8 mask, pos;
 229
 230         extract_mask_pos(label, &mask, &pos);
 231
 232         val = mask & (val << pos);
 233
 234         (*reg) = ((*reg) & (~mask)) | val;
 235 }
 236
 237 static u8 stv0367_readbits(struct stv0367_state *state, u32 label)
 238 {
 239         u8 val = 0xff;
 240         u8 mask, pos;
 241
 242         extract_mask_pos(label, &mask, &pos);
 243
 244         val = stv0367_readreg(state, label >> 16);
 245         val = (val & mask) >> pos;
 246
 247         return val;
 248 }
 249
 250 #if 0 /* Currently, unused */
 251 static u8 stv0367_getbits(u8 reg, u32 label)
 252 {
 253         u8 mask, pos;
 254
 255         extract_mask_pos(label, &mask, &pos);
 256
 257         return (reg & mask) >> pos;
 258 }
 259 #endif
 260
 261 static void stv0367_write_table(struct stv0367_state *state,
 262                                 const struct st_register *deftab)
 263 {
 264         int i = 0;
 265
 266         while (1) {
 267                 if (!deftab[i].addr)
 268                         break;
 269                 stv0367_writereg(state, deftab[i].addr, deftab[i].value);
 270                 i++;
 271         }
 272 }
 273
 274 static void stv0367_pll_setup(struct stv0367_state *state,
 275                                 u32 icspeed, u32 xtal)
 276 {
 277         /* note on regs: R367TER_* and R367CAB_* defines each point to
 278          * 0xf0d8, so just use R367TER_ for both cases
 279          */
 280
 281         switch (icspeed) {
 282         case STV0367_ICSPEED_58000:
 283                 switch (xtal) {
 284                 default:
 285                 case 27000000:
 286                         dprintk("STV0367 SetCLKgen for 58MHz IC and 27Mhz crystal\n");
 287                         /* PLLMDIV: 27, PLLNDIV: 232 */
 288                         stv0367_writereg(state, R367TER_PLLMDIV, 0x1b);
 289                         stv0367_writereg(state, R367TER_PLLNDIV, 0xe8);
 290                         break;
 291                 }
 292                 break;
 293         default:
 294         case STV0367_ICSPEED_53125:
 295                 switch (xtal) {
 296                         /* set internal freq to 53.125MHz */
 297                 case 16000000:
 298                         stv0367_writereg(state, R367TER_PLLMDIV, 0x2);
 299                         stv0367_writereg(state, R367TER_PLLNDIV, 0x1b);
 300                         break;
 301                 case 25000000:
 302                         stv0367_writereg(state, R367TER_PLLMDIV, 0xa);
 303                         stv0367_writereg(state, R367TER_PLLNDIV, 0x55);
 304                         break;
 305                 default:
 306                 case 27000000:
 307                         dprintk("FE_STV0367TER_SetCLKgen for 27Mhz\n");
 308                         stv0367_writereg(state, R367TER_PLLMDIV, 0x1);
 309                         stv0367_writereg(state, R367TER_PLLNDIV, 0x8);
 310                         break;
 311                 case 30000000:
 312                         stv0367_writereg(state, R367TER_PLLMDIV, 0xc);
 313                         stv0367_writereg(state, R367TER_PLLNDIV, 0x55);
 314                         break;
 315                 }
 316         }
 317
 318         stv0367_writereg(state, R367TER_PLLSETUP, 0x18);
 319 }
 320
 321 static int stv0367_get_if_khz(struct stv0367_state *state, u32 *ifkhz)
 322 {
 323         if (state->auto_if_khz && state->fe.ops.tuner_ops.get_if_frequency) {
 324                 state->fe.ops.tuner_ops.get_if_frequency(&state->fe, ifkhz);
 325                 *ifkhz = *ifkhz / 1000; /* hz -> khz */
 326         } else
 327                 *ifkhz = state->config->if_khz;
 328
 329         return 0;
 330 }
 331
 332 static int stv0367ter_gate_ctrl(struct dvb_frontend *fe, int enable)
 333 {
 334         struct stv0367_state *state = fe->demodulator_priv;
 335         u8 tmp = stv0367_readreg(state, R367TER_I2CRPT);
 336
 337         dprintk("%s:\n", __func__);
 338
 339         if (enable) {
 340                 stv0367_setbits(&tmp, F367TER_STOP_ENABLE, 0);
 341                 stv0367_setbits(&tmp, F367TER_I2CT_ON, 1);
 342         } else {
 343                 stv0367_setbits(&tmp, F367TER_STOP_ENABLE, 1);
 344                 stv0367_setbits(&tmp, F367TER_I2CT_ON, 0);
 345         }
 346
 347         stv0367_writereg(state, R367TER_I2CRPT, tmp);
 348
 349         return 0;
 350 }
 351
 352 static u32 stv0367_get_tuner_freq(struct dvb_frontend *fe)
 353 {
 354         struct dvb_frontend_ops *frontend_ops = &fe->ops;
 355         struct dvb_tuner_ops    *tuner_ops = &frontend_ops->tuner_ops;
 356         u32 freq = 0;
 357         int err = 0;
 358
 359         dprintk("%s:\n", __func__);
 360
 361         if (tuner_ops->get_frequency) {
 362                 err = tuner_ops->get_frequency(fe, &freq);
 363                 if (err < 0) {
 364                         printk(KERN_ERR "%s: Invalid parameter\n", __func__);
 365                         return err;
 366                 }
 367
 368                 dprintk("%s: frequency=%d\n", __func__, freq);
 369
 370         } else
 371                 return -1;
 372
 373         return freq;
 374 }
 375
 376 static u16 CellsCoeffs_8MHz_367cofdm[3][6][5] = {
 377         {
 378                 {0x10EF, 0xE205, 0x10EF, 0xCE49, 0x6DA7}, /* CELL 1 COEFFS 27M*/
 379                 {0x2151, 0xc557, 0x2151, 0xc705, 0x6f93}, /* CELL 2 COEFFS */
 380                 {0x2503, 0xc000, 0x2503, 0xc375, 0x7194}, /* CELL 3 COEFFS */
 381                 {0x20E9, 0xca94, 0x20e9, 0xc153, 0x7194}, /* CELL 4 COEFFS */
 382                 {0x06EF, 0xF852, 0x06EF, 0xC057, 0x7207}, /* CELL 5 COEFFS */
 383                 {0x0000, 0x0ECC, 0x0ECC, 0x0000, 0x3647} /* CELL 6 COEFFS */
 384         }, {
 385                 {0x10A0, 0xE2AF, 0x10A1, 0xCE76, 0x6D6D}, /* CELL 1 COEFFS 25M*/
 386                 {0x20DC, 0xC676, 0x20D9, 0xC80A, 0x6F29},
 387                 {0x2532, 0xC000, 0x251D, 0xC391, 0x706F},
 388                 {0x1F7A, 0xCD2B, 0x2032, 0xC15E, 0x711F},
 389                 {0x0698, 0xFA5E, 0x0568, 0xC059, 0x7193},
 390                 {0x0000, 0x0918, 0x149C, 0x0000, 0x3642} /* CELL 6 COEFFS */
 391         }, {
 392                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, /* 30M */
 393                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 394                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 395                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 396                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 397                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000}
 398         }
 399 };
 400
 401 static u16 CellsCoeffs_7MHz_367cofdm[3][6][5] = {
 402         {
 403                 {0x12CA, 0xDDAF, 0x12CA, 0xCCEB, 0x6FB1}, /* CELL 1 COEFFS 27M*/
 404                 {0x2329, 0xC000, 0x2329, 0xC6B0, 0x725F}, /* CELL 2 COEFFS */
 405                 {0x2394, 0xC000, 0x2394, 0xC2C7, 0x7410}, /* CELL 3 COEFFS */
 406                 {0x251C, 0xC000, 0x251C, 0xC103, 0x74D9}, /* CELL 4 COEFFS */
 407                 {0x0804, 0xF546, 0x0804, 0xC040, 0x7544}, /* CELL 5 COEFFS */
 408                 {0x0000, 0x0CD9, 0x0CD9, 0x0000, 0x370A} /* CELL 6 COEFFS */
 409         }, {
 410                 {0x1285, 0xDE47, 0x1285, 0xCD17, 0x6F76}, /*25M*/
 411                 {0x234C, 0xC000, 0x2348, 0xC6DA, 0x7206},
 412                 {0x23B4, 0xC000, 0x23AC, 0xC2DB, 0x73B3},
 413                 {0x253D, 0xC000, 0x25B6, 0xC10B, 0x747F},
 414                 {0x0721, 0xF79C, 0x065F, 0xC041, 0x74EB},
 415                 {0x0000, 0x08FA, 0x1162, 0x0000, 0x36FF}
 416         }, {
 417                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, /* 30M */
 418                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 419                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 420                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 421                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 422                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000}
 423         }
 424 };
 425
 426 static u16 CellsCoeffs_6MHz_367cofdm[3][6][5] = {
 427         {
 428                 {0x1699, 0xD5B8, 0x1699, 0xCBC3, 0x713B}, /* CELL 1 COEFFS 27M*/
 429                 {0x2245, 0xC000, 0x2245, 0xC568, 0x74D5}, /* CELL 2 COEFFS */
 430                 {0x227F, 0xC000, 0x227F, 0xC1FC, 0x76C6}, /* CELL 3 COEFFS */
 431                 {0x235E, 0xC000, 0x235E, 0xC0A7, 0x778A}, /* CELL 4 COEFFS */
 432                 {0x0ECB, 0xEA0B, 0x0ECB, 0xC027, 0x77DD}, /* CELL 5 COEFFS */
 433                 {0x0000, 0x0B68, 0x0B68, 0x0000, 0xC89A}, /* CELL 6 COEFFS */
 434         }, {
 435                 {0x1655, 0xD64E, 0x1658, 0xCBEF, 0x70FE}, /*25M*/
 436                 {0x225E, 0xC000, 0x2256, 0xC589, 0x7489},
 437                 {0x2293, 0xC000, 0x2295, 0xC209, 0x767E},
 438                 {0x2377, 0xC000, 0x23AA, 0xC0AB, 0x7746},
 439                 {0x0DC7, 0xEBC8, 0x0D07, 0xC027, 0x7799},
 440                 {0x0000, 0x0888, 0x0E9C, 0x0000, 0x3757}
 441
 442         }, {
 443                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, /* 30M */
 444                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 445                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 446                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 447                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
 448                 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000}
 449         }
 450 };
 451
 452 static u32 stv0367ter_get_mclk(struct stv0367_state *state, u32 ExtClk_Hz)
 453 {
 454         u32 mclk_Hz = 0; /* master clock frequency (Hz) */
 455         u32 m, n, p;
 456
 457         dprintk("%s:\n", __func__);
 458
 459         if (stv0367_readbits(state, F367TER_BYPASS_PLLXN) == 0) {
 460                 n = (u32)stv0367_readbits(state, F367TER_PLL_NDIV);
 461                 if (n == 0)
 462                         n = n + 1;
 463
 464                 m = (u32)stv0367_readbits(state, F367TER_PLL_MDIV);
 465                 if (m == 0)
 466                         m = m + 1;
 467
 468                 p = (u32)stv0367_readbits(state, F367TER_PLL_PDIV);
 469                 if (p > 5)
 470                         p = 5;
 471
 472                 mclk_Hz = ((ExtClk_Hz / 2) * n) / (m * (1 << p));
 473
 474                 dprintk("N=%d M=%d P=%d mclk_Hz=%d ExtClk_Hz=%d\n",
 475                                 n, m, p, mclk_Hz, ExtClk_Hz);
 476         } else
 477                 mclk_Hz = ExtClk_Hz;
 478
 479         dprintk("%s: mclk_Hz=%d\n", __func__, mclk_Hz);
 480
 481         return mclk_Hz;
 482 }
 483
 484 static int stv0367ter_filt_coeff_init(struct stv0367_state *state,
 485                                 u16 CellsCoeffs[3][6][5], u32 DemodXtal)
 486 {
 487         int i, j, k, freq;
 488
 489         dprintk("%s:\n", __func__);
 490
 491         freq = stv0367ter_get_mclk(state, DemodXtal);
 492
 493         if (freq == 53125000)
 494                 k = 1; /* equivalent to Xtal 25M on 362*/
 495         else if (freq == 54000000)
 496                 k = 0; /* equivalent to Xtal 27M on 362*/
 497         else if (freq == 52500000)
 498                 k = 2; /* equivalent to Xtal 30M on 362*/
 499         else
 500                 return 0;
 501
 502         for (i = 1; i <= 6; i++) {
 503                 stv0367_writebits(state, F367TER_IIR_CELL_NB, i - 1);
 504
 505                 for (j = 1; j <= 5; j++) {
 506                         stv0367_writereg(state,
 507                                 (R367TER_IIRCX_COEFF1_MSB + 2 * (j - 1)),
 508                                 MSB(CellsCoeffs[k][i-1][j-1]));
 509                         stv0367_writereg(state,
 510                                 (R367TER_IIRCX_COEFF1_LSB + 2 * (j - 1)),
 511                                 LSB(CellsCoeffs[k][i-1][j-1]));
 512                 }
 513         }
 514
 515         return 1;
 516
 517 }
 518
 519 static void stv0367ter_agc_iir_lock_detect_set(struct stv0367_state *state)
 520 {
 521         dprintk("%s:\n", __func__);
 522
 523         stv0367_writebits(state, F367TER_LOCK_DETECT_LSB, 0x00);
 524
 525         /* Lock detect 1 */
 526         stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x00);
 527         stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x06);
 528         stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x04);
 529
 530         /* Lock detect 2 */
 531         stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x01);
 532         stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x06);
 533         stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x04);
 534
 535         /* Lock detect 3 */
 536         stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x02);
 537         stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x01);
 538         stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x00);
 539
 540         /* Lock detect 4 */
 541         stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x03);
 542         stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x01);
 543         stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x00);
 544
 545 }
 546
 547 static int stv0367_iir_filt_init(struct stv0367_state *state, u8 Bandwidth,
 548                                                         u32 DemodXtalValue)
 549 {
 550         dprintk("%s:\n", __func__);
 551
 552         stv0367_writebits(state, F367TER_NRST_IIR, 0);
 553
 554         switch (Bandwidth) {
 555         case 6:
 556                 if (!stv0367ter_filt_coeff_init(state,
 557                                 CellsCoeffs_6MHz_367cofdm,
 558                                 DemodXtalValue))
 559                         return 0;
 560                 break;
 561         case 7:
 562                 if (!stv0367ter_filt_coeff_init(state,
 563                                 CellsCoeffs_7MHz_367cofdm,
 564                                 DemodXtalValue))
 565                         return 0;
 566                 break;
 567         case 8:
 568                 if (!stv0367ter_filt_coeff_init(state,
 569                                 CellsCoeffs_8MHz_367cofdm,
 570                                 DemodXtalValue))
 571                         return 0;
 572                 break;
 573         default:
 574                 return 0;
 575         }
 576
 577         stv0367_writebits(state, F367TER_NRST_IIR, 1);
 578
 579         return 1;
 580 }
 581
 582 static void stv0367ter_agc_iir_rst(struct stv0367_state *state)
 583 {
 584
 585         u8 com_n;
 586
 587         dprintk("%s:\n", __func__);
 588
 589         com_n = stv0367_readbits(state, F367TER_COM_N);
 590
 591         stv0367_writebits(state, F367TER_COM_N, 0x07);
 592
 593         stv0367_writebits(state, F367TER_COM_SOFT_RSTN, 0x00);
 594         stv0367_writebits(state, F367TER_COM_AGC_ON, 0x00);
 595
 596         stv0367_writebits(state, F367TER_COM_SOFT_RSTN, 0x01);
 597         stv0367_writebits(state, F367TER_COM_AGC_ON, 0x01);
 598
 599         stv0367_writebits(state, F367TER_COM_N, com_n);
 600
 601 }
 602
 603 static int stv0367ter_duration(s32 mode, int tempo1, int tempo2, int tempo3)
 604 {
 605         int local_tempo = 0;
 606         switch (mode) {
 607         case 0:
 608                 local_tempo = tempo1;
 609                 break;
 610         case 1:
 611                 local_tempo = tempo2;
 612                 break ;
 613
 614         case 2:
 615                 local_tempo = tempo3;
 616                 break;
 617
 618         default:
 619                 break;
 620         }
 621         /*      msleep(local_tempo);  */
 622         return local_tempo;
 623 }
 624
 625 static enum
 626 stv0367_ter_signal_type stv0367ter_check_syr(struct stv0367_state *state)
 627 {
 628         int wd = 100;
 629         unsigned short int SYR_var;
 630         s32 SYRStatus;
 631
 632         dprintk("%s:\n", __func__);
 633
 634         SYR_var = stv0367_readbits(state, F367TER_SYR_LOCK);
 635
 636         while ((!SYR_var) && (wd > 0)) {
 637                 usleep_range(2000, 3000);
 638                 wd -= 2;
 639                 SYR_var = stv0367_readbits(state, F367TER_SYR_LOCK);
 640         }
 641
 642         if (!SYR_var)
 643                 SYRStatus = FE_TER_NOSYMBOL;
 644         else
 645                 SYRStatus =  FE_TER_SYMBOLOK;
 646
 647         dprintk("stv0367ter_check_syr SYRStatus %s\n",
 648                                 SYR_var == 0 ? "No Symbol" : "OK");
 649
 650         return SYRStatus;
 651 }
 652
 653 static enum
 654 stv0367_ter_signal_type stv0367ter_check_cpamp(struct stv0367_state *state,
 655                                                                 s32 FFTmode)
 656 {
 657
 658         s32  CPAMPvalue = 0, CPAMPStatus, CPAMPMin;
 659         int wd = 0;
 660
 661         dprintk("%s:\n", __func__);
 662
 663         switch (FFTmode) {
 664         case 0: /*2k mode*/
 665                 CPAMPMin = 20;
 666                 wd = 10;
 667                 break;
 668         case 1: /*8k mode*/
 669                 CPAMPMin = 80;
 670                 wd = 55;
 671                 break;
 672         case 2: /*4k mode*/
 673                 CPAMPMin = 40;
 674                 wd = 30;
 675                 break;
 676         default:
 677                 CPAMPMin = 0xffff;  /*drives to NOCPAMP */
 678                 break;
 679         }
 680
 681         dprintk("%s: CPAMPMin=%d wd=%d\n", __func__, CPAMPMin, wd);
 682
 683         CPAMPvalue = stv0367_readbits(state, F367TER_PPM_CPAMP_DIRECT);
 684         while ((CPAMPvalue < CPAMPMin) && (wd > 0)) {
 685                 usleep_range(1000, 2000);
 686                 wd -= 1;
 687                 CPAMPvalue = stv0367_readbits(state, F367TER_PPM_CPAMP_DIRECT);
 688                 /*dprintk("CPAMPvalue= %d at wd=%d\n",CPAMPvalue,wd); */
 689         }
 690         dprintk("******last CPAMPvalue= %d at wd=%d\n", CPAMPvalue, wd);
 691         if (CPAMPvalue < CPAMPMin) {
 692                 CPAMPStatus = FE_TER_NOCPAMP;
 693                 dprintk("%s: CPAMP failed\n", __func__);
 694         } else {
 695                 dprintk("%s: CPAMP OK !\n", __func__);
 696                 CPAMPStatus = FE_TER_CPAMPOK;
 697         }
 698
 699         return CPAMPStatus;
 700 }
 701
 702 static enum stv0367_ter_signal_type
 703 stv0367ter_lock_algo(struct stv0367_state *state)
 704 {
 705         enum stv0367_ter_signal_type ret_flag;
 706         short int wd, tempo;
 707         u8 try, u_var1 = 0, u_var2 = 0, u_var3 = 0, u_var4 = 0, mode, guard;
 708         u8 tmp, tmp2;
 709
 710         dprintk("%s:\n", __func__);
 711
 712         if (state == NULL)
 713                 return FE_TER_SWNOK;
 714
 715         try = 0;
 716         do {
 717                 ret_flag = FE_TER_LOCKOK;
 718
 719                 stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
 720
 721                 if (state->config->if_iq_mode != 0)
 722                         stv0367_writebits(state, F367TER_COM_N, 0x07);
 723
 724                 stv0367_writebits(state, F367TER_GUARD, 3);/* suggest 2k 1/4 */
 725                 stv0367_writebits(state, F367TER_MODE, 0);
 726                 stv0367_writebits(state, F367TER_SYR_TR_DIS, 0);
 727                 usleep_range(5000, 10000);
 728
 729                 stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
 730
 731
 732                 if (stv0367ter_check_syr(state) == FE_TER_NOSYMBOL)
 733                         return FE_TER_NOSYMBOL;
 734                 else { /*
 735                         if chip locked on wrong mode first try,
 736                         it must lock correctly second try */
 737                         mode = stv0367_readbits(state, F367TER_SYR_MODE);
 738                         if (stv0367ter_check_cpamp(state, mode) ==
 739                                                         FE_TER_NOCPAMP) {
 740                                 if (try == 0)
 741                                         ret_flag = FE_TER_NOCPAMP;
 742
 743                         }
 744                 }
 745
 746                 try++;
 747         } while ((try < 10) && (ret_flag != FE_TER_LOCKOK));
 748
 749         tmp  = stv0367_readreg(state, R367TER_SYR_STAT);
 750         tmp2 = stv0367_readreg(state, R367TER_STATUS);
 751         dprintk("state=%p\n", state);
 752         dprintk("LOCK OK! mode=%d SYR_STAT=0x%x R367TER_STATUS=0x%x\n",
 753                                                         mode, tmp, tmp2);
 754
 755         tmp  = stv0367_readreg(state, R367TER_PRVIT);
 756         tmp2 = stv0367_readreg(state, R367TER_I2CRPT);
 757         dprintk("PRVIT=0x%x I2CRPT=0x%x\n", tmp, tmp2);
 758
 759         tmp  = stv0367_readreg(state, R367TER_GAIN_SRC1);
 760         dprintk("GAIN_SRC1=0x%x\n", tmp);
 761
 762         if ((mode != 0) && (mode != 1) && (mode != 2))
 763                 return FE_TER_SWNOK;
 764
 765         /*guard=stv0367_readbits(state,F367TER_SYR_GUARD); */
 766
 767         /*suppress EPQ auto for SYR_GARD 1/16 or 1/32
 768         and set channel predictor in automatic */
 769 #if 0
 770         switch (guard) {
 771
 772         case 0:
 773         case 1:
 774                 stv0367_writebits(state, F367TER_AUTO_LE_EN, 0);
 775                 stv0367_writereg(state, R367TER_CHC_CTL, 0x01);
 776                 break;
 777         case 2:
 778         case 3:
 779                 stv0367_writebits(state, F367TER_AUTO_LE_EN, 1);
 780                 stv0367_writereg(state, R367TER_CHC_CTL, 0x11);
 781                 break;
 782
 783         default:
 784                 return FE_TER_SWNOK;
 785         }
 786 #endif
 787
 788         /*reset fec an reedsolo FOR 367 only*/
 789         stv0367_writebits(state, F367TER_RST_SFEC, 1);
 790         stv0367_writebits(state, F367TER_RST_REEDSOLO, 1);
 791         usleep_range(1000, 2000);
 792         stv0367_writebits(state, F367TER_RST_SFEC, 0);
 793         stv0367_writebits(state, F367TER_RST_REEDSOLO, 0);
 794
 795         u_var1 = stv0367_readbits(state, F367TER_LK);
 796         u_var2 = stv0367_readbits(state, F367TER_PRF);
 797         u_var3 = stv0367_readbits(state, F367TER_TPS_LOCK);
 798         /*      u_var4=stv0367_readbits(state,F367TER_TSFIFO_LINEOK); */
 799
 800         wd = stv0367ter_duration(mode, 125, 500, 250);
 801         tempo = stv0367ter_duration(mode, 4, 16, 8);
 802
 803         /*while ( ((!u_var1)||(!u_var2)||(!u_var3)||(!u_var4))  && (wd>=0)) */
 804         while (((!u_var1) || (!u_var2) || (!u_var3)) && (wd >= 0)) {
 805                 usleep_range(1000 * tempo, 1000 * (tempo + 1));
 806                 wd -= tempo;
 807                 u_var1 = stv0367_readbits(state, F367TER_LK);
 808                 u_var2 = stv0367_readbits(state, F367TER_PRF);
 809                 u_var3 = stv0367_readbits(state, F367TER_TPS_LOCK);
 810                 /*u_var4=stv0367_readbits(state, F367TER_TSFIFO_LINEOK); */
 811         }
 812
 813         if (!u_var1)
 814                 return FE_TER_NOLOCK;
 815
 816
 817         if (!u_var2)
 818                 return FE_TER_NOPRFOUND;
 819
 820         if (!u_var3)
 821                 return FE_TER_NOTPS;
 822
 823         guard = stv0367_readbits(state, F367TER_SYR_GUARD);
 824         stv0367_writereg(state, R367TER_CHC_CTL, 0x11);
 825         switch (guard) {
 826         case 0:
 827         case 1:
 828                 stv0367_writebits(state, F367TER_AUTO_LE_EN, 0);
 829                 /*stv0367_writereg(state,R367TER_CHC_CTL, 0x1);*/
 830                 stv0367_writebits(state, F367TER_SYR_FILTER, 0);
 831                 break;
 832         case 2:
 833         case 3:
 834                 stv0367_writebits(state, F367TER_AUTO_LE_EN, 1);
 835                 /*stv0367_writereg(state,R367TER_CHC_CTL, 0x11);*/
 836                 stv0367_writebits(state, F367TER_SYR_FILTER, 1);
 837                 break;
 838
 839         default:
 840                 return FE_TER_SWNOK;
 841         }
 842
 843         /* apply Sfec workaround if 8K 64QAM CR!=1/2*/
 844         if ((stv0367_readbits(state, F367TER_TPS_CONST) == 2) &&
 845                         (mode == 1) &&
 846                         (stv0367_readbits(state, F367TER_TPS_HPCODE) != 0)) {
 847                 stv0367_writereg(state, R367TER_SFDLYSETH, 0xc0);
 848                 stv0367_writereg(state, R367TER_SFDLYSETM, 0x60);
 849                 stv0367_writereg(state, R367TER_SFDLYSETL, 0x0);
 850         } else
 851                 stv0367_writereg(state, R367TER_SFDLYSETH, 0x0);
 852
 853         wd = stv0367ter_duration(mode, 125, 500, 250);
 854         u_var4 = stv0367_readbits(state, F367TER_TSFIFO_LINEOK);
 855
 856         while ((!u_var4) && (wd >= 0)) {
 857                 usleep_range(1000 * tempo, 1000 * (tempo + 1));
 858                 wd -= tempo;
 859                 u_var4 = stv0367_readbits(state, F367TER_TSFIFO_LINEOK);
 860         }
 861
 862         if (!u_var4)
 863                 return FE_TER_NOLOCK;
 864
 865         /* for 367 leave COM_N at 0x7 for IQ_mode*/
 866         /*if(ter_state->if_iq_mode!=FE_TER_NORMAL_IF_TUNER) {
 867                 tempo=0;
 868                 while ((stv0367_readbits(state,F367TER_COM_USEGAINTRK)!=1) &&
 869                 (stv0367_readbits(state,F367TER_COM_AGCLOCK)!=1)&&(tempo<100)) {
 870                         ChipWaitOrAbort(state,1);
 871                         tempo+=1;
 872                 }
 873
 874                 stv0367_writebits(state,F367TER_COM_N,0x17);
 875         } */
 876
 877         stv0367_writebits(state, F367TER_SYR_TR_DIS, 1);
 878
 879         dprintk("FE_TER_LOCKOK !!!\n");
 880
 881         return  FE_TER_LOCKOK;
 882
 883 }
 884
 885 static void stv0367ter_set_ts_mode(struct stv0367_state *state,
 886                                         enum stv0367_ts_mode PathTS)
 887 {
 888
 889         dprintk("%s:\n", __func__);
 890
 891         if (state == NULL)
 892                 return;
 893
 894         stv0367_writebits(state, F367TER_TS_DIS, 0);
 895         switch (PathTS) {
 896         default:
 897                 /*for removing warning :default we can assume in parallel mode*/
 898         case STV0367_PARALLEL_PUNCT_CLOCK:
 899                 stv0367_writebits(state, F367TER_TSFIFO_SERIAL, 0);
 900                 stv0367_writebits(state, F367TER_TSFIFO_DVBCI, 0);
 901                 break;
 902         case STV0367_SERIAL_PUNCT_CLOCK:
 903                 stv0367_writebits(state, F367TER_TSFIFO_SERIAL, 1);
 904                 stv0367_writebits(state, F367TER_TSFIFO_DVBCI, 1);
 905                 break;
 906         }
 907 }
 908
 909 static void stv0367ter_set_clk_pol(struct stv0367_state *state,
 910                                         enum stv0367_clk_pol clock)
 911 {
 912
 913         dprintk("%s:\n", __func__);
 914
 915         if (state == NULL)
 916                 return;
 917
 918         switch (clock) {
 919         case STV0367_RISINGEDGE_CLOCK:
 920                 stv0367_writebits(state, F367TER_TS_BYTE_CLK_INV, 1);
 921                 break;
 922         case STV0367_FALLINGEDGE_CLOCK:
 923                 stv0367_writebits(state, F367TER_TS_BYTE_CLK_INV, 0);
 924                 break;
 925                 /*case FE_TER_CLOCK_POLARITY_DEFAULT:*/
 926         default:
 927                 stv0367_writebits(state, F367TER_TS_BYTE_CLK_INV, 0);
 928                 break;
 929         }
 930 }
 931
 932 #if 0
 933 static void stv0367ter_core_sw(struct stv0367_state *state)
 934 {
 935
 936         dprintk("%s:\n", __func__);
 937
 938         stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
 939         stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
 940         msleep(350);
 941 }
 942 #endif
 943 static int stv0367ter_standby(struct dvb_frontend *fe, u8 standby_on)
 944 {
 945         struct stv0367_state *state = fe->demodulator_priv;
 946
 947         dprintk("%s:\n", __func__);
 948
 949         if (standby_on) {
 950                 stv0367_writebits(state, F367TER_STDBY, 1);
 951                 stv0367_writebits(state, F367TER_STDBY_FEC, 1);
 952                 stv0367_writebits(state, F367TER_STDBY_CORE, 1);
 953         } else {
 954                 stv0367_writebits(state, F367TER_STDBY, 0);
 955                 stv0367_writebits(state, F367TER_STDBY_FEC, 0);
 956                 stv0367_writebits(state, F367TER_STDBY_CORE, 0);
 957         }
 958
 959         return 0;
 960 }
 961
 962 static int stv0367ter_sleep(struct dvb_frontend *fe)
 963 {
 964         return stv0367ter_standby(fe, 1);
 965 }
 966
 967 static int stv0367ter_init(struct dvb_frontend *fe)
 968 {
 969         struct stv0367_state *state = fe->demodulator_priv;
 970         struct stv0367ter_state *ter_state = state->ter_state;
 971
 972         dprintk("%s:\n", __func__);
 973
 974         ter_state->pBER = 0;
 975
 976         stv0367_write_table(state,
 977                 stv0367_deftabs[state->deftabs][STV0367_TAB_TER]);
 978
 979         stv0367_pll_setup(state, STV0367_ICSPEED_53125, state->config->xtal);
 980
 981         stv0367_writereg(state, R367TER_I2CRPT, 0xa0);
 982         stv0367_writereg(state, R367TER_ANACTRL, 0x00);
 983
 984         /*Set TS1 and TS2 to serial or parallel mode */
 985         stv0367ter_set_ts_mode(state, state->config->ts_mode);
 986         stv0367ter_set_clk_pol(state, state->config->clk_pol);
 987
 988         state->chip_id = stv0367_readreg(state, R367TER_ID);
 989         ter_state->first_lock = 0;
 990         ter_state->unlock_counter = 2;
 991
 992         return 0;
 993 }
 994
 995 static int stv0367ter_algo(struct dvb_frontend *fe)
 996 {
 997         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 998         struct stv0367_state *state = fe->demodulator_priv;
 999         struct stv0367ter_state *ter_state = state->ter_state;
1000         int offset = 0, tempo = 0;
1001         u8 u_var;
1002         u8 /*constell,*/ counter;
1003         s8 step;
1004         s32 timing_offset = 0;
1005         u32 trl_nomrate = 0, InternalFreq = 0, temp = 0, ifkhz = 0;
1006
1007         dprintk("%s:\n", __func__);
1008
1009         stv0367_get_if_khz(state, &ifkhz);
1010
1011         ter_state->frequency = p->frequency;
1012         ter_state->force = FE_TER_FORCENONE
1013                         + stv0367_readbits(state, F367TER_FORCE) * 2;
1014         ter_state->if_iq_mode = state->config->if_iq_mode;
1015         switch (state->config->if_iq_mode) {
1016         case FE_TER_NORMAL_IF_TUNER:  /* Normal IF mode */
1017                 dprintk("ALGO: FE_TER_NORMAL_IF_TUNER selected\n");
1018                 stv0367_writebits(state, F367TER_TUNER_BB, 0);
1019                 stv0367_writebits(state, F367TER_LONGPATH_IF, 0);
1020                 stv0367_writebits(state, F367TER_DEMUX_SWAP, 0);
1021                 break;
1022         case FE_TER_LONGPATH_IF_TUNER:  /* Long IF mode */
1023                 dprintk("ALGO: FE_TER_LONGPATH_IF_TUNER selected\n");
1024                 stv0367_writebits(state, F367TER_TUNER_BB, 0);
1025                 stv0367_writebits(state, F367TER_LONGPATH_IF, 1);
1026                 stv0367_writebits(state, F367TER_DEMUX_SWAP, 1);
1027                 break;
1028         case FE_TER_IQ_TUNER:  /* IQ mode */
1029                 dprintk("ALGO: FE_TER_IQ_TUNER selected\n");
1030                 stv0367_writebits(state, F367TER_TUNER_BB, 1);
1031                 stv0367_writebits(state, F367TER_PPM_INVSEL, 0);
1032                 break;
1033         default:
1034                 printk(KERN_ERR "ALGO: wrong TUNER type selected\n");
1035                 return -EINVAL;
1036         }
1037
1038         usleep_range(5000, 7000);
1039
1040         switch (p->inversion) {
1041         case INVERSION_AUTO:
1042         default:
1043                 dprintk("%s: inversion AUTO\n", __func__);
1044                 if (ter_state->if_iq_mode == FE_TER_IQ_TUNER)
1045                         stv0367_writebits(state, F367TER_IQ_INVERT,
1046                                                 ter_state->sense);
1047                 else
1048                         stv0367_writebits(state, F367TER_INV_SPECTR,
1049                                                 ter_state->sense);
1050
1051                 break;
1052         case INVERSION_ON:
1053         case INVERSION_OFF:
1054                 if (ter_state->if_iq_mode == FE_TER_IQ_TUNER)
1055                         stv0367_writebits(state, F367TER_IQ_INVERT,
1056                                                 p->inversion);
1057                 else
1058                         stv0367_writebits(state, F367TER_INV_SPECTR,
1059                                                 p->inversion);
1060
1061                 break;
1062         }
1063
1064         if ((ter_state->if_iq_mode != FE_TER_NORMAL_IF_TUNER) &&
1065                                 (ter_state->pBW != ter_state->bw)) {
1066                 stv0367ter_agc_iir_lock_detect_set(state);
1067
1068                 /*set fine agc target to 180 for LPIF or IQ mode*/
1069                 /* set Q_AGCTarget */
1070                 stv0367_writebits(state, F367TER_SEL_IQNTAR, 1);
1071                 stv0367_writebits(state, F367TER_AUT_AGC_TARGET_MSB, 0xB);
1072                 /*stv0367_writebits(state,AUT_AGC_TARGET_LSB,0x04); */
1073
1074                 /* set Q_AGCTarget */
1075                 stv0367_writebits(state, F367TER_SEL_IQNTAR, 0);
1076                 stv0367_writebits(state, F367TER_AUT_AGC_TARGET_MSB, 0xB);
1077                 /*stv0367_writebits(state,AUT_AGC_TARGET_LSB,0x04); */
1078
1079                 if (!stv0367_iir_filt_init(state, ter_state->bw,
1080                                                 state->config->xtal))
1081                         return -EINVAL;
1082                 /*set IIR filter once for 6,7 or 8MHz BW*/
1083                 ter_state->pBW = ter_state->bw;
1084
1085                 stv0367ter_agc_iir_rst(state);
1086         }
1087
1088         if (ter_state->hierarchy == FE_TER_HIER_LOW_PRIO)
1089                 stv0367_writebits(state, F367TER_BDI_LPSEL, 0x01);
1090         else
1091                 stv0367_writebits(state, F367TER_BDI_LPSEL, 0x00);
1092
1093         InternalFreq = stv0367ter_get_mclk(state, state->config->xtal) / 1000;
1094         temp = (int)
1095                 ((((ter_state->bw * 64 * (1 << 15) * 100)
1096                                                 / (InternalFreq)) * 10) / 7);
1097
1098         stv0367_writebits(state, F367TER_TRL_NOMRATE_LSB, temp % 2);
1099         temp = temp / 2;
1100         stv0367_writebits(state, F367TER_TRL_NOMRATE_HI, temp / 256);
1101         stv0367_writebits(state, F367TER_TRL_NOMRATE_LO, temp % 256);
1102
1103         temp = stv0367_readbits(state, F367TER_TRL_NOMRATE_HI) * 512 +
1104                         stv0367_readbits(state, F367TER_TRL_NOMRATE_LO) * 2 +
1105                         stv0367_readbits(state, F367TER_TRL_NOMRATE_LSB);
1106         temp = (int)(((1 << 17) * ter_state->bw * 1000) / (7 * (InternalFreq)));
1107         stv0367_writebits(state, F367TER_GAIN_SRC_HI, temp / 256);
1108         stv0367_writebits(state, F367TER_GAIN_SRC_LO, temp % 256);
1109         temp = stv0367_readbits(state, F367TER_GAIN_SRC_HI) * 256 +
1110                         stv0367_readbits(state, F367TER_GAIN_SRC_LO);
1111
1112         temp = (int)
1113                 ((InternalFreq - ifkhz) * (1 << 16) / (InternalFreq));
1114
1115         dprintk("DEROT temp=0x%x\n", temp);
1116         stv0367_writebits(state, F367TER_INC_DEROT_HI, temp / 256);
1117         stv0367_writebits(state, F367TER_INC_DEROT_LO, temp % 256);
1118
1119         ter_state->echo_pos = 0;
1120         ter_state->ucblocks = 0; /* liplianin */
1121         ter_state->pBER = 0; /* liplianin */
1122         stv0367_writebits(state, F367TER_LONG_ECHO, ter_state->echo_pos);
1123
1124         if (stv0367ter_lock_algo(state) != FE_TER_LOCKOK)
1125                 return 0;
1126
1127         ter_state->state = FE_TER_LOCKOK;
1128
1129         ter_state->mode = stv0367_readbits(state, F367TER_SYR_MODE);
1130         ter_state->guard = stv0367_readbits(state, F367TER_SYR_GUARD);
1131
1132         ter_state->first_lock = 1; /* we know sense now :) */
1133
1134         ter_state->agc_val =
1135                         (stv0367_readbits(state, F367TER_AGC1_VAL_LO) << 16) +
1136                         (stv0367_readbits(state, F367TER_AGC1_VAL_HI) << 24) +
1137                         stv0367_readbits(state, F367TER_AGC2_VAL_LO) +
1138                         (stv0367_readbits(state, F367TER_AGC2_VAL_HI) << 8);
1139
1140         /* Carrier offset calculation */
1141         stv0367_writebits(state, F367TER_FREEZE, 1);
1142         offset = (stv0367_readbits(state, F367TER_CRL_FOFFSET_VHI) << 16) ;
1143         offset += (stv0367_readbits(state, F367TER_CRL_FOFFSET_HI) << 8);
1144         offset += (stv0367_readbits(state, F367TER_CRL_FOFFSET_LO));
1145         stv0367_writebits(state, F367TER_FREEZE, 0);
1146         if (offset > 8388607)
1147                 offset -= 16777216;
1148
1149         offset = offset * 2 / 16384;
1150
1151         if (ter_state->mode == FE_TER_MODE_2K)
1152                 offset = (offset * 4464) / 1000;/*** 1 FFT BIN=4.464khz***/
1153         else if (ter_state->mode == FE_TER_MODE_4K)
1154                 offset = (offset * 223) / 100;/*** 1 FFT BIN=2.23khz***/
1155         else  if (ter_state->mode == FE_TER_MODE_8K)
1156                 offset = (offset * 111) / 100;/*** 1 FFT BIN=1.1khz***/
1157
1158         if (stv0367_readbits(state, F367TER_PPM_INVSEL) == 1) {
1159                 if ((stv0367_readbits(state, F367TER_INV_SPECTR) ==
1160                                 (stv0367_readbits(state,
1161                                         F367TER_STATUS_INV_SPECRUM) == 1)))
1162                         offset = offset * -1;
1163         }
1164
1165         if (ter_state->bw == 6)
1166                 offset = (offset * 6) / 8;
1167         else if (ter_state->bw == 7)
1168                 offset = (offset * 7) / 8;
1169
1170         ter_state->frequency += offset;
1171
1172         tempo = 10;  /* exit even if timing_offset stays null */
1173         while ((timing_offset == 0) && (tempo > 0)) {
1174                 usleep_range(10000, 20000);     /*was 20ms  */
1175                 /* fine tuning of timing offset if required */
1176                 timing_offset = stv0367_readbits(state, F367TER_TRL_TOFFSET_LO)
1177                                 + 256 * stv0367_readbits(state,
1178                                                         F367TER_TRL_TOFFSET_HI);
1179                 if (timing_offset >= 32768)
1180                         timing_offset -= 65536;
1181                 trl_nomrate = (512 * stv0367_readbits(state,
1182                                                         F367TER_TRL_NOMRATE_HI)
1183                         + stv0367_readbits(state, F367TER_TRL_NOMRATE_LO) * 2
1184                         + stv0367_readbits(state, F367TER_TRL_NOMRATE_LSB));
1185
1186                 timing_offset = ((signed)(1000000 / trl_nomrate) *
1187                                                         timing_offset) / 2048;
1188                 tempo--;
1189         }
1190
1191         if (timing_offset <= 0) {
1192                 timing_offset = (timing_offset - 11) / 22;
1193                 step = -1;
1194         } else {
1195                 timing_offset = (timing_offset + 11) / 22;
1196                 step = 1;
1197         }
1198
1199         for (counter = 0; counter < abs(timing_offset); counter++) {
1200                 trl_nomrate += step;
1201                 stv0367_writebits(state, F367TER_TRL_NOMRATE_LSB,
1202                                                 trl_nomrate % 2);
1203                 stv0367_writebits(state, F367TER_TRL_NOMRATE_LO,
1204                                                 trl_nomrate / 2);
1205                 usleep_range(1000, 2000);
1206         }
1207
1208         usleep_range(5000, 6000);
1209         /* unlocks could happen in case of trl centring big step,
1210         then a core off/on restarts demod */
1211         u_var = stv0367_readbits(state, F367TER_LK);
1212
1213         if (!u_var) {
1214                 stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
1215                 msleep(20);
1216                 stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
1217         }
1218
1219         return 0;
1220 }
1221
1222 static int stv0367ter_set_frontend(struct dvb_frontend *fe)
1223 {
1224         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1225         struct stv0367_state *state = fe->demodulator_priv;
1226         struct stv0367ter_state *ter_state = state->ter_state;
1227
1228         /*u8 trials[2]; */
1229         s8 num_trials, index;
1230         u8 SenseTrials[] = { INVERSION_ON, INVERSION_OFF };
1231
1232         if (state->reinit_on_setfrontend)
1233                 stv0367ter_init(fe);
1234
1235         if (fe->ops.tuner_ops.set_params) {
1236                 if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
1237                         fe->ops.i2c_gate_ctrl(fe, 1);
1238                 fe->ops.tuner_ops.set_params(fe);
1239                 if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
1240                         fe->ops.i2c_gate_ctrl(fe, 0);
1241         }
1242
1243         switch (p->transmission_mode) {
1244         default:
1245         case TRANSMISSION_MODE_AUTO:
1246         case TRANSMISSION_MODE_2K:
1247                 ter_state->mode = FE_TER_MODE_2K;
1248                 break;
1249 /*      case TRANSMISSION_MODE_4K:
1250                 pLook.mode = FE_TER_MODE_4K;
1251                 break;*/
1252         case TRANSMISSION_MODE_8K:
1253                 ter_state->mode = FE_TER_MODE_8K;
1254                 break;
1255         }
1256
1257         switch (p->guard_interval) {
1258         default:
1259         case GUARD_INTERVAL_1_32:
1260         case GUARD_INTERVAL_1_16:
1261         case GUARD_INTERVAL_1_8:
1262         case GUARD_INTERVAL_1_4:
1263                 ter_state->guard = p->guard_interval;
1264                 break;
1265         case GUARD_INTERVAL_AUTO:
1266                 ter_state->guard = GUARD_INTERVAL_1_32;
1267                 break;
1268         }
1269
1270         switch (p->bandwidth_hz) {
1271         case 6000000:
1272                 ter_state->bw = FE_TER_CHAN_BW_6M;
1273                 break;
1274         case 7000000:
1275                 ter_state->bw = FE_TER_CHAN_BW_7M;
1276                 break;
1277         case 8000000:
1278         default:
1279                 ter_state->bw = FE_TER_CHAN_BW_8M;
1280         }
1281
1282         ter_state->hierarchy = FE_TER_HIER_NONE;
1283
1284         switch (p->inversion) {
1285         case INVERSION_OFF:
1286         case INVERSION_ON:
1287                 num_trials = 1;
1288                 break;
1289         default:
1290                 num_trials = 2;
1291                 if (ter_state->first_lock)
1292                         num_trials = 1;
1293                 break;
1294         }
1295
1296         ter_state->state = FE_TER_NOLOCK;
1297         index = 0;
1298
1299         while (((index) < num_trials) && (ter_state->state != FE_TER_LOCKOK)) {
1300                 if (!ter_state->first_lock) {
1301                         if (p->inversion == INVERSION_AUTO)
1302                                 ter_state->sense = SenseTrials[index];
1303
1304                 }
1305                 stv0367ter_algo(fe);
1306
1307                 if ((ter_state->state == FE_TER_LOCKOK) &&
1308                                 (p->inversion == INVERSION_AUTO) &&
1309                                                                 (index == 1)) {
1310                         /* invert spectrum sense */
1311                         SenseTrials[index] = SenseTrials[0];
1312                         SenseTrials[(index + 1) % 2] = (SenseTrials[1] + 1) % 2;
1313                 }
1314
1315                 index++;
1316         }
1317
1318         return 0;
1319 }
1320
1321 static int stv0367ter_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1322 {
1323         struct stv0367_state *state = fe->demodulator_priv;
1324         struct stv0367ter_state *ter_state = state->ter_state;
1325         u32 errs = 0;
1326
1327         /*wait for counting completion*/
1328         if (stv0367_readbits(state, F367TER_SFERRC_OLDVALUE) == 0) {
1329                 errs =
1330                         ((u32)stv0367_readbits(state, F367TER_ERR_CNT1)
1331                         * (1 << 16))
1332                         + ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_HI)
1333                         * (1 << 8))
1334                         + ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_LO));
1335                 ter_state->ucblocks = errs;
1336         }
1337
1338         (*ucblocks) = ter_state->ucblocks;
1339
1340         return 0;
1341 }
1342
1343 static int stv0367ter_get_frontend(struct dvb_frontend *fe,
1344                                    struct dtv_frontend_properties *p)
1345 {
1346         struct stv0367_state *state = fe->demodulator_priv;
1347         struct stv0367ter_state *ter_state = state->ter_state;
1348         enum stv0367_ter_mode mode;
1349         int constell = 0,/* snr = 0,*/ Data = 0;
1350
1351         p->frequency = stv0367_get_tuner_freq(fe);
1352         if ((int)p->frequency < 0)
1353                 p->frequency = -p->frequency;
1354
1355         constell = stv0367_readbits(state, F367TER_TPS_CONST);
1356         if (constell == 0)
1357                 p->modulation = QPSK;
1358         else if (constell == 1)
1359                 p->modulation = QAM_16;
1360         else
1361                 p->modulation = QAM_64;
1362
1363         p->inversion = stv0367_readbits(state, F367TER_INV_SPECTR);
1364
1365         /* Get the Hierarchical mode */
1366         Data = stv0367_readbits(state, F367TER_TPS_HIERMODE);
1367
1368         switch (Data) {
1369         case 0:
1370                 p->hierarchy = HIERARCHY_NONE;
1371                 break;
1372         case 1:
1373                 p->hierarchy = HIERARCHY_1;
1374                 break;
1375         case 2:
1376                 p->hierarchy = HIERARCHY_2;
1377                 break;
1378         case 3:
1379                 p->hierarchy = HIERARCHY_4;
1380                 break;
1381         default:
1382                 p->hierarchy = HIERARCHY_AUTO;
1383                 break; /* error */
1384         }
1385
1386         /* Get the FEC Rate */
1387         if (ter_state->hierarchy == FE_TER_HIER_LOW_PRIO)
1388                 Data = stv0367_readbits(state, F367TER_TPS_LPCODE);
1389         else
1390                 Data = stv0367_readbits(state, F367TER_TPS_HPCODE);
1391
1392         switch (Data) {
1393         case 0:
1394                 p->code_rate_HP = FEC_1_2;
1395                 break;
1396         case 1:
1397                 p->code_rate_HP = FEC_2_3;
1398                 break;
1399         case 2:
1400                 p->code_rate_HP = FEC_3_4;
1401                 break;
1402         case 3:
1403                 p->code_rate_HP = FEC_5_6;
1404                 break;
1405         case 4:
1406                 p->code_rate_HP = FEC_7_8;
1407                 break;
1408         default:
1409                 p->code_rate_HP = FEC_AUTO;
1410                 break; /* error */
1411         }
1412
1413         mode = stv0367_readbits(state, F367TER_SYR_MODE);
1414
1415         switch (mode) {
1416         case FE_TER_MODE_2K:
1417                 p->transmission_mode = TRANSMISSION_MODE_2K;
1418                 break;
1419 /*      case FE_TER_MODE_4K:
1420                 p->transmission_mode = TRANSMISSION_MODE_4K;
1421                 break;*/
1422         case FE_TER_MODE_8K:
1423                 p->transmission_mode = TRANSMISSION_MODE_8K;
1424                 break;
1425         default:
1426                 p->transmission_mode = TRANSMISSION_MODE_AUTO;
1427         }
1428
1429         p->guard_interval = stv0367_readbits(state, F367TER_SYR_GUARD);
1430
1431         return 0;
1432 }
1433
1434 static u32 stv0367ter_snr_readreg(struct dvb_frontend *fe)
1435 {
1436         struct stv0367_state *state = fe->demodulator_priv;
1437         u32 snru32 = 0;
1438         int cpt = 0;
1439         u8 cut = stv0367_readbits(state, F367TER_IDENTIFICATIONREG);
1440
1441         while (cpt < 10) {
1442                 usleep_range(2000, 3000);
1443                 if (cut == 0x50) /*cut 1.0 cut 1.1*/
1444                         snru32 += stv0367_readbits(state, F367TER_CHCSNR) / 4;
1445                 else /*cu2.0*/
1446                         snru32 += 125 * stv0367_readbits(state, F367TER_CHCSNR);
1447
1448                 cpt++;
1449         }
1450         snru32 /= 10;/*average on 10 values*/
1451
1452         return snru32;
1453 }
1454
1455 static int stv0367ter_read_snr(struct dvb_frontend *fe, u16 *snr)
1456 {
1457         u32 snrval = stv0367ter_snr_readreg(fe);
1458
1459         *snr = snrval / 1000;
1460
1461         return 0;
1462 }
1463
1464 #if 0
1465 static int stv0367ter_status(struct dvb_frontend *fe)
1466 {
1467
1468         struct stv0367_state *state = fe->demodulator_priv;
1469         struct stv0367ter_state *ter_state = state->ter_state;
1470         int locked = FALSE;
1471
1472         locked = (stv0367_readbits(state, F367TER_LK));
1473         if (!locked)
1474                 ter_state->unlock_counter += 1;
1475         else
1476                 ter_state->unlock_counter = 0;
1477
1478         if (ter_state->unlock_counter > 2) {
1479                 if (!stv0367_readbits(state, F367TER_TPS_LOCK) ||
1480                                 (!stv0367_readbits(state, F367TER_LK))) {
1481                         stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
1482                         usleep_range(2000, 3000);
1483                         stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
1484                         msleep(350);
1485                         locked = (stv0367_readbits(state, F367TER_TPS_LOCK)) &&
1486                                         (stv0367_readbits(state, F367TER_LK));
1487                 }
1488
1489         }
1490
1491         return locked;
1492 }
1493 #endif
1494 static int stv0367ter_read_status(struct dvb_frontend *fe,
1495                                   enum fe_status *status)
1496 {
1497         struct stv0367_state *state = fe->demodulator_priv;
1498
1499         dprintk("%s:\n", __func__);
1500
1501         *status = 0;
1502
1503         if (stv0367_readbits(state, F367TER_LK)) {
1504                 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI
1505                           | FE_HAS_SYNC | FE_HAS_LOCK;
1506                 dprintk("%s: stv0367 has locked\n", __func__);
1507         }
1508
1509         return 0;
1510 }
1511
1512 static int stv0367ter_read_ber(struct dvb_frontend *fe, u32 *ber)
1513 {
1514         struct stv0367_state *state = fe->demodulator_priv;
1515         struct stv0367ter_state *ter_state = state->ter_state;
1516         u32 Errors = 0, tber = 0, temporary = 0;
1517         int abc = 0, def = 0;
1518
1519
1520         /*wait for counting completion*/
1521         if (stv0367_readbits(state, F367TER_SFERRC_OLDVALUE) == 0)
1522                 Errors = ((u32)stv0367_readbits(state, F367TER_SFEC_ERR_CNT)
1523                         * (1 << 16))
1524                         + ((u32)stv0367_readbits(state, F367TER_SFEC_ERR_CNT_HI)
1525                         * (1 << 8))
1526                         + ((u32)stv0367_readbits(state,
1527                                                 F367TER_SFEC_ERR_CNT_LO));
1528         /*measurement not completed, load previous value*/
1529         else {
1530                 tber = ter_state->pBER;
1531                 return 0;
1532         }
1533
1534         abc = stv0367_readbits(state, F367TER_SFEC_ERR_SOURCE);
1535         def = stv0367_readbits(state, F367TER_SFEC_NUM_EVENT);
1536
1537         if (Errors == 0) {
1538                 tber = 0;
1539         } else if (abc == 0x7) {
1540                 if (Errors <= 4) {
1541                         temporary = (Errors * 1000000000) / (8 * (1 << 14));
1542                 } else if (Errors <= 42) {
1543                         temporary = (Errors * 100000000) / (8 * (1 << 14));
1544                         temporary = temporary * 10;
1545                 } else if (Errors <= 429) {
1546                         temporary = (Errors * 10000000) / (8 * (1 << 14));
1547                         temporary = temporary * 100;
1548                 } else if (Errors <= 4294) {
1549                         temporary = (Errors * 1000000) / (8 * (1 << 14));
1550                         temporary = temporary * 1000;
1551                 } else if (Errors <= 42949) {
1552                         temporary = (Errors * 100000) / (8 * (1 << 14));
1553                         temporary = temporary * 10000;
1554                 } else if (Errors <= 429496) {
1555                         temporary = (Errors * 10000) / (8 * (1 << 14));
1556                         temporary = temporary * 100000;
1557                 } else { /*if (Errors<4294967) 2^22 max error*/
1558                         temporary = (Errors * 1000) / (8 * (1 << 14));
1559                         temporary = temporary * 100000; /* still to *10 */
1560                 }
1561
1562                 /* Byte error*/
1563                 if (def == 2)
1564                         /*tber=Errors/(8*(1 <<14));*/
1565                         tber = temporary;
1566                 else if (def == 3)
1567                         /*tber=Errors/(8*(1 <<16));*/
1568                         tber = temporary / 4;
1569                 else if (def == 4)
1570                         /*tber=Errors/(8*(1 <<18));*/
1571                         tber = temporary / 16;
1572                 else if (def == 5)
1573                         /*tber=Errors/(8*(1 <<20));*/
1574                         tber = temporary / 64;
1575                 else if (def == 6)
1576                         /*tber=Errors/(8*(1 <<22));*/
1577                         tber = temporary / 256;
1578                 else
1579                         /* should not pass here*/
1580                         tber = 0;
1581
1582                 if ((Errors < 4294967) && (Errors > 429496))
1583                         tber *= 10;
1584
1585         }
1586
1587         /* save actual value */
1588         ter_state->pBER = tber;
1589
1590         (*ber) = tber;
1591
1592         return 0;
1593 }
1594 #if 0
1595 static u32 stv0367ter_get_per(struct stv0367_state *state)
1596 {
1597         struct stv0367ter_state *ter_state = state->ter_state;
1598         u32 Errors = 0, Per = 0, temporary = 0;
1599         int abc = 0, def = 0, cpt = 0;
1600
1601         while (((stv0367_readbits(state, F367TER_SFERRC_OLDVALUE) == 1) &&
1602                         (cpt < 400)) || ((Errors == 0) && (cpt < 400))) {
1603                 usleep_range(1000, 2000);
1604                 Errors = ((u32)stv0367_readbits(state, F367TER_ERR_CNT1)
1605                         * (1 << 16))
1606                         + ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_HI)
1607                         * (1 << 8))
1608                         + ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_LO));
1609                 cpt++;
1610         }
1611         abc = stv0367_readbits(state, F367TER_ERR_SRC1);
1612         def = stv0367_readbits(state, F367TER_NUM_EVT1);
1613
1614         if (Errors == 0)
1615                 Per = 0;
1616         else if (abc == 0x9) {
1617                 if (Errors <= 4) {
1618                         temporary = (Errors * 1000000000) / (8 * (1 << 8));
1619                 } else if (Errors <= 42) {
1620                         temporary = (Errors * 100000000) / (8 * (1 << 8));
1621                         temporary = temporary * 10;
1622                 } else if (Errors <= 429) {
1623                         temporary = (Errors * 10000000) / (8 * (1 << 8));
1624                         temporary = temporary * 100;
1625                 } else if (Errors <= 4294) {
1626                         temporary = (Errors * 1000000) / (8 * (1 << 8));
1627                         temporary = temporary * 1000;
1628                 } else if (Errors <= 42949) {
1629                         temporary = (Errors * 100000) / (8 * (1 << 8));
1630                         temporary = temporary * 10000;
1631                 } else { /*if(Errors<=429496)  2^16 errors max*/
1632                         temporary = (Errors * 10000) / (8 * (1 << 8));
1633                         temporary = temporary * 100000;
1634                 }
1635
1636                 /* pkt error*/
1637                 if (def == 2)
1638                         /*Per=Errors/(1 << 8);*/
1639                         Per = temporary;
1640                 else if (def == 3)
1641                         /*Per=Errors/(1 << 10);*/
1642                         Per = temporary / 4;
1643                 else if (def == 4)
1644                         /*Per=Errors/(1 << 12);*/
1645                         Per = temporary / 16;
1646                 else if (def == 5)
1647                         /*Per=Errors/(1 << 14);*/
1648                         Per = temporary / 64;
1649                 else if (def == 6)
1650                         /*Per=Errors/(1 << 16);*/
1651                         Per = temporary / 256;
1652                 else
1653                         Per = 0;
1654
1655         }
1656         /* save actual value */
1657         ter_state->pPER = Per;
1658
1659         return Per;
1660 }
1661 #endif
1662 static int stv0367_get_tune_settings(struct dvb_frontend *fe,
1663                                         struct dvb_frontend_tune_settings
1664                                         *fe_tune_settings)
1665 {
1666         fe_tune_settings->min_delay_ms = 1000;
1667         fe_tune_settings->step_size = 0;
1668         fe_tune_settings->max_drift = 0;
1669
1670         return 0;
1671 }
1672
1673 static void stv0367_release(struct dvb_frontend *fe)
1674 {
1675         struct stv0367_state *state = fe->demodulator_priv;
1676
1677         kfree(state->ter_state);
1678         kfree(state->cab_state);
1679         kfree(state);
1680 }
1681
1682 static const struct dvb_frontend_ops stv0367ter_ops = {
1683         .delsys = { SYS_DVBT },
1684         .info = {
1685                 .name                   = "ST STV0367 DVB-T",
1686                 .frequency_min_hz       =  47 * MHz,
1687                 .frequency_max_hz       = 862 * MHz,
1688                 .frequency_stepsize_hz  = 15625,
1689                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
1690                         FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
1691                         FE_CAN_FEC_AUTO |
1692                         FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
1693                         FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_QAM_AUTO |
1694                         FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_RECOVER |
1695                         FE_CAN_INVERSION_AUTO |
1696                         FE_CAN_MUTE_TS
1697         },
1698         .release = stv0367_release,
1699         .init = stv0367ter_init,
1700         .sleep = stv0367ter_sleep,
1701         .i2c_gate_ctrl = stv0367ter_gate_ctrl,
1702         .set_frontend = stv0367ter_set_frontend,
1703         .get_frontend = stv0367ter_get_frontend,
1704         .get_tune_settings = stv0367_get_tune_settings,
1705         .read_status = stv0367ter_read_status,
1706         .read_ber = stv0367ter_read_ber,/* too slow */
1707 /*      .read_signal_strength = stv0367_read_signal_strength,*/
1708         .read_snr = stv0367ter_read_snr,
1709         .read_ucblocks = stv0367ter_read_ucblocks,
1710 };
1711
1712 struct dvb_frontend *stv0367ter_attach(const struct stv0367_config *config,
1713                                    struct i2c_adapter *i2c)
1714 {
1715         struct stv0367_state *state = NULL;
1716         struct stv0367ter_state *ter_state = NULL;
1717
1718         /* allocate memory for the internal state */
1719         state = kzalloc(sizeof(struct stv0367_state), GFP_KERNEL);
1720         if (state == NULL)
1721                 goto error;
1722         ter_state = kzalloc(sizeof(struct stv0367ter_state), GFP_KERNEL);
1723         if (ter_state == NULL)
1724                 goto error;
1725
1726         /* setup the state */
1727         state->i2c = i2c;
1728         state->config = config;
1729         state->ter_state = ter_state;
1730         state->fe.ops = stv0367ter_ops;
1731         state->fe.demodulator_priv = state;
1732         state->chip_id = stv0367_readreg(state, 0xf000);
1733
1734         /* demod operation options */
1735         state->use_i2c_gatectrl = 1;
1736         state->deftabs = STV0367_DEFTAB_GENERIC;
1737         state->reinit_on_setfrontend = 1;
1738         state->auto_if_khz = 0;
1739
1740         dprintk("%s: chip_id = 0x%x\n", __func__, state->chip_id);
1741
1742         /* check if the demod is there */
1743         if ((state->chip_id != 0x50) && (state->chip_id != 0x60))
1744                 goto error;
1745
1746         return &state->fe;
1747
1748 error:
1749         kfree(ter_state);
1750         kfree(state);
1751         return NULL;
1752 }
1753 EXPORT_SYMBOL(stv0367ter_attach);
1754
1755 static int stv0367cab_gate_ctrl(struct dvb_frontend *fe, int enable)
1756 {
1757         struct stv0367_state *state = fe->demodulator_priv;
1758
1759         dprintk("%s:\n", __func__);
1760
1761         stv0367_writebits(state, F367CAB_I2CT_ON, (enable > 0) ? 1 : 0);
1762
1763         return 0;
1764 }
1765
1766 static u32 stv0367cab_get_mclk(struct dvb_frontend *fe, u32 ExtClk_Hz)
1767 {
1768         struct stv0367_state *state = fe->demodulator_priv;
1769         u32 mclk_Hz = 0;/* master clock frequency (Hz) */
1770         u32 M, N, P;
1771
1772
1773         if (stv0367_readbits(state, F367CAB_BYPASS_PLLXN) == 0) {
1774                 N = (u32)stv0367_readbits(state, F367CAB_PLL_NDIV);
1775                 if (N == 0)
1776                         N = N + 1;
1777
1778                 M = (u32)stv0367_readbits(state, F367CAB_PLL_MDIV);
1779                 if (M == 0)
1780                         M = M + 1;
1781
1782                 P = (u32)stv0367_readbits(state, F367CAB_PLL_PDIV);
1783
1784                 if (P > 5)
1785                         P = 5;
1786
1787                 mclk_Hz = ((ExtClk_Hz / 2) * N) / (M * (1 << P));
1788                 dprintk("stv0367cab_get_mclk BYPASS_PLLXN mclk_Hz=%d\n",
1789                                                                 mclk_Hz);
1790         } else
1791                 mclk_Hz = ExtClk_Hz;
1792
1793         dprintk("stv0367cab_get_mclk final mclk_Hz=%d\n", mclk_Hz);
1794
1795         return mclk_Hz;
1796 }
1797
1798 static u32 stv0367cab_get_adc_freq(struct dvb_frontend *fe, u32 ExtClk_Hz)
1799 {
1800         u32 ADCClk_Hz = ExtClk_Hz;
1801
1802         ADCClk_Hz = stv0367cab_get_mclk(fe, ExtClk_Hz);
1803
1804         return ADCClk_Hz;
1805 }
1806
1807 static enum stv0367cab_mod stv0367cab_SetQamSize(struct stv0367_state *state,
1808                                                  u32 SymbolRate,
1809                                                  enum stv0367cab_mod QAMSize)
1810 {
1811         /* Set QAM size */
1812         stv0367_writebits(state, F367CAB_QAM_MODE, QAMSize);
1813
1814         /* Set Registers settings specific to the QAM size */
1815         switch (QAMSize) {
1816         case FE_CAB_MOD_QAM4:
1817                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1818                 break;
1819         case FE_CAB_MOD_QAM16:
1820                 stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x64);
1821                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1822                 stv0367_writereg(state, R367CAB_FSM_STATE, 0x90);
1823                 stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1824                 stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1825                 stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x95);
1826                 stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x40);
1827                 stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0x8a);
1828                 break;
1829         case FE_CAB_MOD_QAM32:
1830                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1831                 stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x6e);
1832                 stv0367_writereg(state, R367CAB_FSM_STATE, 0xb0);
1833                 stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1834                 stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xb7);
1835                 stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x9d);
1836                 stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x7f);
1837                 stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0xa7);
1838                 break;
1839         case FE_CAB_MOD_QAM64:
1840                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x82);
1841                 stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x5a);
1842                 if (SymbolRate > 4500000) {
1843                         stv0367_writereg(state, R367CAB_FSM_STATE, 0xb0);
1844                         stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1845                         stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa5);
1846                 } else if (SymbolRate > 2500000) {
1847                         stv0367_writereg(state, R367CAB_FSM_STATE, 0xa0);
1848                         stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1849                         stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa6);
1850                 } else {
1851                         stv0367_writereg(state, R367CAB_FSM_STATE, 0xa0);
1852                         stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xd1);
1853                         stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1854                 }
1855                 stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x95);
1856                 stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x40);
1857                 stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0x99);
1858                 break;
1859         case FE_CAB_MOD_QAM128:
1860                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1861                 stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x76);
1862                 stv0367_writereg(state, R367CAB_FSM_STATE, 0x90);
1863                 stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xb1);
1864                 if (SymbolRate > 4500000)
1865                         stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1866                 else if (SymbolRate > 2500000)
1867                         stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa6);
1868                 else
1869                         stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0x97);
1870
1871                 stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x8e);
1872                 stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x7f);
1873                 stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0xa7);
1874                 break;
1875         case FE_CAB_MOD_QAM256:
1876                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x94);
1877                 stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x5a);
1878                 stv0367_writereg(state, R367CAB_FSM_STATE, 0xa0);
1879                 if (SymbolRate > 4500000)
1880                         stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1881                 else if (SymbolRate > 2500000)
1882                         stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1883                 else
1884                         stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xd1);
1885
1886                 stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1887                 stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x85);
1888                 stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x40);
1889                 stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0xa7);
1890                 break;
1891         case FE_CAB_MOD_QAM512:
1892                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1893                 break;
1894         case FE_CAB_MOD_QAM1024:
1895                 stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1896                 break;
1897         default:
1898                 break;
1899         }
1900
1901         return QAMSize;
1902 }
1903
1904 static u32 stv0367cab_set_derot_freq(struct stv0367_state *state,
1905                                         u32 adc_hz, s32 derot_hz)
1906 {
1907         u32 sampled_if = 0;
1908         u32 adc_khz;
1909
1910         adc_khz = adc_hz / 1000;
1911
1912         dprintk("%s: adc_hz=%d derot_hz=%d\n", __func__, adc_hz, derot_hz);
1913
1914         if (adc_khz != 0) {
1915                 if (derot_hz < 1000000)
1916                         derot_hz = adc_hz / 4; /* ZIF operation */
1917                 if (derot_hz > adc_hz)
1918                         derot_hz = derot_hz - adc_hz;
1919                 sampled_if = (u32)derot_hz / 1000;
1920                 sampled_if *= 32768;
1921                 sampled_if /= adc_khz;
1922                 sampled_if *= 256;
1923         }
1924
1925         if (sampled_if > 8388607)
1926                 sampled_if = 8388607;
1927
1928         dprintk("%s: sampled_if=0x%x\n", __func__, sampled_if);
1929
1930         stv0367_writereg(state, R367CAB_MIX_NCO_LL, sampled_if);
1931         stv0367_writereg(state, R367CAB_MIX_NCO_HL, (sampled_if >> 8));
1932         stv0367_writebits(state, F367CAB_MIX_NCO_INC_HH, (sampled_if >> 16));
1933
1934         return derot_hz;
1935 }
1936
1937 static u32 stv0367cab_get_derot_freq(struct stv0367_state *state, u32 adc_hz)
1938 {
1939         u32 sampled_if;
1940
1941         sampled_if = stv0367_readbits(state, F367CAB_MIX_NCO_INC_LL) +
1942                         (stv0367_readbits(state, F367CAB_MIX_NCO_INC_HL) << 8) +
1943                         (stv0367_readbits(state, F367CAB_MIX_NCO_INC_HH) << 16);
1944
1945         sampled_if /= 256;
1946         sampled_if *= (adc_hz / 1000);
1947         sampled_if += 1;
1948         sampled_if /= 32768;
1949
1950         return sampled_if;
1951 }
1952
1953 static u32 stv0367cab_set_srate(struct stv0367_state *state, u32 adc_hz,
1954                         u32 mclk_hz, u32 SymbolRate,
1955                         enum stv0367cab_mod QAMSize)
1956 {
1957         u32 QamSizeCorr = 0;
1958         u32 u32_tmp = 0, u32_tmp1 = 0;
1959         u32 adp_khz;
1960
1961         dprintk("%s:\n", __func__);
1962
1963         /* Set Correction factor of SRC gain */
1964         switch (QAMSize) {
1965         case FE_CAB_MOD_QAM4:
1966                 QamSizeCorr = 1110;
1967                 break;
1968         case FE_CAB_MOD_QAM16:
1969                 QamSizeCorr = 1032;
1970                 break;
1971         case FE_CAB_MOD_QAM32:
1972                 QamSizeCorr =  954;
1973                 break;
1974         case FE_CAB_MOD_QAM64:
1975                 QamSizeCorr =  983;
1976                 break;
1977         case FE_CAB_MOD_QAM128:
1978                 QamSizeCorr =  957;
1979                 break;
1980         case FE_CAB_MOD_QAM256:
1981                 QamSizeCorr =  948;
1982                 break;
1983         case FE_CAB_MOD_QAM512:
1984                 QamSizeCorr =    0;
1985                 break;
1986         case FE_CAB_MOD_QAM1024:
1987                 QamSizeCorr =  944;
1988                 break;
1989         default:
1990                 break;
1991         }
1992
1993         /* Transfer ratio calculation */
1994         if (adc_hz != 0) {
1995                 u32_tmp = 256 * SymbolRate;
1996                 u32_tmp = u32_tmp / adc_hz;
1997         }
1998         stv0367_writereg(state, R367CAB_EQU_CRL_TFR, (u8)u32_tmp);
1999
2000         /* Symbol rate and SRC gain calculation */
2001         adp_khz = (mclk_hz >> 1) / 1000;/* TRL works at half the system clock */
2002         if (adp_khz != 0) {
2003                 u32_tmp = SymbolRate;
2004                 u32_tmp1 = SymbolRate;
2005
2006                 if (u32_tmp < 2097152) { /* 2097152 = 2^21 */
2007                         /* Symbol rate calculation */
2008                         u32_tmp *= 2048; /* 2048 = 2^11 */
2009                         u32_tmp = u32_tmp / adp_khz;
2010                         u32_tmp = u32_tmp * 16384; /* 16384 = 2^14 */
2011                         u32_tmp /= 125 ; /* 125 = 1000/2^3 */
2012                         u32_tmp = u32_tmp * 8; /* 8 = 2^3 */
2013
2014                         /* SRC Gain Calculation */
2015                         u32_tmp1 *= 2048; /* *2*2^10 */
2016                         u32_tmp1 /= 439; /* *2/878 */
2017                         u32_tmp1 *= 256; /* *2^8 */
2018                         u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz) */
2019                         u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2020                         u32_tmp1 = u32_tmp1 / 10000000;
2021
2022                 } else if (u32_tmp < 4194304) { /* 4194304 = 2**22 */
2023                         /* Symbol rate calculation */
2024                         u32_tmp *= 1024 ; /* 1024 = 2**10 */
2025                         u32_tmp = u32_tmp / adp_khz;
2026                         u32_tmp = u32_tmp * 16384; /* 16384 = 2**14 */
2027                         u32_tmp /= 125 ; /* 125 = 1000/2**3 */
2028                         u32_tmp = u32_tmp * 16; /* 16 = 2**4 */
2029
2030                         /* SRC Gain Calculation */
2031                         u32_tmp1 *= 1024; /* *2*2^9 */
2032                         u32_tmp1 /= 439; /* *2/878 */
2033                         u32_tmp1 *= 256; /* *2^8 */
2034                         u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz)*/
2035                         u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2036                         u32_tmp1 = u32_tmp1 / 5000000;
2037                 } else if (u32_tmp < 8388607) { /* 8388607 = 2**23 */
2038                         /* Symbol rate calculation */
2039                         u32_tmp *= 512 ; /* 512 = 2**9 */
2040                         u32_tmp = u32_tmp / adp_khz;
2041                         u32_tmp = u32_tmp * 16384; /* 16384 = 2**14 */
2042                         u32_tmp /= 125 ; /* 125 = 1000/2**3 */
2043                         u32_tmp = u32_tmp * 32; /* 32 = 2**5 */
2044
2045                         /* SRC Gain Calculation */
2046                         u32_tmp1 *= 512; /* *2*2^8 */
2047                         u32_tmp1 /= 439; /* *2/878 */
2048                         u32_tmp1 *= 256; /* *2^8 */
2049                         u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz) */
2050                         u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2051                         u32_tmp1 = u32_tmp1 / 2500000;
2052                 } else {
2053                         /* Symbol rate calculation */
2054                         u32_tmp *= 256 ; /* 256 = 2**8 */
2055                         u32_tmp = u32_tmp / adp_khz;
2056                         u32_tmp = u32_tmp * 16384; /* 16384 = 2**13 */
2057                         u32_tmp /= 125 ; /* 125 = 1000/2**3 */
2058                         u32_tmp = u32_tmp * 64; /* 64 = 2**6 */
2059
2060                         /* SRC Gain Calculation */
2061                         u32_tmp1 *= 256; /* 2*2^7 */
2062                         u32_tmp1 /= 439; /* *2/878 */
2063                         u32_tmp1 *= 256; /* *2^8 */
2064                         u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz) */
2065                         u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2066                         u32_tmp1 = u32_tmp1 / 1250000;
2067                 }
2068         }
2069 #if 0
2070         /* Filters' coefficients are calculated and written
2071         into registers only if the filters are enabled */
2072         if (stv0367_readbits(state, F367CAB_ADJ_EN)) {
2073                 stv0367cab_SetIirAdjacentcoefficient(state, mclk_hz,
2074                                                                 SymbolRate);
2075                 /* AllPass filter must be enabled
2076                 when the adjacents filter is used */
2077                 stv0367_writebits(state, F367CAB_ALLPASSFILT_EN, 1);
2078                 stv0367cab_SetAllPasscoefficient(state, mclk_hz, SymbolRate);
2079         } else
2080                 /* AllPass filter must be disabled
2081                 when the adjacents filter is not used */
2082 #endif
2083         stv0367_writebits(state, F367CAB_ALLPASSFILT_EN, 0);
2084
2085         stv0367_writereg(state, R367CAB_SRC_NCO_LL, u32_tmp);
2086         stv0367_writereg(state, R367CAB_SRC_NCO_LH, (u32_tmp >> 8));
2087         stv0367_writereg(state, R367CAB_SRC_NCO_HL, (u32_tmp >> 16));
2088         stv0367_writereg(state, R367CAB_SRC_NCO_HH, (u32_tmp >> 24));
2089
2090         stv0367_writereg(state, R367CAB_IQDEM_GAIN_SRC_L, u32_tmp1 & 0x00ff);
2091         stv0367_writebits(state, F367CAB_GAIN_SRC_HI, (u32_tmp1 >> 8) & 0x00ff);
2092
2093         return SymbolRate ;
2094 }
2095
2096 static u32 stv0367cab_GetSymbolRate(struct stv0367_state *state, u32 mclk_hz)
2097 {
2098         u32 regsym;
2099         u32 adp_khz;
2100
2101         regsym = stv0367_readreg(state, R367CAB_SRC_NCO_LL) +
2102                 (stv0367_readreg(state, R367CAB_SRC_NCO_LH) << 8) +
2103                 (stv0367_readreg(state, R367CAB_SRC_NCO_HL) << 16) +
2104                 (stv0367_readreg(state, R367CAB_SRC_NCO_HH) << 24);
2105
2106         adp_khz = (mclk_hz >> 1) / 1000;/* TRL works at half the system clock */
2107
2108         if (regsym < 134217728) {               /* 134217728L = 2**27*/
2109                 regsym = regsym * 32;           /* 32 = 2**5 */
2110                 regsym = regsym / 32768;        /* 32768L = 2**15 */
2111                 regsym = adp_khz * regsym;      /* AdpClk in kHz */
2112                 regsym = regsym / 128;          /* 128 = 2**7 */
2113                 regsym *= 125 ;                 /* 125 = 1000/2**3 */
2114                 regsym /= 2048 ;                /* 2048 = 2**11 */
2115         } else if (regsym < 268435456) {        /* 268435456L = 2**28 */
2116                 regsym = regsym * 16;           /* 16 = 2**4 */
2117                 regsym = regsym / 32768;        /* 32768L = 2**15 */
2118                 regsym = adp_khz * regsym;      /* AdpClk in kHz */
2119                 regsym = regsym / 128;          /* 128 = 2**7 */
2120                 regsym *= 125 ;                 /* 125 = 1000/2**3*/
2121                 regsym /= 1024 ;                /* 256 = 2**10*/
2122         } else if (regsym < 536870912) {        /* 536870912L = 2**29*/
2123                 regsym = regsym * 8;            /* 8 = 2**3 */
2124                 regsym = regsym / 32768;        /* 32768L = 2**15 */
2125                 regsym = adp_khz * regsym;      /* AdpClk in kHz */
2126                 regsym = regsym / 128;          /* 128 = 2**7 */
2127                 regsym *= 125 ;                 /* 125 = 1000/2**3 */
2128                 regsym /= 512 ;                 /* 128 = 2**9 */
2129         } else {
2130                 regsym = regsym * 4;            /* 4 = 2**2 */
2131                 regsym = regsym / 32768;        /* 32768L = 2**15 */
2132                 regsym = adp_khz * regsym;      /* AdpClk in kHz */
2133                 regsym = regsym / 128;          /* 128 = 2**7 */
2134                 regsym *= 125 ;                 /* 125 = 1000/2**3 */
2135                 regsym /= 256 ;                 /* 64 = 2**8 */
2136         }
2137
2138         return regsym;
2139 }
2140
2141 static u32 stv0367cab_fsm_status(struct stv0367_state *state)
2142 {
2143         return stv0367_readbits(state, F367CAB_FSM_STATUS);
2144 }
2145
2146 static u32 stv0367cab_qamfec_lock(struct stv0367_state *state)
2147 {
2148         return stv0367_readbits(state,
2149                 (state->cab_state->qamfec_status_reg ?
2150                  state->cab_state->qamfec_status_reg :
2151                  F367CAB_QAMFEC_LOCK));
2152 }
2153
2154 static
2155 enum stv0367_cab_signal_type stv0367cab_fsm_signaltype(u32 qam_fsm_status)
2156 {
2157         enum stv0367_cab_signal_type signaltype = FE_CAB_NOAGC;
2158
2159         switch (qam_fsm_status) {
2160         case 1:
2161                 signaltype = FE_CAB_NOAGC;
2162                 break;
2163         case 2:
2164                 signaltype = FE_CAB_NOTIMING;
2165                 break;
2166         case 3:
2167                 signaltype = FE_CAB_TIMINGOK;
2168                 break;
2169         case 4:
2170                 signaltype = FE_CAB_NOCARRIER;
2171                 break;
2172         case 5:
2173                 signaltype = FE_CAB_CARRIEROK;
2174                 break;
2175         case 7:
2176                 signaltype = FE_CAB_NOBLIND;
2177                 break;
2178         case 8:
2179                 signaltype = FE_CAB_BLINDOK;
2180                 break;
2181         case 10:
2182                 signaltype = FE_CAB_NODEMOD;
2183                 break;
2184         case 11:
2185                 signaltype = FE_CAB_DEMODOK;
2186                 break;
2187         case 12:
2188                 signaltype = FE_CAB_DEMODOK;
2189                 break;
2190         case 13:
2191                 signaltype = FE_CAB_NODEMOD;
2192                 break;
2193         case 14:
2194                 signaltype = FE_CAB_NOBLIND;
2195                 break;
2196         case 15:
2197                 signaltype = FE_CAB_NOSIGNAL;
2198                 break;
2199         default:
2200                 break;
2201         }
2202
2203         return signaltype;
2204 }
2205
2206 static int stv0367cab_read_status(struct dvb_frontend *fe,
2207                                   enum fe_status *status)
2208 {
2209         struct stv0367_state *state = fe->demodulator_priv;
2210
2211         dprintk("%s:\n", __func__);
2212
2213         *status = 0;
2214
2215         /* update cab_state->state from QAM_FSM_STATUS */
2216         state->cab_state->state = stv0367cab_fsm_signaltype(
2217                 stv0367cab_fsm_status(state));
2218
2219         if (stv0367cab_qamfec_lock(state)) {
2220                 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI
2221                           | FE_HAS_SYNC | FE_HAS_LOCK;
2222                 dprintk("%s: stv0367 has locked\n", __func__);
2223         } else {
2224                 if (state->cab_state->state > FE_CAB_NOSIGNAL)
2225                         *status |= FE_HAS_SIGNAL;
2226
2227                 if (state->cab_state->state > FE_CAB_NOCARRIER)
2228                         *status |= FE_HAS_CARRIER;
2229
2230                 if (state->cab_state->state >= FE_CAB_DEMODOK)
2231                         *status |= FE_HAS_VITERBI;
2232
2233                 if (state->cab_state->state >= FE_CAB_DATAOK)
2234                         *status |= FE_HAS_SYNC;
2235         }
2236
2237         return 0;
2238 }
2239
2240 static int stv0367cab_standby(struct dvb_frontend *fe, u8 standby_on)
2241 {
2242         struct stv0367_state *state = fe->demodulator_priv;
2243
2244         dprintk("%s:\n", __func__);
2245
2246         if (standby_on) {
2247                 stv0367_writebits(state, F367CAB_BYPASS_PLLXN, 0x03);
2248                 stv0367_writebits(state, F367CAB_STDBY_PLLXN, 0x01);
2249                 stv0367_writebits(state, F367CAB_STDBY, 1);
2250                 stv0367_writebits(state, F367CAB_STDBY_CORE, 1);
2251                 stv0367_writebits(state, F367CAB_EN_BUFFER_I, 0);
2252                 stv0367_writebits(state, F367CAB_EN_BUFFER_Q, 0);
2253                 stv0367_writebits(state, F367CAB_POFFQ, 1);
2254                 stv0367_writebits(state, F367CAB_POFFI, 1);
2255         } else {
2256                 stv0367_writebits(state, F367CAB_STDBY_PLLXN, 0x00);
2257                 stv0367_writebits(state, F367CAB_BYPASS_PLLXN, 0x00);
2258                 stv0367_writebits(state, F367CAB_STDBY, 0);
2259                 stv0367_writebits(state, F367CAB_STDBY_CORE, 0);
2260                 stv0367_writebits(state, F367CAB_EN_BUFFER_I, 1);
2261                 stv0367_writebits(state, F367CAB_EN_BUFFER_Q, 1);
2262                 stv0367_writebits(state, F367CAB_POFFQ, 0);
2263                 stv0367_writebits(state, F367CAB_POFFI, 0);
2264         }
2265
2266         return 0;
2267 }
2268
2269 static int stv0367cab_sleep(struct dvb_frontend *fe)
2270 {
2271         return stv0367cab_standby(fe, 1);
2272 }
2273
2274 static int stv0367cab_init(struct dvb_frontend *fe)
2275 {
2276         struct stv0367_state *state = fe->demodulator_priv;
2277         struct stv0367cab_state *cab_state = state->cab_state;
2278
2279         dprintk("%s:\n", __func__);
2280
2281         stv0367_write_table(state,
2282                 stv0367_deftabs[state->deftabs][STV0367_TAB_CAB]);
2283
2284         switch (state->config->ts_mode) {
2285         case STV0367_DVBCI_CLOCK:
2286                 dprintk("Setting TSMode = STV0367_DVBCI_CLOCK\n");
2287                 stv0367_writebits(state, F367CAB_OUTFORMAT, 0x03);
2288                 break;
2289         case STV0367_SERIAL_PUNCT_CLOCK:
2290         case STV0367_SERIAL_CONT_CLOCK:
2291                 stv0367_writebits(state, F367CAB_OUTFORMAT, 0x01);
2292                 break;
2293         case STV0367_PARALLEL_PUNCT_CLOCK:
2294         case STV0367_OUTPUTMODE_DEFAULT:
2295                 stv0367_writebits(state, F367CAB_OUTFORMAT, 0x00);
2296                 break;
2297         }
2298
2299         switch (state->config->clk_pol) {
2300         case STV0367_RISINGEDGE_CLOCK:
2301                 stv0367_writebits(state, F367CAB_CLK_POLARITY, 0x00);
2302                 break;
2303         case STV0367_FALLINGEDGE_CLOCK:
2304         case STV0367_CLOCKPOLARITY_DEFAULT:
2305                 stv0367_writebits(state, F367CAB_CLK_POLARITY, 0x01);
2306                 break;
2307         }
2308
2309         stv0367_writebits(state, F367CAB_SYNC_STRIP, 0x00);
2310
2311         stv0367_writebits(state, F367CAB_CT_NBST, 0x01);
2312
2313         stv0367_writebits(state, F367CAB_TS_SWAP, 0x01);
2314
2315         stv0367_writebits(state, F367CAB_FIFO_BYPASS, 0x00);
2316
2317         stv0367_writereg(state, R367CAB_ANACTRL, 0x00);/*PLL enabled and used */
2318
2319         cab_state->mclk = stv0367cab_get_mclk(fe, state->config->xtal);
2320         cab_state->adc_clk = stv0367cab_get_adc_freq(fe, state->config->xtal);
2321
2322         return 0;
2323 }
2324 static
2325 enum stv0367_cab_signal_type stv0367cab_algo(struct stv0367_state *state,
2326                                              struct dtv_frontend_properties *p)
2327 {
2328         struct stv0367cab_state *cab_state = state->cab_state;
2329         enum stv0367_cab_signal_type signalType = FE_CAB_NOAGC;
2330         u32     QAMFEC_Lock, QAM_Lock, u32_tmp, ifkhz,
2331                 LockTime, TRLTimeOut, AGCTimeOut, CRLSymbols,
2332                 CRLTimeOut, EQLTimeOut, DemodTimeOut, FECTimeOut;
2333         u8      TrackAGCAccum;
2334         s32     tmp;
2335
2336         dprintk("%s:\n", __func__);
2337
2338         stv0367_get_if_khz(state, &ifkhz);
2339
2340         /* Timeouts calculation */
2341         /* A max lock time of 25 ms is allowed for delayed AGC */
2342         AGCTimeOut = 25;
2343         /* 100000 symbols needed by the TRL as a maximum value */
2344         TRLTimeOut = 100000000 / p->symbol_rate;
2345         /* CRLSymbols is the needed number of symbols to achieve a lock
2346            within [-4%, +4%] of the symbol rate.
2347            CRL timeout is calculated
2348            for a lock within [-search_range, +search_range].
2349            EQL timeout can be changed depending on
2350            the micro-reflections we want to handle.
2351            A characterization must be performed
2352            with these echoes to get new timeout values.
2353         */
2354         switch (p->modulation) {
2355         case QAM_16:
2356                 CRLSymbols = 150000;
2357                 EQLTimeOut = 100;
2358                 break;
2359         case QAM_32:
2360                 CRLSymbols = 250000;
2361                 EQLTimeOut = 100;
2362                 break;
2363         case QAM_64:
2364                 CRLSymbols = 200000;
2365                 EQLTimeOut = 100;
2366                 break;
2367         case QAM_128:
2368                 CRLSymbols = 250000;
2369                 EQLTimeOut = 100;
2370                 break;
2371         case QAM_256:
2372                 CRLSymbols = 250000;
2373                 EQLTimeOut = 100;
2374                 break;
2375         default:
2376                 CRLSymbols = 200000;
2377                 EQLTimeOut = 100;
2378                 break;
2379         }
2380 #if 0
2381         if (pIntParams->search_range < 0) {
2382                 CRLTimeOut = (25 * CRLSymbols *
2383                                 (-pIntParams->search_range / 1000)) /
2384                                         (pIntParams->symbol_rate / 1000);
2385         } else
2386 #endif
2387         CRLTimeOut = (25 * CRLSymbols * (cab_state->search_range / 1000)) /
2388                                         (p->symbol_rate / 1000);
2389
2390         CRLTimeOut = (1000 * CRLTimeOut) / p->symbol_rate;
2391         /* Timeouts below 50ms are coerced */
2392         if (CRLTimeOut < 50)
2393                 CRLTimeOut = 50;
2394         /* A maximum of 100 TS packets is needed to get FEC lock even in case
2395         the spectrum inversion needs to be changed.
2396            This is equal to 20 ms in case of the lowest symbol rate of 0.87Msps
2397         */
2398         FECTimeOut = 20;
2399         DemodTimeOut = AGCTimeOut + TRLTimeOut + CRLTimeOut + EQLTimeOut;
2400
2401         dprintk("%s: DemodTimeOut=%d\n", __func__, DemodTimeOut);
2402
2403         /* Reset the TRL to ensure nothing starts until the
2404            AGC is stable which ensures a better lock time
2405         */
2406         stv0367_writereg(state, R367CAB_CTRL_1, 0x04);
2407         /* Set AGC accumulation time to minimum and lock threshold to maximum
2408         in order to speed up the AGC lock */
2409         TrackAGCAccum = stv0367_readbits(state, F367CAB_AGC_ACCUMRSTSEL);
2410         stv0367_writebits(state, F367CAB_AGC_ACCUMRSTSEL, 0x0);
2411         /* Modulus Mapper is disabled */
2412         stv0367_writebits(state, F367CAB_MODULUSMAP_EN, 0);
2413         /* Disable the sweep function */
2414         stv0367_writebits(state, F367CAB_SWEEP_EN, 0);
2415         /* The sweep function is never used, Sweep rate must be set to 0 */
2416         /* Set the derotator frequency in Hz */
2417         stv0367cab_set_derot_freq(state, cab_state->adc_clk,
2418                 (1000 * (s32)ifkhz + cab_state->derot_offset));
2419         /* Disable the Allpass Filter when the symbol rate is out of range */
2420         if ((p->symbol_rate > 10800000) | (p->symbol_rate < 1800000)) {
2421                 stv0367_writebits(state, F367CAB_ADJ_EN, 0);
2422                 stv0367_writebits(state, F367CAB_ALLPASSFILT_EN, 0);
2423         }
2424 #if 0
2425         /* Check if the tuner is locked */
2426         tuner_lock = stv0367cab_tuner_get_status(fe);
2427         if (tuner_lock == 0)
2428                 return FE_367CAB_NOTUNER;
2429 #endif
2430         /* Release the TRL to start demodulator acquisition */
2431         /* Wait for QAM lock */
2432         LockTime = 0;
2433         stv0367_writereg(state, R367CAB_CTRL_1, 0x00);
2434         do {
2435                 QAM_Lock = stv0367cab_fsm_status(state);
2436                 if ((LockTime >= (DemodTimeOut - EQLTimeOut)) &&
2437                                                         (QAM_Lock == 0x04))
2438                         /*
2439                          * We don't wait longer, the frequency/phase offset
2440                          * must be too big
2441                          */
2442                         LockTime = DemodTimeOut;
2443                 else if ((LockTime >= (AGCTimeOut + TRLTimeOut)) &&
2444                                                         (QAM_Lock == 0x02))
2445                         /*
2446                          * We don't wait longer, either there is no signal or
2447                          * it is not the right symbol rate or it is an analog
2448                          * carrier
2449                          */
2450                 {
2451                         LockTime = DemodTimeOut;
2452                         u32_tmp = stv0367_readbits(state,
2453                                                 F367CAB_AGC_PWR_WORD_LO) +
2454                                         (stv0367_readbits(state,
2455                                                 F367CAB_AGC_PWR_WORD_ME) << 8) +
2456                                         (stv0367_readbits(state,
2457                                                 F367CAB_AGC_PWR_WORD_HI) << 16);
2458                         if (u32_tmp >= 131072)
2459                                 u32_tmp = 262144 - u32_tmp;
2460                         u32_tmp = u32_tmp / (1 << (11 - stv0367_readbits(state,
2461                                                         F367CAB_AGC_IF_BWSEL)));
2462
2463                         if (u32_tmp < stv0367_readbits(state,
2464                                                 F367CAB_AGC_PWRREF_LO) +
2465                                         256 * stv0367_readbits(state,
2466                                                 F367CAB_AGC_PWRREF_HI) - 10)
2467                                 QAM_Lock = 0x0f;
2468                 } else {
2469                         usleep_range(10000, 20000);
2470                         LockTime += 10;
2471                 }
2472                 dprintk("QAM_Lock=0x%x LockTime=%d\n", QAM_Lock, LockTime);
2473                 tmp = stv0367_readreg(state, R367CAB_IT_STATUS1);
2474
2475                 dprintk("R367CAB_IT_STATUS1=0x%x\n", tmp);
2476
2477         } while (((QAM_Lock != 0x0c) && (QAM_Lock != 0x0b)) &&
2478                                                 (LockTime < DemodTimeOut));
2479
2480         dprintk("QAM_Lock=0x%x\n", QAM_Lock);
2481
2482         tmp = stv0367_readreg(state, R367CAB_IT_STATUS1);
2483         dprintk("R367CAB_IT_STATUS1=0x%x\n", tmp);
2484         tmp = stv0367_readreg(state, R367CAB_IT_STATUS2);
2485         dprintk("R367CAB_IT_STATUS2=0x%x\n", tmp);
2486
2487         tmp  = stv0367cab_get_derot_freq(state, cab_state->adc_clk);
2488         dprintk("stv0367cab_get_derot_freq=0x%x\n", tmp);
2489
2490         if ((QAM_Lock == 0x0c) || (QAM_Lock == 0x0b)) {
2491                 /* Wait for FEC lock */
2492                 LockTime = 0;
2493                 do {
2494                         usleep_range(5000, 7000);
2495                         LockTime += 5;
2496                         QAMFEC_Lock = stv0367cab_qamfec_lock(state);
2497                 } while (!QAMFEC_Lock && (LockTime < FECTimeOut));
2498         } else
2499                 QAMFEC_Lock = 0;
2500
2501         if (QAMFEC_Lock) {
2502                 signalType = FE_CAB_DATAOK;
2503                 cab_state->spect_inv = stv0367_readbits(state,
2504                                                         F367CAB_QUAD_INV);
2505 #if 0
2506 /* not clear for me */
2507                 if (ifkhz != 0) {
2508                         if (ifkhz > cab_state->adc_clk / 1000) {
2509                                 cab_state->freq_khz =
2510                                         FE_Cab_TunerGetFrequency(pIntParams->hTuner)
2511                                 - stv0367cab_get_derot_freq(state, cab_state->adc_clk)
2512                                 - cab_state->adc_clk / 1000 + ifkhz;
2513                         } else {
2514                                 cab_state->freq_khz =
2515                                                 FE_Cab_TunerGetFrequency(pIntParams->hTuner)
2516                                                 - stv0367cab_get_derot_freq(state, cab_state->adc_clk)
2517                                                 + ifkhz;
2518                         }
2519                 } else {
2520                         cab_state->freq_khz =
2521                                 FE_Cab_TunerGetFrequency(pIntParams->hTuner) +
2522                                 stv0367cab_get_derot_freq(state,
2523                                                         cab_state->adc_clk) -
2524                                 cab_state->adc_clk / 4000;
2525                 }
2526 #endif
2527                 cab_state->symbol_rate = stv0367cab_GetSymbolRate(state,
2528                                                         cab_state->mclk);
2529                 cab_state->locked = 1;
2530
2531                 /* stv0367_setbits(state, F367CAB_AGC_ACCUMRSTSEL,7);*/
2532         } else
2533                 signalType = stv0367cab_fsm_signaltype(QAM_Lock);
2534
2535         /* Set the AGC control values to tracking values */
2536         stv0367_writebits(state, F367CAB_AGC_ACCUMRSTSEL, TrackAGCAccum);
2537         return signalType;
2538 }
2539
2540 static int stv0367cab_set_frontend(struct dvb_frontend *fe)
2541 {
2542         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
2543         struct stv0367_state *state = fe->demodulator_priv;
2544         struct stv0367cab_state *cab_state = state->cab_state;
2545         enum stv0367cab_mod QAMSize = 0;
2546
2547         dprintk("%s: freq = %d, srate = %d\n", __func__,
2548                                         p->frequency, p->symbol_rate);
2549
2550         cab_state->derot_offset = 0;
2551
2552         switch (p->modulation) {
2553         case QAM_16:
2554                 QAMSize = FE_CAB_MOD_QAM16;
2555                 break;
2556         case QAM_32:
2557                 QAMSize = FE_CAB_MOD_QAM32;
2558                 break;
2559         case QAM_64:
2560                 QAMSize = FE_CAB_MOD_QAM64;
2561                 break;
2562         case QAM_128:
2563                 QAMSize = FE_CAB_MOD_QAM128;
2564                 break;
2565         case QAM_256:
2566                 QAMSize = FE_CAB_MOD_QAM256;
2567                 break;
2568         default:
2569                 break;
2570         }
2571
2572         if (state->reinit_on_setfrontend)
2573                 stv0367cab_init(fe);
2574
2575         /* Tuner Frequency Setting */
2576         if (fe->ops.tuner_ops.set_params) {
2577                 if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
2578                         fe->ops.i2c_gate_ctrl(fe, 1);
2579                 fe->ops.tuner_ops.set_params(fe);
2580                 if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
2581                         fe->ops.i2c_gate_ctrl(fe, 0);
2582         }
2583
2584         stv0367cab_SetQamSize(
2585                         state,
2586                         p->symbol_rate,
2587                         QAMSize);
2588
2589         stv0367cab_set_srate(state,
2590                         cab_state->adc_clk,
2591                         cab_state->mclk,
2592                         p->symbol_rate,
2593                         QAMSize);
2594         /* Search algorithm launch, [-1.1*RangeOffset, +1.1*RangeOffset] scan */
2595         cab_state->state = stv0367cab_algo(state, p);
2596         return 0;
2597 }
2598
2599 static int stv0367cab_get_frontend(struct dvb_frontend *fe,
2600                                    struct dtv_frontend_properties *p)
2601 {
2602         struct stv0367_state *state = fe->demodulator_priv;
2603         struct stv0367cab_state *cab_state = state->cab_state;
2604         u32 ifkhz = 0;
2605
2606         enum stv0367cab_mod QAMSize;
2607
2608         dprintk("%s:\n", __func__);
2609
2610         stv0367_get_if_khz(state, &ifkhz);
2611         p->symbol_rate = stv0367cab_GetSymbolRate(state, cab_state->mclk);
2612
2613         QAMSize = stv0367_readbits(state, F367CAB_QAM_MODE);
2614         switch (QAMSize) {
2615         case FE_CAB_MOD_QAM16:
2616                 p->modulation = QAM_16;
2617                 break;
2618         case FE_CAB_MOD_QAM32:
2619                 p->modulation = QAM_32;
2620                 break;
2621         case FE_CAB_MOD_QAM64:
2622                 p->modulation = QAM_64;
2623                 break;
2624         case FE_CAB_MOD_QAM128:
2625                 p->modulation = QAM_128;
2626                 break;
2627         case FE_CAB_MOD_QAM256:
2628                 p->modulation = QAM_256;
2629                 break;
2630         default:
2631                 break;
2632         }
2633
2634         p->frequency = stv0367_get_tuner_freq(fe);
2635
2636         dprintk("%s: tuner frequency = %d\n", __func__, p->frequency);
2637
2638         if (ifkhz == 0) {
2639                 p->frequency +=
2640                         (stv0367cab_get_derot_freq(state, cab_state->adc_clk) -
2641                         cab_state->adc_clk / 4000);
2642                 return 0;
2643         }
2644
2645         if (ifkhz > cab_state->adc_clk / 1000)
2646                 p->frequency += (ifkhz
2647                         - stv0367cab_get_derot_freq(state, cab_state->adc_clk)
2648                         - cab_state->adc_clk / 1000);
2649         else
2650                 p->frequency += (ifkhz
2651                         - stv0367cab_get_derot_freq(state, cab_state->adc_clk));
2652
2653         return 0;
2654 }
2655
2656 #if 0
2657 void stv0367cab_GetErrorCount(state, enum stv0367cab_mod QAMSize,
2658                         u32 symbol_rate, FE_367qam_Monitor *Monitor_results)
2659 {
2660         stv0367cab_OptimiseNByteAndGetBER(state, QAMSize, symbol_rate, Monitor_results);
2661         stv0367cab_GetPacketsCount(state, Monitor_results);
2662
2663         return;
2664 }
2665
2666 static int stv0367cab_read_ber(struct dvb_frontend *fe, u32 *ber)
2667 {
2668         struct stv0367_state *state = fe->demodulator_priv;
2669
2670         return 0;
2671 }
2672 #endif
2673 static s32 stv0367cab_get_rf_lvl(struct stv0367_state *state)
2674 {
2675         s32 rfLevel = 0;
2676         s32 RfAgcPwm = 0, IfAgcPwm = 0;
2677         u8 i;
2678
2679         stv0367_writebits(state, F367CAB_STDBY_ADCGP, 0x0);
2680
2681         RfAgcPwm =
2682                 (stv0367_readbits(state, F367CAB_RF_AGC1_LEVEL_LO) & 0x03) +
2683                 (stv0367_readbits(state, F367CAB_RF_AGC1_LEVEL_HI) << 2);
2684         RfAgcPwm = 100 * RfAgcPwm / 1023;
2685
2686         IfAgcPwm =
2687                 stv0367_readbits(state, F367CAB_AGC_IF_PWMCMD_LO) +
2688                 (stv0367_readbits(state, F367CAB_AGC_IF_PWMCMD_HI) << 8);
2689         if (IfAgcPwm >= 2048)
2690                 IfAgcPwm -= 2048;
2691         else
2692                 IfAgcPwm += 2048;
2693
2694         IfAgcPwm = 100 * IfAgcPwm / 4095;
2695
2696         /* For DTT75467 on NIM */
2697         if (RfAgcPwm < 90  && IfAgcPwm < 28) {
2698                 for (i = 0; i < RF_LOOKUP_TABLE_SIZE; i++) {
2699                         if (RfAgcPwm <= stv0367cab_RF_LookUp1[0][i]) {
2700                                 rfLevel = (-1) * stv0367cab_RF_LookUp1[1][i];
2701                                 break;
2702                         }
2703                 }
2704                 if (i == RF_LOOKUP_TABLE_SIZE)
2705                         rfLevel = -56;
2706         } else { /*if IF AGC>10*/
2707                 for (i = 0; i < RF_LOOKUP_TABLE2_SIZE; i++) {
2708                         if (IfAgcPwm <= stv0367cab_RF_LookUp2[0][i]) {
2709                                 rfLevel = (-1) * stv0367cab_RF_LookUp2[1][i];
2710                                 break;
2711                         }
2712                 }
2713                 if (i == RF_LOOKUP_TABLE2_SIZE)
2714                         rfLevel = -72;
2715         }
2716         return rfLevel;
2717 }
2718
2719 static int stv0367cab_read_strength(struct dvb_frontend *fe, u16 *strength)
2720 {
2721         struct stv0367_state *state = fe->demodulator_priv;
2722
2723         s32 signal =  stv0367cab_get_rf_lvl(state);
2724
2725         dprintk("%s: signal=%d dBm\n", __func__, signal);
2726
2727         if (signal <= -72)
2728                 *strength = 65535;
2729         else
2730                 *strength = (22 + signal) * (-1311);
2731
2732         dprintk("%s: strength=%d\n", __func__, (*strength));
2733
2734         return 0;
2735 }
2736
2737 static int stv0367cab_snr_power(struct dvb_frontend *fe)
2738 {
2739         struct stv0367_state *state = fe->demodulator_priv;
2740         enum stv0367cab_mod QAMSize;
2741
2742         QAMSize = stv0367_readbits(state, F367CAB_QAM_MODE);
2743         switch (QAMSize) {
2744         case FE_CAB_MOD_QAM4:
2745                 return 21904;
2746         case FE_CAB_MOD_QAM16:
2747                 return 20480;
2748         case FE_CAB_MOD_QAM32:
2749                 return 23040;
2750         case FE_CAB_MOD_QAM64:
2751                 return 21504;
2752         case FE_CAB_MOD_QAM128:
2753                 return 23616;
2754         case FE_CAB_MOD_QAM256:
2755                 return 21760;
2756         case FE_CAB_MOD_QAM1024:
2757                 return 21280;
2758         default:
2759                 break;
2760         }
2761
2762         return 1;
2763 }
2764
2765 static int stv0367cab_snr_readreg(struct dvb_frontend *fe, int avgdiv)
2766 {
2767         struct stv0367_state *state = fe->demodulator_priv;
2768         u32 regval = 0;
2769         int i;
2770
2771         for (i = 0; i < 10; i++) {
2772                 regval += (stv0367_readbits(state, F367CAB_SNR_LO)
2773                         + 256 * stv0367_readbits(state, F367CAB_SNR_HI));
2774         }
2775
2776         if (avgdiv)
2777                 regval /= 10;
2778
2779         return regval;
2780 }
2781
2782 static int stv0367cab_read_snr(struct dvb_frontend *fe, u16 *snr)
2783 {
2784         struct stv0367_state *state = fe->demodulator_priv;
2785         u32 noisepercentage;
2786         u32 regval = 0, temp = 0;
2787         int power;
2788
2789         power = stv0367cab_snr_power(fe);
2790         regval = stv0367cab_snr_readreg(fe, 1);
2791
2792         if (regval != 0) {
2793                 temp = power
2794                         * (1 << (3 + stv0367_readbits(state, F367CAB_SNR_PER)));
2795                 temp /= regval;
2796         }
2797
2798         /* table values, not needed to calculate logarithms */
2799         if (temp >= 5012)
2800                 noisepercentage = 100;
2801         else if (temp >= 3981)
2802                 noisepercentage = 93;
2803         else if (temp >= 3162)
2804                 noisepercentage = 86;
2805         else if (temp >= 2512)
2806                 noisepercentage = 79;
2807         else if (temp >= 1995)
2808                 noisepercentage = 72;
2809         else if (temp >= 1585)
2810                 noisepercentage = 65;
2811         else if (temp >= 1259)
2812                 noisepercentage = 58;
2813         else if (temp >= 1000)
2814                 noisepercentage = 50;
2815         else if (temp >= 794)
2816                 noisepercentage = 43;
2817         else if (temp >= 501)
2818                 noisepercentage = 36;
2819         else if (temp >= 316)
2820                 noisepercentage = 29;
2821         else if (temp >= 200)
2822                 noisepercentage = 22;
2823         else if (temp >= 158)
2824                 noisepercentage = 14;
2825         else if (temp >= 126)
2826                 noisepercentage = 7;
2827         else
2828                 noisepercentage = 0;
2829
2830         dprintk("%s: noisepercentage=%d\n", __func__, noisepercentage);
2831
2832         *snr = (noisepercentage * 65535) / 100;
2833
2834         return 0;
2835 }
2836
2837 static int stv0367cab_read_ucblcks(struct dvb_frontend *fe, u32 *ucblocks)
2838 {
2839         struct stv0367_state *state = fe->demodulator_priv;
2840         int corrected, tscount;
2841
2842         *ucblocks = (stv0367_readreg(state, R367CAB_RS_COUNTER_5) << 8)
2843                         | stv0367_readreg(state, R367CAB_RS_COUNTER_4);
2844         corrected = (stv0367_readreg(state, R367CAB_RS_COUNTER_3) << 8)
2845                         | stv0367_readreg(state, R367CAB_RS_COUNTER_2);
2846         tscount = (stv0367_readreg(state, R367CAB_RS_COUNTER_2) << 8)
2847                         | stv0367_readreg(state, R367CAB_RS_COUNTER_1);
2848
2849         dprintk("%s: uncorrected blocks=%d corrected blocks=%d tscount=%d\n",
2850                                 __func__, *ucblocks, corrected, tscount);
2851
2852         return 0;
2853 };
2854
2855 static const struct dvb_frontend_ops stv0367cab_ops = {
2856         .delsys = { SYS_DVBC_ANNEX_A },
2857         .info = {
2858                 .name = "ST STV0367 DVB-C",
2859                 .frequency_min_hz =  47 * MHz,
2860                 .frequency_max_hz = 862 * MHz,
2861                 .frequency_stepsize_hz = 62500,
2862                 .symbol_rate_min = 870000,
2863                 .symbol_rate_max = 11700000,
2864                 .caps = 0x400 |/* FE_CAN_QAM_4 */
2865                         FE_CAN_QAM_16 | FE_CAN_QAM_32  |
2866                         FE_CAN_QAM_64 | FE_CAN_QAM_128 |
2867                         FE_CAN_QAM_256 | FE_CAN_FEC_AUTO
2868         },
2869         .release                                = stv0367_release,
2870         .init                                   = stv0367cab_init,
2871         .sleep                                  = stv0367cab_sleep,
2872         .i2c_gate_ctrl                          = stv0367cab_gate_ctrl,
2873         .set_frontend                           = stv0367cab_set_frontend,
2874         .get_frontend                           = stv0367cab_get_frontend,
2875         .read_status                            = stv0367cab_read_status,
2876 /*      .read_ber                               = stv0367cab_read_ber, */
2877         .read_signal_strength                   = stv0367cab_read_strength,
2878         .read_snr                               = stv0367cab_read_snr,
2879         .read_ucblocks                          = stv0367cab_read_ucblcks,
2880         .get_tune_settings                      = stv0367_get_tune_settings,
2881 };
2882
2883 struct dvb_frontend *stv0367cab_attach(const struct stv0367_config *config,
2884                                    struct i2c_adapter *i2c)
2885 {
2886         struct stv0367_state *state = NULL;
2887         struct stv0367cab_state *cab_state = NULL;
2888
2889         /* allocate memory for the internal state */
2890         state = kzalloc(sizeof(struct stv0367_state), GFP_KERNEL);
2891         if (state == NULL)
2892                 goto error;
2893         cab_state = kzalloc(sizeof(struct stv0367cab_state), GFP_KERNEL);
2894         if (cab_state == NULL)
2895                 goto error;
2896
2897         /* setup the state */
2898         state->i2c = i2c;
2899         state->config = config;
2900         cab_state->search_range = 280000;
2901         cab_state->qamfec_status_reg = F367CAB_QAMFEC_LOCK;
2902         state->cab_state = cab_state;
2903         state->fe.ops = stv0367cab_ops;
2904         state->fe.demodulator_priv = state;
2905         state->chip_id = stv0367_readreg(state, 0xf000);
2906
2907         /* demod operation options */
2908         state->use_i2c_gatectrl = 1;
2909         state->deftabs = STV0367_DEFTAB_GENERIC;
2910         state->reinit_on_setfrontend = 1;
2911         state->auto_if_khz = 0;
2912
2913         dprintk("%s: chip_id = 0x%x\n", __func__, state->chip_id);
2914
2915         /* check if the demod is there */
2916         if ((state->chip_id != 0x50) && (state->chip_id != 0x60))
2917                 goto error;
2918
2919         return &state->fe;
2920
2921 error:
2922         kfree(cab_state);
2923         kfree(state);
2924         return NULL;
2925 }
2926 EXPORT_SYMBOL(stv0367cab_attach);
2927
2928 /*
2929  * Functions for operation on Digital Devices hardware
2930  */
2931
2932 static void stv0367ddb_setup_ter(struct stv0367_state *state)
2933 {
2934         stv0367_writereg(state, R367TER_DEBUG_LT4, 0x00);
2935         stv0367_writereg(state, R367TER_DEBUG_LT5, 0x00);
2936         stv0367_writereg(state, R367TER_DEBUG_LT6, 0x00); /* R367CAB_CTRL_1 */
2937         stv0367_writereg(state, R367TER_DEBUG_LT7, 0x00); /* R367CAB_CTRL_2 */
2938         stv0367_writereg(state, R367TER_DEBUG_LT8, 0x00);
2939         stv0367_writereg(state, R367TER_DEBUG_LT9, 0x00);
2940
2941         /* Tuner Setup */
2942         /* Buffer Q disabled, I Enabled, unsigned ADC */
2943         stv0367_writereg(state, R367TER_ANADIGCTRL, 0x89);
2944         stv0367_writereg(state, R367TER_DUAL_AD12, 0x04); /* ADCQ disabled */
2945
2946         /* Clock setup */
2947         /* PLL bypassed and disabled */
2948         stv0367_writereg(state, R367TER_ANACTRL, 0x0D);
2949         stv0367_writereg(state, R367TER_TOPCTRL, 0x00); /* Set OFDM */
2950
2951         /* IC runs at 54 MHz with a 27 MHz crystal */
2952         stv0367_pll_setup(state, STV0367_ICSPEED_53125, state->config->xtal);
2953
2954         msleep(50);
2955         /* PLL enabled and used */
2956         stv0367_writereg(state, R367TER_ANACTRL, 0x00);
2957
2958         state->activedemod = demod_ter;
2959 }
2960
2961 static void stv0367ddb_setup_cab(struct stv0367_state *state)
2962 {
2963         stv0367_writereg(state, R367TER_DEBUG_LT4, 0x00);
2964         stv0367_writereg(state, R367TER_DEBUG_LT5, 0x01);
2965         stv0367_writereg(state, R367TER_DEBUG_LT6, 0x06); /* R367CAB_CTRL_1 */
2966         stv0367_writereg(state, R367TER_DEBUG_LT7, 0x03); /* R367CAB_CTRL_2 */
2967         stv0367_writereg(state, R367TER_DEBUG_LT8, 0x00);
2968         stv0367_writereg(state, R367TER_DEBUG_LT9, 0x00);
2969
2970         /* Tuner Setup */
2971         /* Buffer Q disabled, I Enabled, signed ADC */
2972         stv0367_writereg(state, R367TER_ANADIGCTRL, 0x8B);
2973         /* ADCQ disabled */
2974         stv0367_writereg(state, R367TER_DUAL_AD12, 0x04);
2975
2976         /* Clock setup */
2977         /* PLL bypassed and disabled */
2978         stv0367_writereg(state, R367TER_ANACTRL, 0x0D);
2979         /* Set QAM */
2980         stv0367_writereg(state, R367TER_TOPCTRL, 0x10);
2981
2982         /* IC runs at 58 MHz with a 27 MHz crystal */
2983         stv0367_pll_setup(state, STV0367_ICSPEED_58000, state->config->xtal);
2984
2985         msleep(50);
2986         /* PLL enabled and used */
2987         stv0367_writereg(state, R367TER_ANACTRL, 0x00);
2988
2989         state->cab_state->mclk = stv0367cab_get_mclk(&state->fe,
2990                 state->config->xtal);
2991         state->cab_state->adc_clk = stv0367cab_get_adc_freq(&state->fe,
2992                 state->config->xtal);
2993
2994         state->activedemod = demod_cab;
2995 }
2996
2997 static int stv0367ddb_set_frontend(struct dvb_frontend *fe)
2998 {
2999         struct stv0367_state *state = fe->demodulator_priv;
3000
3001         switch (fe->dtv_property_cache.delivery_system) {
3002         case SYS_DVBT:
3003                 if (state->activedemod != demod_ter)
3004                         stv0367ddb_setup_ter(state);
3005
3006                 return stv0367ter_set_frontend(fe);
3007         case SYS_DVBC_ANNEX_A:
3008                 if (state->activedemod != demod_cab)
3009                         stv0367ddb_setup_cab(state);
3010
3011                 /* protect against division error oopses */
3012                 if (fe->dtv_property_cache.symbol_rate == 0) {
3013                         printk(KERN_ERR "Invalid symbol rate\n");
3014                         return -EINVAL;
3015                 }
3016
3017                 return stv0367cab_set_frontend(fe);
3018         default:
3019                 break;
3020         }
3021
3022         return -EINVAL;
3023 }
3024
3025 static void stv0367ddb_read_signal_strength(struct dvb_frontend *fe)
3026 {
3027         struct stv0367_state *state = fe->demodulator_priv;
3028         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3029         s32 signalstrength;
3030
3031         switch (state->activedemod) {
3032         case demod_cab:
3033                 signalstrength = stv0367cab_get_rf_lvl(state) * 1000;
3034                 break;
3035         default:
3036                 p->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3037                 return;
3038         }
3039
3040         p->strength.stat[0].scale = FE_SCALE_DECIBEL;
3041         p->strength.stat[0].uvalue = signalstrength;
3042 }
3043
3044 static void stv0367ddb_read_snr(struct dvb_frontend *fe)
3045 {
3046         struct stv0367_state *state = fe->demodulator_priv;
3047         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3048         int cab_pwr;
3049         u32 regval, tmpval, snrval = 0;
3050
3051         switch (state->activedemod) {
3052         case demod_ter:
3053                 snrval = stv0367ter_snr_readreg(fe);
3054                 break;
3055         case demod_cab:
3056                 cab_pwr = stv0367cab_snr_power(fe);
3057                 regval = stv0367cab_snr_readreg(fe, 0);
3058
3059                 /* prevent division by zero */
3060                 if (!regval) {
3061                         snrval = 0;
3062                         break;
3063                 }
3064
3065                 tmpval = (cab_pwr * 320) / regval;
3066                 snrval = ((tmpval != 0) ? (intlog2(tmpval) / 5581) : 0);
3067                 break;
3068         default:
3069                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3070                 return;
3071         }
3072
3073         p->cnr.stat[0].scale = FE_SCALE_DECIBEL;
3074         p->cnr.stat[0].uvalue = snrval;
3075 }
3076
3077 static void stv0367ddb_read_ucblocks(struct dvb_frontend *fe)
3078 {
3079         struct stv0367_state *state = fe->demodulator_priv;
3080         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3081         u32 ucblocks = 0;
3082
3083         switch (state->activedemod) {
3084         case demod_ter:
3085                 stv0367ter_read_ucblocks(fe, &ucblocks);
3086                 break;
3087         case demod_cab:
3088                 stv0367cab_read_ucblcks(fe, &ucblocks);
3089                 break;
3090         default:
3091                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3092                 return;
3093         }
3094
3095         p->block_error.stat[0].scale = FE_SCALE_COUNTER;
3096         p->block_error.stat[0].uvalue = ucblocks;
3097 }
3098
3099 static int stv0367ddb_read_status(struct dvb_frontend *fe,
3100                                   enum fe_status *status)
3101 {
3102         struct stv0367_state *state = fe->demodulator_priv;
3103         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3104         int ret = 0;
3105
3106         switch (state->activedemod) {
3107         case demod_ter:
3108                 ret = stv0367ter_read_status(fe, status);
3109                 break;
3110         case demod_cab:
3111                 ret = stv0367cab_read_status(fe, status);
3112                 break;
3113         default:
3114                 break;
3115         }
3116
3117         /* stop and report on *_read_status failure */
3118         if (ret)
3119                 return ret;
3120
3121         stv0367ddb_read_signal_strength(fe);
3122
3123         /* read carrier/noise when a carrier is detected */
3124         if (*status & FE_HAS_CARRIER)
3125                 stv0367ddb_read_snr(fe);
3126         else
3127                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3128
3129         /* read uncorrected blocks on FE_HAS_LOCK */
3130         if (*status & FE_HAS_LOCK)
3131                 stv0367ddb_read_ucblocks(fe);
3132         else
3133                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3134
3135         return 0;
3136 }
3137
3138 static int stv0367ddb_get_frontend(struct dvb_frontend *fe,
3139                                    struct dtv_frontend_properties *p)
3140 {
3141         struct stv0367_state *state = fe->demodulator_priv;
3142
3143         switch (state->activedemod) {
3144         case demod_ter:
3145                 return stv0367ter_get_frontend(fe, p);
3146         case demod_cab:
3147                 return stv0367cab_get_frontend(fe, p);
3148         default:
3149                 break;
3150         }
3151
3152         return 0;
3153 }
3154
3155 static int stv0367ddb_sleep(struct dvb_frontend *fe)
3156 {
3157         struct stv0367_state *state = fe->demodulator_priv;
3158
3159         switch (state->activedemod) {
3160         case demod_ter:
3161                 state->activedemod = demod_none;
3162                 return stv0367ter_sleep(fe);
3163         case demod_cab:
3164                 state->activedemod = demod_none;
3165                 return stv0367cab_sleep(fe);
3166         default:
3167                 break;
3168         }
3169
3170         return -EINVAL;
3171 }
3172
3173 static int stv0367ddb_init(struct stv0367_state *state)
3174 {
3175         struct stv0367ter_state *ter_state = state->ter_state;
3176         struct dtv_frontend_properties *p = &state->fe.dtv_property_cache;
3177
3178         stv0367_writereg(state, R367TER_TOPCTRL, 0x10);
3179
3180         if (stv0367_deftabs[state->deftabs][STV0367_TAB_BASE])
3181                 stv0367_write_table(state,
3182                         stv0367_deftabs[state->deftabs][STV0367_TAB_BASE]);
3183
3184         stv0367_write_table(state,
3185                 stv0367_deftabs[state->deftabs][STV0367_TAB_CAB]);
3186
3187         stv0367_writereg(state, R367TER_TOPCTRL, 0x00);
3188         stv0367_write_table(state,
3189                 stv0367_deftabs[state->deftabs][STV0367_TAB_TER]);
3190
3191         stv0367_writereg(state, R367TER_GAIN_SRC1, 0x2A);
3192         stv0367_writereg(state, R367TER_GAIN_SRC2, 0xD6);
3193         stv0367_writereg(state, R367TER_INC_DEROT1, 0x55);
3194         stv0367_writereg(state, R367TER_INC_DEROT2, 0x55);
3195         stv0367_writereg(state, R367TER_TRL_CTL, 0x14);
3196         stv0367_writereg(state, R367TER_TRL_NOMRATE1, 0xAE);
3197         stv0367_writereg(state, R367TER_TRL_NOMRATE2, 0x56);
3198         stv0367_writereg(state, R367TER_FEPATH_CFG, 0x0);
3199
3200         /* OFDM TS Setup */
3201
3202         stv0367_writereg(state, R367TER_TSCFGH, 0x70);
3203         stv0367_writereg(state, R367TER_TSCFGM, 0xC0);
3204         stv0367_writereg(state, R367TER_TSCFGL, 0x20);
3205         stv0367_writereg(state, R367TER_TSSPEED, 0x40); /* Fixed at 54 MHz */
3206
3207         stv0367_writereg(state, R367TER_TSCFGH, 0x71);
3208         stv0367_writereg(state, R367TER_TSCFGH, 0x70);
3209
3210         stv0367_writereg(state, R367TER_TOPCTRL, 0x10);
3211
3212         /* Also needed for QAM */
3213         stv0367_writereg(state, R367TER_AGC12C, 0x01); /* AGC Pin setup */
3214
3215         stv0367_writereg(state, R367TER_AGCCTRL1, 0x8A);
3216
3217         /* QAM TS setup, note exact format also depends on descrambler */
3218         /* settings */
3219         /* Inverted Clock, Swap, serial */
3220         stv0367_writereg(state, R367CAB_OUTFORMAT_0, 0x85);
3221
3222         /* Clock setup (PLL bypassed and disabled) */
3223         stv0367_writereg(state, R367TER_ANACTRL, 0x0D);
3224
3225         /* IC runs at 58 MHz with a 27 MHz crystal */
3226         stv0367_pll_setup(state, STV0367_ICSPEED_58000, state->config->xtal);
3227
3228         /* Tuner setup */
3229         /* Buffer Q disabled, I Enabled, signed ADC */
3230         stv0367_writereg(state, R367TER_ANADIGCTRL, 0x8b);
3231         stv0367_writereg(state, R367TER_DUAL_AD12, 0x04); /* ADCQ disabled */
3232
3233         /* Improves the C/N lock limit */
3234         stv0367_writereg(state, R367CAB_FSM_SNR2_HTH, 0x23);
3235         /* ZIF/IF Automatic mode */
3236         stv0367_writereg(state, R367CAB_IQ_QAM, 0x01);
3237         /* Improving burst noise performances */
3238         stv0367_writereg(state, R367CAB_EQU_FFE_LEAKAGE, 0x83);
3239         /* Improving ACI performances */
3240         stv0367_writereg(state, R367CAB_IQDEM_ADJ_EN, 0x05);
3241
3242         /* PLL enabled and used */
3243         stv0367_writereg(state, R367TER_ANACTRL, 0x00);
3244
3245         stv0367_writereg(state, R367TER_I2CRPT, (0x08 | ((5 & 0x07) << 4)));
3246
3247         ter_state->pBER = 0;
3248         ter_state->first_lock = 0;
3249         ter_state->unlock_counter = 2;
3250
3251         p->strength.len = 1;
3252         p->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3253         p->cnr.len = 1;
3254         p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3255         p->block_error.len = 1;
3256         p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3257
3258         return 0;
3259 }
3260
3261 static const struct dvb_frontend_ops stv0367ddb_ops = {
3262         .delsys = { SYS_DVBC_ANNEX_A, SYS_DVBT },
3263         .info = {
3264                 .name                   = "ST STV0367 DDB DVB-C/T",
3265                 .frequency_min_hz       =  47 * MHz,
3266                 .frequency_max_hz       = 865 * MHz,
3267                 .frequency_stepsize_hz  = 166667,
3268                 .symbol_rate_min        = 870000,
3269                 .symbol_rate_max        = 11700000,
3270                 .caps = /* DVB-C */
3271                         0x400 |/* FE_CAN_QAM_4 */
3272                         FE_CAN_QAM_16 | FE_CAN_QAM_32  |
3273                         FE_CAN_QAM_64 | FE_CAN_QAM_128 |
3274                         FE_CAN_QAM_256 |
3275                         /* DVB-T */
3276                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
3277                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
3278                         FE_CAN_QPSK | FE_CAN_TRANSMISSION_MODE_AUTO |
3279                         FE_CAN_RECOVER | FE_CAN_INVERSION_AUTO |
3280                         FE_CAN_MUTE_TS
3281         },
3282         .release = stv0367_release,
3283         .sleep = stv0367ddb_sleep,
3284         .i2c_gate_ctrl = stv0367cab_gate_ctrl, /* valid for TER and CAB */
3285         .set_frontend = stv0367ddb_set_frontend,
3286         .get_frontend = stv0367ddb_get_frontend,
3287         .get_tune_settings = stv0367_get_tune_settings,
3288         .read_status = stv0367ddb_read_status,
3289 };
3290
3291 struct dvb_frontend *stv0367ddb_attach(const struct stv0367_config *config,
3292                                    struct i2c_adapter *i2c)
3293 {
3294         struct stv0367_state *state = NULL;
3295         struct stv0367ter_state *ter_state = NULL;
3296         struct stv0367cab_state *cab_state = NULL;
3297
3298         /* allocate memory for the internal state */
3299         state = kzalloc(sizeof(struct stv0367_state), GFP_KERNEL);
3300         if (state == NULL)
3301                 goto error;
3302         ter_state = kzalloc(sizeof(struct stv0367ter_state), GFP_KERNEL);
3303         if (ter_state == NULL)
3304                 goto error;
3305         cab_state = kzalloc(sizeof(struct stv0367cab_state), GFP_KERNEL);
3306         if (cab_state == NULL)
3307                 goto error;
3308
3309         /* setup the state */
3310         state->i2c = i2c;
3311         state->config = config;
3312         state->ter_state = ter_state;
3313         cab_state->search_range = 280000;
3314         cab_state->qamfec_status_reg = F367CAB_DESCR_SYNCSTATE;
3315         state->cab_state = cab_state;
3316         state->fe.ops = stv0367ddb_ops;
3317         state->fe.demodulator_priv = state;
3318         state->chip_id = stv0367_readreg(state, R367TER_ID);
3319
3320         /* demod operation options */
3321         state->use_i2c_gatectrl = 0;
3322         state->deftabs = STV0367_DEFTAB_DDB;
3323         state->reinit_on_setfrontend = 0;
3324         state->auto_if_khz = 1;
3325         state->activedemod = demod_none;
3326
3327         dprintk("%s: chip_id = 0x%x\n", __func__, state->chip_id);
3328
3329         /* check if the demod is there */
3330         if ((state->chip_id != 0x50) && (state->chip_id != 0x60))
3331                 goto error;
3332
3333         dev_info(&i2c->dev, "Found %s with ChipID %02X at adr %02X\n",
3334                 state->fe.ops.info.name, state->chip_id,
3335                 config->demod_address);
3336
3337         stv0367ddb_init(state);
3338
3339         return &state->fe;
3340
3341 error:
3342         kfree(cab_state);
3343         kfree(ter_state);
3344         kfree(state);
3345         return NULL;
3346 }
3347 EXPORT_SYMBOL(stv0367ddb_attach);
3348
3349 MODULE_PARM_DESC(debug, "Set debug");
3350 MODULE_PARM_DESC(i2c_debug, "Set i2c debug");
3351
3352 MODULE_AUTHOR("Igor M. Liplianin");
3353 MODULE_DESCRIPTION("ST STV0367 DVB-C/T demodulator driver");
3354 MODULE_LICENSE("GPL");