drivers/media/usb/dvb-usb/dib0700_devices.c

   1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
   2  *
   3  *      This program is free software; you can redistribute it and/or modify it
   4  *      under the terms of the GNU General Public License as published by the Free
   5  *      Software Foundation, version 2.
   6  *
   7  *  Copyright (C) 2005-9 DiBcom, SA et al
   8  */
   9 #include "dib0700.h"
  10
  11 #include "dib3000mc.h"
  12 #include "dib7000m.h"
  13 #include "dib7000p.h"
  14 #include "dib8000.h"
  15 #include "dib9000.h"
  16 #include "mt2060.h"
  17 #include "mt2266.h"
  18 #include "tuner-xc2028.h"
  19 #include "xc5000.h"
  20 #include "xc4000.h"
  21 #include "s5h1411.h"
  22 #include "dib0070.h"
  23 #include "dib0090.h"
  24 #include "lgdt3305.h"
  25 #include "mxl5007t.h"
  26 #include "mn88472.h"
  27 #include "tda18250.h"
  28
  29
  30 static int force_lna_activation;
  31 module_param(force_lna_activation, int, 0644);
  32 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), if applicable for the device (default: 0=automatic/off).");
  33
  34 struct dib0700_adapter_state {
  35         int (*set_param_save) (struct dvb_frontend *);
  36         const struct firmware *frontend_firmware;
  37         struct dib7000p_ops dib7000p_ops;
  38         struct dib8000_ops dib8000_ops;
  39 };
  40
  41 /* Hauppauge Nova-T 500 (aka Bristol)
  42  *  has a LNA on GPIO0 which is enabled by setting 1 */
  43 static struct mt2060_config bristol_mt2060_config[2] = {
  44         {
  45                 .i2c_address = 0x60,
  46                 .clock_out   = 3,
  47         }, {
  48                 .i2c_address = 0x61,
  49         }
  50 };
  51
  52
  53 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  54         .band_caps = BAND_VHF | BAND_UHF,
  55         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  56
  57         .agc1_max = 42598,
  58         .agc1_min = 17694,
  59         .agc2_max = 45875,
  60         .agc2_min = 0,
  61
  62         .agc1_pt1 = 0,
  63         .agc1_pt2 = 59,
  64
  65         .agc1_slope1 = 0,
  66         .agc1_slope2 = 69,
  67
  68         .agc2_pt1 = 0,
  69         .agc2_pt2 = 59,
  70
  71         .agc2_slope1 = 111,
  72         .agc2_slope2 = 28,
  73 };
  74
  75 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  76         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  77                 .max_time     = 0x196,
  78                 .ln_adc_level = 0x1cc7,
  79                 .output_mpeg2_in_188_bytes = 1,
  80         },
  81         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  82                 .max_time     = 0x196,
  83                 .ln_adc_level = 0x1cc7,
  84                 .output_mpeg2_in_188_bytes = 1,
  85         }
  86 };
  87
  88 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  89 {
  90         struct dib0700_state *st = adap->dev->priv;
  91         if (adap->id == 0) {
  92                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  93                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  94                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  95                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  96
  97                 if (force_lna_activation)
  98                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  99                 else
 100                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
 101
 102                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
 103                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
 104                         return -ENODEV;
 105                 }
 106         }
 107         st->mt2060_if1[adap->id] = 1220;
 108         return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 109                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 110 }
 111
 112 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 113 {
 114         struct i2c_msg msg[2] = {
 115                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 116                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 117         };
 118         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 119         return 0;
 120 }
 121
 122 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 123 {
 124         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 125         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
 126         s8 a;
 127         int if1=1220;
 128         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 129                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 130                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 131         }
 132         return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
 133                           &bristol_mt2060_config[adap->id], if1) == NULL ?
 134                           -ENODEV : 0;
 135 }
 136
 137 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 138
 139 /* MT226x */
 140 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 141         {
 142                 BAND_UHF,
 143
 144                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
 145                 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 146                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 147             | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 148
 149                 1130,
 150                 21,
 151
 152                 0,
 153                 118,
 154
 155                 0,
 156                 3530,
 157                 1,
 158                 0,
 159
 160                 65535,
 161                 33770,
 162                 65535,
 163                 23592,
 164
 165                 0,
 166                 62,
 167                 255,
 168                 64,
 169                 64,
 170                 132,
 171                 192,
 172                 80,
 173                 80,
 174
 175                 17,
 176                 27,
 177                 23,
 178                 51,
 179
 180                 1,
 181         }, {
 182                 BAND_VHF | BAND_LBAND,
 183
 184                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
 185                 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 186                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 187             | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 188
 189                 2372,
 190                 21,
 191
 192                 0,
 193                 118,
 194
 195                 0,
 196                 3530,
 197                 1,
 198                 0,
 199
 200                 65535,
 201                 0,
 202                 65535,
 203                 23592,
 204
 205                 0,
 206                 128,
 207                 128,
 208                 128,
 209                 0,
 210                 128,
 211                 253,
 212                 81,
 213                 0,
 214
 215                 17,
 216                 27,
 217                 23,
 218                 51,
 219
 220                 1,
 221         }
 222 };
 223
 224 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 225         .internal = 60000,
 226         .sampling = 30000,
 227         .pll_prediv = 1,
 228         .pll_ratio = 8,
 229         .pll_range = 3,
 230         .pll_reset = 1,
 231         .pll_bypass = 0,
 232         .enable_refdiv = 0,
 233         .bypclk_div = 0,
 234         .IO_CLK_en_core = 1,
 235         .ADClkSrc = 1,
 236         .modulo = 2,
 237         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 238         .ifreq = 0,
 239         .timf = 20452225,
 240 };
 241
 242 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 243         {       .output_mpeg2_in_188_bytes = 1,
 244                 .hostbus_diversity = 1,
 245                 .tuner_is_baseband = 1,
 246
 247                 .agc_config_count = 2,
 248                 .agc = stk7700d_7000p_mt2266_agc_config,
 249                 .bw  = &stk7700d_mt2266_pll_config,
 250
 251                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 252                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 253                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 254         },
 255         {       .output_mpeg2_in_188_bytes = 1,
 256                 .hostbus_diversity = 1,
 257                 .tuner_is_baseband = 1,
 258
 259                 .agc_config_count = 2,
 260                 .agc = stk7700d_7000p_mt2266_agc_config,
 261                 .bw  = &stk7700d_mt2266_pll_config,
 262
 263                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 264                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 265                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 266         }
 267 };
 268
 269 static struct mt2266_config stk7700d_mt2266_config[2] = {
 270         {       .i2c_address = 0x60
 271         },
 272         {       .i2c_address = 0x60
 273         }
 274 };
 275
 276 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 277 {
 278         struct dib0700_adapter_state *state = adap->priv;
 279
 280         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 281                 return -ENODEV;
 282
 283         if (adap->id == 0) {
 284                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 285                 msleep(10);
 286                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 287                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 288                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 289                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 290                 msleep(10);
 291                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 292                 msleep(10);
 293                 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 294                                              stk7700d_dib7000p_mt2266_config)
 295                     != 0) {
 296                         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
 297                         dvb_detach(state->dib7000p_ops.set_wbd_ref);
 298                         return -ENODEV;
 299                 }
 300         }
 301
 302         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
 303                            0x80 + (adap->id << 1),
 304                            &stk7700d_dib7000p_mt2266_config[adap->id]);
 305
 306         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 307 }
 308
 309 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 310 {
 311         struct dib0700_adapter_state *state = adap->priv;
 312
 313         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 314                 return -ENODEV;
 315
 316         if (adap->id == 0) {
 317                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 318                 msleep(10);
 319                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 320                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 321                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 322                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 323                 msleep(10);
 324                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 325                 msleep(10);
 326                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 327                 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 328                                              stk7700d_dib7000p_mt2266_config)
 329                     != 0) {
 330                         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
 331                         dvb_detach(state->dib7000p_ops.set_wbd_ref);
 332                         return -ENODEV;
 333                 }
 334         }
 335
 336         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
 337                            0x80 + (adap->id << 1),
 338                            &stk7700d_dib7000p_mt2266_config[adap->id]);
 339
 340         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 341 }
 342
 343 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 344 {
 345         struct i2c_adapter *tun_i2c;
 346         struct dib0700_adapter_state *state = adap->priv;
 347
 348         tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 349                                             DIBX000_I2C_INTERFACE_TUNER, 1);
 350         return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
 351                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 352 }
 353
 354 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 355 static struct dibx000_agc_config xc3028_agc_config = {
 356         .band_caps = BAND_VHF | BAND_UHF,
 357         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 358          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 359          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 360         .setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 361         .inv_gain = 712,
 362         .time_stabiliz = 21,
 363         .alpha_level = 0,
 364         .thlock = 118,
 365         .wbd_inv = 0,
 366         .wbd_ref = 2867,
 367         .wbd_sel = 0,
 368         .wbd_alpha = 2,
 369         .agc1_max = 0,
 370         .agc1_min = 0,
 371         .agc2_max = 39718,
 372         .agc2_min = 9930,
 373         .agc1_pt1 = 0,
 374         .agc1_pt2 = 0,
 375         .agc1_pt3 = 0,
 376         .agc1_slope1 = 0,
 377         .agc1_slope2 = 0,
 378         .agc2_pt1 = 0,
 379         .agc2_pt2 = 128,
 380         .agc2_slope1 = 29,
 381         .agc2_slope2 = 29,
 382         .alpha_mant = 17,
 383         .alpha_exp = 27,
 384         .beta_mant = 23,
 385         .beta_exp = 51,
 386         .perform_agc_softsplit = 1,
 387 };
 388
 389 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 390 static struct dibx000_bandwidth_config xc3028_bw_config = {
 391         .internal = 60000,
 392         .sampling = 30000,
 393         .pll_prediv = 1,
 394         .pll_ratio = 8,
 395         .pll_range = 3,
 396         .pll_reset = 1,
 397         .pll_bypass = 0,
 398         .enable_refdiv = 0,
 399         .bypclk_div = 0,
 400         .IO_CLK_en_core = 1,
 401         .ADClkSrc = 1,
 402         .modulo = 0,
 403         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 404         .ifreq = (1 << 25) | 5816102,  /* ifreq = 5.200000 MHz */
 405         .timf = 20452225,
 406         .xtal_hz = 30000000,
 407 };
 408
 409 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 410         .output_mpeg2_in_188_bytes = 1,
 411         .tuner_is_baseband = 1,
 412
 413         .agc_config_count = 1,
 414         .agc = &xc3028_agc_config,
 415         .bw  = &xc3028_bw_config,
 416
 417         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 418         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 419         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 420 };
 421
 422 static int stk7700ph_xc3028_callback(void *ptr, int component,
 423                                      int command, int arg)
 424 {
 425         struct dvb_usb_adapter *adap = ptr;
 426         struct dib0700_adapter_state *state = adap->priv;
 427
 428         switch (command) {
 429         case XC2028_TUNER_RESET:
 430                 /* Send the tuner in then out of reset */
 431                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
 432                 msleep(10);
 433                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 434                 break;
 435         case XC2028_RESET_CLK:
 436         case XC2028_I2C_FLUSH:
 437                 break;
 438         default:
 439                 err("%s: unknown command %d, arg %d\n", __func__,
 440                         command, arg);
 441                 return -EINVAL;
 442         }
 443         return 0;
 444 }
 445
 446 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
 447         .fname = "/*(DEBLOBBED)*/",
 448         .max_len = 64,
 449         .demod = XC3028_FE_DIBCOM52,
 450 };
 451
 452 static struct xc2028_config stk7700ph_xc3028_config = {
 453         .i2c_addr = 0x61,
 454         .ctrl = &stk7700ph_xc3028_ctrl,
 455 };
 456
 457 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 458 {
 459         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 460         struct dib0700_adapter_state *state = adap->priv;
 461
 462         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 463                 return -ENODEV;
 464
 465         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 466             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
 467                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 468         else
 469                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 470         msleep(20);
 471         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 472         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 473         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 474         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 475         msleep(10);
 476         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 477         msleep(20);
 478         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 479         msleep(10);
 480
 481         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 482                                      &stk7700ph_dib7700_xc3028_config) != 0) {
 483                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
 484                     __func__);
 485                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
 486                 return -ENODEV;
 487         }
 488
 489         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
 490                 &stk7700ph_dib7700_xc3028_config);
 491
 492         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 493 }
 494
 495 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 496 {
 497         struct i2c_adapter *tun_i2c;
 498         struct dib0700_adapter_state *state = adap->priv;
 499
 500         tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 501                 DIBX000_I2C_INTERFACE_TUNER, 1);
 502
 503         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
 504
 505         /* FIXME: generalize & move to common area */
 506         adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
 507
 508         return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
 509                 == NULL ? -ENODEV : 0;
 510 }
 511
 512 #define DEFAULT_RC_INTERVAL 50
 513
 514 /*
 515  * This function is used only when firmware is < 1.20 version. Newer
 516  * firmwares use bulk mode, with functions implemented at dib0700_core,
 517  * at dib0700_rc_urb_completion()
 518  */
 519 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 520 {
 521         enum rc_proto protocol;
 522         u32 scancode;
 523         u8 toggle;
 524         int i;
 525         struct dib0700_state *st = d->priv;
 526
 527         if (st->fw_version >= 0x10200) {
 528                 /* For 1.20 firmware , We need to keep the RC polling
 529                    callback so we can reuse the input device setup in
 530                    dvb-usb-remote.c.  However, the actual work is being done
 531                    in the bulk URB completion handler. */
 532                 return 0;
 533         }
 534
 535         st->buf[0] = REQUEST_POLL_RC;
 536         st->buf[1] = 0;
 537
 538         i = dib0700_ctrl_rd(d, st->buf, 2, st->buf, 4);
 539         if (i <= 0) {
 540                 err("RC Query Failed");
 541                 return -EIO;
 542         }
 543
 544         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 545         if (st->buf[0] == 0 && st->buf[1] == 0
 546             && st->buf[2] == 0 && st->buf[3] == 0)
 547                 return 0;
 548
 549         /* info("%d: %2X %2X %2X %2X",dvb_usb_dib0700_ir_proto,(int)st->buf[3 - 2],(int)st->buf[3 - 3],(int)st->buf[3 - 1],(int)st->buf[3]);  */
 550
 551         dib0700_rc_setup(d, NULL); /* reset ir sensor data to prevent false events */
 552
 553         switch (d->props.rc.core.protocol) {
 554         case RC_PROTO_BIT_NEC:
 555                 /* NEC protocol sends repeat code as 0 0 0 FF */
 556                 if ((st->buf[3 - 2] == 0x00) && (st->buf[3 - 3] == 0x00) &&
 557                     (st->buf[3] == 0xff)) {
 558                         rc_repeat(d->rc_dev);
 559                         return 0;
 560                 }
 561
 562                 protocol = RC_PROTO_NEC;
 563                 scancode = RC_SCANCODE_NEC(st->buf[3 - 2], st->buf[3 - 3]);
 564                 toggle = 0;
 565                 break;
 566
 567         default:
 568                 /* RC-5 protocol changes toggle bit on new keypress */
 569                 protocol = RC_PROTO_RC5;
 570                 scancode = RC_SCANCODE_RC5(st->buf[3 - 2], st->buf[3 - 3]);
 571                 toggle = st->buf[3 - 1];
 572                 break;
 573         }
 574
 575         rc_keydown(d->rc_dev, protocol, scancode, toggle);
 576         return 0;
 577 }
 578
 579 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 580 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 581         BAND_UHF | BAND_VHF,
 582
 583         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 584          * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 585         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 586         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 587
 588         712,
 589         41,
 590
 591         0,
 592         118,
 593
 594         0,
 595         4095,
 596         0,
 597         0,
 598
 599         42598,
 600         17694,
 601         45875,
 602         2621,
 603         0,
 604         76,
 605         139,
 606         52,
 607         59,
 608         107,
 609         172,
 610         57,
 611         70,
 612
 613         21,
 614         25,
 615         28,
 616         48,
 617
 618         1,
 619         {  0,
 620            107,
 621            51800,
 622            24700
 623         },
 624 };
 625
 626 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 627         .band_caps = BAND_UHF | BAND_VHF,
 628         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 629          * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 630         .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 631         .inv_gain = 712,
 632         .time_stabiliz = 41,
 633         .alpha_level = 0,
 634         .thlock = 118,
 635         .wbd_inv = 0,
 636         .wbd_ref = 4095,
 637         .wbd_sel = 0,
 638         .wbd_alpha = 0,
 639         .agc1_max = 42598,
 640         .agc1_min = 16384,
 641         .agc2_max = 42598,
 642         .agc2_min = 0,
 643         .agc1_pt1 = 0,
 644         .agc1_pt2 = 137,
 645         .agc1_pt3 = 255,
 646         .agc1_slope1 = 0,
 647         .agc1_slope2 = 255,
 648         .agc2_pt1 = 0,
 649         .agc2_pt2 = 0,
 650         .agc2_slope1 = 0,
 651         .agc2_slope2 = 41,
 652         .alpha_mant = 15,
 653         .alpha_exp = 25,
 654         .beta_mant = 28,
 655         .beta_exp = 48,
 656         .perform_agc_softsplit = 0,
 657 };
 658
 659 static struct dibx000_bandwidth_config stk7700p_pll_config = {
 660         .internal = 60000,
 661         .sampling = 30000,
 662         .pll_prediv = 1,
 663         .pll_ratio = 8,
 664         .pll_range = 3,
 665         .pll_reset = 1,
 666         .pll_bypass = 0,
 667         .enable_refdiv = 0,
 668         .bypclk_div = 0,
 669         .IO_CLK_en_core = 1,
 670         .ADClkSrc = 1,
 671         .modulo = 0,
 672         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 673         .ifreq = 60258167,
 674         .timf = 20452225,
 675         .xtal_hz = 30000000,
 676 };
 677
 678 static struct dib7000m_config stk7700p_dib7000m_config = {
 679         .dvbt_mode = 1,
 680         .output_mpeg2_in_188_bytes = 1,
 681         .quartz_direct = 1,
 682
 683         .agc_config_count = 1,
 684         .agc = &stk7700p_7000m_mt2060_agc_config,
 685         .bw  = &stk7700p_pll_config,
 686
 687         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 688         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 689         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 690 };
 691
 692 static struct dib7000p_config stk7700p_dib7000p_config = {
 693         .output_mpeg2_in_188_bytes = 1,
 694
 695         .agc_config_count = 1,
 696         .agc = &stk7700p_7000p_mt2060_agc_config,
 697         .bw  = &stk7700p_pll_config,
 698
 699         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 700         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 701         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 702 };
 703
 704 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 705 {
 706         struct dib0700_state *st = adap->dev->priv;
 707         struct dib0700_adapter_state *state = adap->priv;
 708
 709         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 710                 return -ENODEV;
 711
 712         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 713
 714         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 715         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 716
 717         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 718         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 719
 720         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 721         dib0700_ctrl_clock(adap->dev, 72, 1);
 722         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 723
 724         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 725
 726         st->mt2060_if1[0] = 1220;
 727
 728         if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) {
 729                 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 730                 st->is_dib7000pc = 1;
 731         } else {
 732                 memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops));
 733                 adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 734         }
 735
 736         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 737 }
 738
 739 static struct mt2060_config stk7700p_mt2060_config = {
 740         0x60
 741 };
 742
 743 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 744 {
 745         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 746         struct dib0700_state *st = adap->dev->priv;
 747         struct i2c_adapter *tun_i2c;
 748         struct dib0700_adapter_state *state = adap->priv;
 749         s8 a;
 750         int if1=1220;
 751
 752         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 753                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
 754                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
 755         }
 756         if (st->is_dib7000pc)
 757                 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 758         else
 759                 tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 760
 761         return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
 762                 if1) == NULL ? -ENODEV : 0;
 763 }
 764
 765 /* DIB7070 generic */
 766 static struct dibx000_agc_config dib7070_agc_config = {
 767         .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 768         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 769          * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
 770         .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 771         .inv_gain = 600,
 772         .time_stabiliz = 10,
 773         .alpha_level = 0,
 774         .thlock = 118,
 775         .wbd_inv = 0,
 776         .wbd_ref = 3530,
 777         .wbd_sel = 1,
 778         .wbd_alpha = 5,
 779         .agc1_max = 65535,
 780         .agc1_min = 0,
 781         .agc2_max = 65535,
 782         .agc2_min = 0,
 783         .agc1_pt1 = 0,
 784         .agc1_pt2 = 40,
 785         .agc1_pt3 = 183,
 786         .agc1_slope1 = 206,
 787         .agc1_slope2 = 255,
 788         .agc2_pt1 = 72,
 789         .agc2_pt2 = 152,
 790         .agc2_slope1 = 88,
 791         .agc2_slope2 = 90,
 792         .alpha_mant = 17,
 793         .alpha_exp = 27,
 794         .beta_mant = 23,
 795         .beta_exp = 51,
 796         .perform_agc_softsplit = 0,
 797 };
 798
 799 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 800 {
 801         struct dvb_usb_adapter *adap = fe->dvb->priv;
 802         struct dib0700_adapter_state *state = adap->priv;
 803
 804         deb_info("reset: %d", onoff);
 805         return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
 806 }
 807
 808 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 809 {
 810         struct dvb_usb_adapter *adap = fe->dvb->priv;
 811         struct dib0700_adapter_state *state = adap->priv;
 812
 813         deb_info("sleep: %d", onoff);
 814         return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff);
 815 }
 816
 817 static struct dib0070_config dib7070p_dib0070_config[2] = {
 818         {
 819                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 820                 .reset = dib7070_tuner_reset,
 821                 .sleep = dib7070_tuner_sleep,
 822                 .clock_khz = 12000,
 823                 .clock_pad_drive = 4,
 824                 .charge_pump = 2,
 825         }, {
 826                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 827                 .reset = dib7070_tuner_reset,
 828                 .sleep = dib7070_tuner_sleep,
 829                 .clock_khz = 12000,
 830                 .charge_pump = 2,
 831         }
 832 };
 833
 834 static struct dib0070_config dib7770p_dib0070_config = {
 835          .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 836          .reset = dib7070_tuner_reset,
 837          .sleep = dib7070_tuner_sleep,
 838          .clock_khz = 12000,
 839          .clock_pad_drive = 0,
 840          .flip_chip = 1,
 841          .charge_pump = 2,
 842 };
 843
 844 static int dib7070_set_param_override(struct dvb_frontend *fe)
 845 {
 846         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 847         struct dvb_usb_adapter *adap = fe->dvb->priv;
 848         struct dib0700_adapter_state *state = adap->priv;
 849
 850         u16 offset;
 851         u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
 852         switch (band) {
 853                 case BAND_VHF: offset = 950; break;
 854                 case BAND_UHF:
 855                 default: offset = 550; break;
 856         }
 857         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 858         state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 859         return state->set_param_save(fe);
 860 }
 861
 862 static int dib7770_set_param_override(struct dvb_frontend *fe)
 863 {
 864         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 865         struct dvb_usb_adapter *adap = fe->dvb->priv;
 866         struct dib0700_adapter_state *state = adap->priv;
 867
 868         u16 offset;
 869         u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
 870         switch (band) {
 871         case BAND_VHF:
 872                 state->dib7000p_ops.set_gpio(fe, 0, 0, 1);
 873                 offset = 850;
 874                 break;
 875         case BAND_UHF:
 876         default:
 877                 state->dib7000p_ops.set_gpio(fe, 0, 0, 0);
 878                 offset = 250;
 879                 break;
 880         }
 881         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 882         state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 883         return state->set_param_save(fe);
 884 }
 885
 886 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
 887 {
 888         struct dib0700_adapter_state *st = adap->priv;
 889         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 890                          DIBX000_I2C_INTERFACE_TUNER, 1);
 891
 892         if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
 893                        &dib7770p_dib0070_config) == NULL)
 894                 return -ENODEV;
 895
 896         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
 897         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
 898         return 0;
 899 }
 900
 901 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 902 {
 903         struct dib0700_adapter_state *st = adap->priv;
 904         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 905
 906         if (adap->id == 0) {
 907                 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
 908                         return -ENODEV;
 909         } else {
 910                 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
 911                         return -ENODEV;
 912         }
 913
 914         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
 915         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
 916         return 0;
 917 }
 918
 919 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
 920                 u16 pid, int onoff)
 921 {
 922         struct dib0700_adapter_state *state = adapter->priv;
 923         struct dib0700_state *st = adapter->dev->priv;
 924
 925         if (st->is_dib7000pc)
 926                 return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 927         return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 928 }
 929
 930 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 931 {
 932         struct dib0700_state *st = adapter->dev->priv;
 933         struct dib0700_adapter_state *state = adapter->priv;
 934         if (st->is_dib7000pc)
 935                 return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 936         return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 937 }
 938
 939 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
 940 {
 941         struct dib0700_adapter_state *state = adapter->priv;
 942         return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 943 }
 944
 945 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 946 {
 947         struct dib0700_adapter_state *state = adapter->priv;
 948         return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 949 }
 950
 951 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
 952         .internal = 60000,
 953         .sampling = 15000,
 954         .pll_prediv = 1,
 955         .pll_ratio = 20,
 956         .pll_range = 3,
 957         .pll_reset = 1,
 958         .pll_bypass = 0,
 959         .enable_refdiv = 0,
 960         .bypclk_div = 0,
 961         .IO_CLK_en_core = 1,
 962         .ADClkSrc = 1,
 963         .modulo = 2,
 964         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 965         .ifreq = (0 << 25) | 0,
 966         .timf = 20452225,
 967         .xtal_hz = 12000000,
 968 };
 969
 970 static struct dib7000p_config dib7070p_dib7000p_config = {
 971         .output_mpeg2_in_188_bytes = 1,
 972
 973         .agc_config_count = 1,
 974         .agc = &dib7070_agc_config,
 975         .bw  = &dib7070_bw_config_12_mhz,
 976         .tuner_is_baseband = 1,
 977         .spur_protect = 1,
 978
 979         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 980         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 981         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 982
 983         .hostbus_diversity = 1,
 984 };
 985
 986 /* STK7070P */
 987 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 988 {
 989         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 990         struct dib0700_adapter_state *state = adap->priv;
 991
 992         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 993                 return -ENODEV;
 994
 995         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 996             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 997                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 998         else
 999                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1000         msleep(10);
1001         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1002         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1003         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1004         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1005
1006         dib0700_ctrl_clock(adap->dev, 72, 1);
1007
1008         msleep(10);
1009         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1010         msleep(10);
1011         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1012
1013         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1014                                      &dib7070p_dib7000p_config) != 0) {
1015                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
1016                     __func__);
1017                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
1018                 return -ENODEV;
1019         }
1020
1021         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1022                 &dib7070p_dib7000p_config);
1023         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1024 }
1025
1026 /* STK7770P */
1027 static struct dib7000p_config dib7770p_dib7000p_config = {
1028         .output_mpeg2_in_188_bytes = 1,
1029
1030         .agc_config_count = 1,
1031         .agc = &dib7070_agc_config,
1032         .bw  = &dib7070_bw_config_12_mhz,
1033         .tuner_is_baseband = 1,
1034         .spur_protect = 1,
1035
1036         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1037         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1038         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1039
1040         .hostbus_diversity = 1,
1041         .enable_current_mirror = 1,
1042         .disable_sample_and_hold = 0,
1043 };
1044
1045 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
1046 {
1047         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1048         struct dib0700_adapter_state *state = adap->priv;
1049
1050         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1051                 return -ENODEV;
1052
1053         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
1054             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1055                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1056         else
1057                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1058         msleep(10);
1059         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1060         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1061         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1062         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1063
1064         dib0700_ctrl_clock(adap->dev, 72, 1);
1065
1066         msleep(10);
1067         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1068         msleep(10);
1069         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1070
1071         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1072                                      &dib7770p_dib7000p_config) != 0) {
1073                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
1074                     __func__);
1075                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
1076                 return -ENODEV;
1077         }
1078
1079         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1080                 &dib7770p_dib7000p_config);
1081         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1082 }
1083
1084 /* DIB807x generic */
1085 static struct dibx000_agc_config dib807x_agc_config[2] = {
1086         {
1087                 BAND_VHF,
1088                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1089                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1090                  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1091                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1092                  * P_agc_write=0 */
1093                 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1094                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1095                         (0 << 0), /* setup*/
1096
1097                 600, /* inv_gain*/
1098                 10,  /* time_stabiliz*/
1099
1100                 0,  /* alpha_level*/
1101                 118,  /* thlock*/
1102
1103                 0,     /* wbd_inv*/
1104                 3530,  /* wbd_ref*/
1105                 1,     /* wbd_sel*/
1106                 5,     /* wbd_alpha*/
1107
1108                 65535,  /* agc1_max*/
1109                 0,  /* agc1_min*/
1110
1111                 65535,  /* agc2_max*/
1112                 0,      /* agc2_min*/
1113
1114                 0,      /* agc1_pt1*/
1115                 40,     /* agc1_pt2*/
1116                 183,    /* agc1_pt3*/
1117                 206,    /* agc1_slope1*/
1118                 255,    /* agc1_slope2*/
1119                 72,     /* agc2_pt1*/
1120                 152,    /* agc2_pt2*/
1121                 88,     /* agc2_slope1*/
1122                 90,     /* agc2_slope2*/
1123
1124                 17,  /* alpha_mant*/
1125                 27,  /* alpha_exp*/
1126                 23,  /* beta_mant*/
1127                 51,  /* beta_exp*/
1128
1129                 0,  /* perform_agc_softsplit*/
1130         }, {
1131                 BAND_UHF,
1132                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1133                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1134                  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1135                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1136                  * P_agc_write=0 */
1137                 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1138                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1139                         (0 << 0), /* setup */
1140
1141                 600, /* inv_gain*/
1142                 10,  /* time_stabiliz*/
1143
1144                 0,  /* alpha_level*/
1145                 118,  /* thlock*/
1146
1147                 0,     /* wbd_inv*/
1148                 3530,  /* wbd_ref*/
1149                 1,     /* wbd_sel*/
1150                 5,     /* wbd_alpha*/
1151
1152                 65535,  /* agc1_max*/
1153                 0,  /* agc1_min*/
1154
1155                 65535,  /* agc2_max*/
1156                 0,      /* agc2_min*/
1157
1158                 0,      /* agc1_pt1*/
1159                 40,     /* agc1_pt2*/
1160                 183,    /* agc1_pt3*/
1161                 206,    /* agc1_slope1*/
1162                 255,    /* agc1_slope2*/
1163                 72,     /* agc2_pt1*/
1164                 152,    /* agc2_pt2*/
1165                 88,     /* agc2_slope1*/
1166                 90,     /* agc2_slope2*/
1167
1168                 17,  /* alpha_mant*/
1169                 27,  /* alpha_exp*/
1170                 23,  /* beta_mant*/
1171                 51,  /* beta_exp*/
1172
1173                 0,  /* perform_agc_softsplit*/
1174         }
1175 };
1176
1177 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1178         .internal = 60000,
1179         .sampling = 15000,
1180         .pll_prediv = 1,
1181         .pll_ratio = 20,
1182         .pll_range = 3,
1183         .pll_reset = 1,
1184         .pll_bypass = 0,
1185         .enable_refdiv = 0,
1186         .bypclk_div = 0,
1187         .IO_CLK_en_core = 1,
1188         .ADClkSrc = 1,
1189         .modulo = 2,
1190         .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0),  /* sad_cfg: refsel, sel, freq_15k*/
1191         .ifreq = (0 << 25) | 0,                         /* ifreq = 0.000000 MHz*/
1192         .timf = 18179755,
1193         .xtal_hz = 12000000,
1194 };
1195
1196 static struct dib8000_config dib807x_dib8000_config[2] = {
1197         {
1198                 .output_mpeg2_in_188_bytes = 1,
1199
1200                 .agc_config_count = 2,
1201                 .agc = dib807x_agc_config,
1202                 .pll = &dib807x_bw_config_12_mhz,
1203                 .tuner_is_baseband = 1,
1204
1205                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1206                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1207                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1208
1209                 .hostbus_diversity = 1,
1210                 .div_cfg = 1,
1211                 .agc_control = &dib0070_ctrl_agc_filter,
1212                 .output_mode = OUTMODE_MPEG2_FIFO,
1213                 .drives = 0x2d98,
1214         }, {
1215                 .output_mpeg2_in_188_bytes = 1,
1216
1217                 .agc_config_count = 2,
1218                 .agc = dib807x_agc_config,
1219                 .pll = &dib807x_bw_config_12_mhz,
1220                 .tuner_is_baseband = 1,
1221
1222                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1223                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1224                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1225
1226                 .hostbus_diversity = 1,
1227                 .agc_control = &dib0070_ctrl_agc_filter,
1228                 .output_mode = OUTMODE_MPEG2_FIFO,
1229                 .drives = 0x2d98,
1230         }
1231 };
1232
1233 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1234 {
1235         struct dvb_usb_adapter *adap = fe->dvb->priv;
1236         struct dib0700_adapter_state *state = adap->priv;
1237
1238         return state->dib8000_ops.set_gpio(fe, 5, 0, !onoff);
1239 }
1240
1241 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1242 {
1243         struct dvb_usb_adapter *adap = fe->dvb->priv;
1244         struct dib0700_adapter_state *state = adap->priv;
1245
1246         return state->dib8000_ops.set_gpio(fe, 0, 0, onoff);
1247 }
1248
1249 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1250     { 240,      7},
1251     { 0xffff,   6},
1252 };
1253
1254 static struct dib0070_config dib807x_dib0070_config[2] = {
1255         {
1256                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1257                 .reset = dib80xx_tuner_reset,
1258                 .sleep = dib80xx_tuner_sleep,
1259                 .clock_khz = 12000,
1260                 .clock_pad_drive = 4,
1261                 .vga_filter = 1,
1262                 .force_crystal_mode = 1,
1263                 .enable_third_order_filter = 1,
1264                 .charge_pump = 0,
1265                 .wbd_gain = dib8070_wbd_gain_cfg,
1266                 .osc_buffer_state = 0,
1267                 .freq_offset_khz_uhf = -100,
1268                 .freq_offset_khz_vhf = -100,
1269         }, {
1270                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1271                 .reset = dib80xx_tuner_reset,
1272                 .sleep = dib80xx_tuner_sleep,
1273                 .clock_khz = 12000,
1274                 .clock_pad_drive = 2,
1275                 .vga_filter = 1,
1276                 .force_crystal_mode = 1,
1277                 .enable_third_order_filter = 1,
1278                 .charge_pump = 0,
1279                 .wbd_gain = dib8070_wbd_gain_cfg,
1280                 .osc_buffer_state = 0,
1281                 .freq_offset_khz_uhf = -25,
1282                 .freq_offset_khz_vhf = -25,
1283         }
1284 };
1285
1286 static int dib807x_set_param_override(struct dvb_frontend *fe)
1287 {
1288         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1289         struct dvb_usb_adapter *adap = fe->dvb->priv;
1290         struct dib0700_adapter_state *state = adap->priv;
1291
1292         u16 offset = dib0070_wbd_offset(fe);
1293         u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1294         switch (band) {
1295         case BAND_VHF:
1296                 offset += 750;
1297                 break;
1298         case BAND_UHF:  /* fall-thru wanted */
1299         default:
1300                 offset += 250; break;
1301         }
1302         deb_info("WBD for DiB8000: %d\n", offset);
1303         state->dib8000_ops.set_wbd_ref(fe, offset);
1304
1305         return state->set_param_save(fe);
1306 }
1307
1308 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1309 {
1310         struct dib0700_adapter_state *st = adap->priv;
1311         struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe,
1312                         DIBX000_I2C_INTERFACE_TUNER, 1);
1313
1314         if (adap->id == 0) {
1315                 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1316                                 &dib807x_dib0070_config[0]) == NULL)
1317                         return -ENODEV;
1318         } else {
1319                 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1320                                 &dib807x_dib0070_config[1]) == NULL)
1321                         return -ENODEV;
1322         }
1323
1324         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1325         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1326         return 0;
1327 }
1328
1329 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1330         u16 pid, int onoff)
1331 {
1332         struct dib0700_adapter_state *state = adapter->priv;
1333
1334         return state->dib8000_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1335 }
1336
1337 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1338                 int onoff)
1339 {
1340         struct dib0700_adapter_state *state = adapter->priv;
1341
1342         return state->dib8000_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1343 }
1344
1345 /* STK807x */
1346 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1347 {
1348         struct dib0700_adapter_state *state = adap->priv;
1349
1350         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1351                 return -ENODEV;
1352
1353         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1354         msleep(10);
1355         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1356         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1357         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1358
1359         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1360
1361         dib0700_ctrl_clock(adap->dev, 72, 1);
1362
1363         msleep(10);
1364         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1365         msleep(10);
1366         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1367
1368         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1369                                 0x80, 0);
1370
1371         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
1372                               &dib807x_dib8000_config[0]);
1373
1374         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1375 }
1376
1377 /* STK807xPVR */
1378 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1379 {
1380         struct dib0700_adapter_state *state = adap->priv;
1381
1382         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1383                 return -ENODEV;
1384
1385         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1386         msleep(30);
1387         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1388         msleep(500);
1389         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1390         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1391         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1392
1393         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1394
1395         dib0700_ctrl_clock(adap->dev, 72, 1);
1396
1397         msleep(10);
1398         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1399         msleep(10);
1400         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1401
1402         /* initialize IC 0 */
1403         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
1404
1405         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
1406                               &dib807x_dib8000_config[0]);
1407
1408         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1409 }
1410
1411 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1412 {
1413         struct dib0700_adapter_state *state = adap->priv;
1414
1415         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1416                 return -ENODEV;
1417
1418         /* initialize IC 1 */
1419         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
1420
1421         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82,
1422                               &dib807x_dib8000_config[1]);
1423
1424         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1425 }
1426
1427 /* STK8096GP */
1428 static struct dibx000_agc_config dib8090_agc_config[2] = {
1429         {
1430         .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1431         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1432          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1433          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1434         .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1435         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1436
1437         .inv_gain = 787,
1438         .time_stabiliz = 10,
1439
1440         .alpha_level = 0,
1441         .thlock = 118,
1442
1443         .wbd_inv = 0,
1444         .wbd_ref = 3530,
1445         .wbd_sel = 1,
1446         .wbd_alpha = 5,
1447
1448         .agc1_max = 65535,
1449         .agc1_min = 0,
1450
1451         .agc2_max = 65535,
1452         .agc2_min = 0,
1453
1454         .agc1_pt1 = 0,
1455         .agc1_pt2 = 32,
1456         .agc1_pt3 = 114,
1457         .agc1_slope1 = 143,
1458         .agc1_slope2 = 144,
1459         .agc2_pt1 = 114,
1460         .agc2_pt2 = 227,
1461         .agc2_slope1 = 116,
1462         .agc2_slope2 = 117,
1463
1464         .alpha_mant = 28,
1465         .alpha_exp = 26,
1466         .beta_mant = 31,
1467         .beta_exp = 51,
1468
1469         .perform_agc_softsplit = 0,
1470         },
1471         {
1472         .band_caps = BAND_CBAND,
1473         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1474          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1475          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1476         .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1477         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1478
1479         .inv_gain = 787,
1480         .time_stabiliz = 10,
1481
1482         .alpha_level = 0,
1483         .thlock = 118,
1484
1485         .wbd_inv = 0,
1486         .wbd_ref = 3530,
1487         .wbd_sel = 1,
1488         .wbd_alpha = 5,
1489
1490         .agc1_max = 0,
1491         .agc1_min = 0,
1492
1493         .agc2_max = 65535,
1494         .agc2_min = 0,
1495
1496         .agc1_pt1 = 0,
1497         .agc1_pt2 = 32,
1498         .agc1_pt3 = 114,
1499         .agc1_slope1 = 143,
1500         .agc1_slope2 = 144,
1501         .agc2_pt1 = 114,
1502         .agc2_pt2 = 227,
1503         .agc2_slope1 = 116,
1504         .agc2_slope2 = 117,
1505
1506         .alpha_mant = 28,
1507         .alpha_exp = 26,
1508         .beta_mant = 31,
1509         .beta_exp = 51,
1510
1511         .perform_agc_softsplit = 0,
1512         }
1513 };
1514
1515 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1516         .internal = 54000,
1517         .sampling = 13500,
1518
1519         .pll_prediv = 1,
1520         .pll_ratio = 18,
1521         .pll_range = 3,
1522         .pll_reset = 1,
1523         .pll_bypass = 0,
1524
1525         .enable_refdiv = 0,
1526         .bypclk_div = 0,
1527         .IO_CLK_en_core = 1,
1528         .ADClkSrc = 1,
1529         .modulo = 2,
1530
1531         .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0),
1532
1533         .ifreq = (0 << 25) | 0,
1534         .timf = 20199727,
1535
1536         .xtal_hz = 12000000,
1537 };
1538
1539 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1540 {
1541         struct dvb_usb_adapter *adap = fe->dvb->priv;
1542         struct dib0700_adapter_state *state = adap->priv;
1543
1544         return state->dib8000_ops.get_adc_power(fe, 1);
1545 }
1546
1547 static void dib8090_agc_control(struct dvb_frontend *fe, u8 restart)
1548 {
1549         deb_info("AGC control callback: %i\n", restart);
1550         dib0090_dcc_freq(fe, restart);
1551
1552         if (restart == 0) /* before AGC startup */
1553                 dib0090_set_dc_servo(fe, 1);
1554 }
1555
1556 static struct dib8000_config dib809x_dib8000_config[2] = {
1557         {
1558         .output_mpeg2_in_188_bytes = 1,
1559
1560         .agc_config_count = 2,
1561         .agc = dib8090_agc_config,
1562         .agc_control = dib8090_agc_control,
1563         .pll = &dib8090_pll_config_12mhz,
1564         .tuner_is_baseband = 1,
1565
1566         .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1567         .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1568         .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1569
1570         .hostbus_diversity = 1,
1571         .div_cfg = 0x31,
1572         .output_mode = OUTMODE_MPEG2_FIFO,
1573         .drives = 0x2d98,
1574         .diversity_delay = 48,
1575         .refclksel = 3,
1576         }, {
1577         .output_mpeg2_in_188_bytes = 1,
1578
1579         .agc_config_count = 2,
1580         .agc = dib8090_agc_config,
1581         .agc_control = dib8090_agc_control,
1582         .pll = &dib8090_pll_config_12mhz,
1583         .tuner_is_baseband = 1,
1584
1585         .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1586         .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1587         .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1588
1589         .hostbus_diversity = 1,
1590         .div_cfg = 0x31,
1591         .output_mode = OUTMODE_DIVERSITY,
1592         .drives = 0x2d08,
1593         .diversity_delay = 1,
1594         .refclksel = 3,
1595         }
1596 };
1597
1598 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1599         /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1600         { 120,     0, 500,  0,   500, 4 }, /* CBAND */
1601         { 170,     0, 450,  0,   450, 4 }, /* CBAND */
1602         { 380,    48, 373, 28,   259, 6 }, /* VHF */
1603         { 860,    34, 700, 36,   616, 6 }, /* high UHF */
1604         { 0xFFFF, 34, 700, 36,   616, 6 }, /* default */
1605 };
1606
1607 static struct dib0090_config dib809x_dib0090_config = {
1608         .io.pll_bypass = 1,
1609         .io.pll_range = 1,
1610         .io.pll_prediv = 1,
1611         .io.pll_loopdiv = 20,
1612         .io.adc_clock_ratio = 8,
1613         .io.pll_int_loop_filt = 0,
1614         .io.clock_khz = 12000,
1615         .reset = dib80xx_tuner_reset,
1616         .sleep = dib80xx_tuner_sleep,
1617         .clkouttobamse = 1,
1618         .analog_output = 1,
1619         .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1620         .use_pwm_agc = 1,
1621         .clkoutdrive = 1,
1622         .get_adc_power = dib8090_get_adc_power,
1623         .freq_offset_khz_uhf = -63,
1624         .freq_offset_khz_vhf = -143,
1625         .wbd = dib8090_wbd_table,
1626         .fref_clock_ratio = 6,
1627 };
1628
1629 static u8 dib8090_compute_pll_parameters(struct dvb_frontend *fe)
1630 {
1631         u8 optimal_pll_ratio = 20;
1632         u32 freq_adc, ratio, rest, max = 0;
1633         u8 pll_ratio;
1634
1635         for (pll_ratio = 17; pll_ratio <= 20; pll_ratio++) {
1636                 freq_adc = 12 * pll_ratio * (1 << 8) / 16;
1637                 ratio = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) / freq_adc;
1638                 rest = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) - ratio * freq_adc;
1639
1640                 if (rest > freq_adc / 2)
1641                         rest = freq_adc - rest;
1642                 deb_info("PLL ratio=%i rest=%i\n", pll_ratio, rest);
1643                 if ((rest > max) && (rest > 717)) {
1644                         optimal_pll_ratio = pll_ratio;
1645                         max = rest;
1646                 }
1647         }
1648         deb_info("optimal PLL ratio=%i\n", optimal_pll_ratio);
1649
1650         return optimal_pll_ratio;
1651 }
1652
1653 static int dib8096_set_param_override(struct dvb_frontend *fe)
1654 {
1655         struct dvb_usb_adapter *adap = fe->dvb->priv;
1656         struct dib0700_adapter_state *state = adap->priv;
1657         u8 pll_ratio, band = BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000);
1658         u16 target, ltgain, rf_gain_limit;
1659         u32 timf;
1660         int ret = 0;
1661         enum frontend_tune_state tune_state = CT_SHUTDOWN;
1662
1663         switch (band) {
1664         default:
1665                         deb_info("Warning : Rf frequency  (%iHz) is not in the supported range, using VHF switch ", fe->dtv_property_cache.frequency);
1666                         /* fall through */
1667         case BAND_VHF:
1668                         state->dib8000_ops.set_gpio(fe, 3, 0, 1);
1669                         break;
1670         case BAND_UHF:
1671                         state->dib8000_ops.set_gpio(fe, 3, 0, 0);
1672                         break;
1673         }
1674
1675         ret = state->set_param_save(fe);
1676         if (ret < 0)
1677                 return ret;
1678
1679         if (fe->dtv_property_cache.bandwidth_hz != 6000000) {
1680                 deb_info("only 6MHz bandwidth is supported\n");
1681                 return -EINVAL;
1682         }
1683
1684         /* Update PLL if needed ratio */
1685         state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1686
1687         /* Get optimize PLL ratio to remove spurious */
1688         pll_ratio = dib8090_compute_pll_parameters(fe);
1689         if (pll_ratio == 17)
1690                 timf = 21387946;
1691         else if (pll_ratio == 18)
1692                 timf = 20199727;
1693         else if (pll_ratio == 19)
1694                 timf = 19136583;
1695         else
1696                 timf = 18179756;
1697
1698         /* Update ratio */
1699         state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
1700
1701         state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, timf);
1702
1703         if (band != BAND_CBAND) {
1704                 /* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */
1705                 target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2;
1706                 state->dib8000_ops.set_wbd_ref(fe, target);
1707         }
1708
1709         if (band == BAND_CBAND) {
1710                 deb_info("tuning in CBAND - soft-AGC startup\n");
1711                 dib0090_set_tune_state(fe, CT_AGC_START);
1712
1713                 do {
1714                         ret = dib0090_gain_control(fe);
1715                         msleep(ret);
1716                         tune_state = dib0090_get_tune_state(fe);
1717                         if (tune_state == CT_AGC_STEP_0)
1718                                 state->dib8000_ops.set_gpio(fe, 6, 0, 1);
1719                         else if (tune_state == CT_AGC_STEP_1) {
1720                                 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1721                                 if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */
1722                                         state->dib8000_ops.set_gpio(fe, 6, 0, 0);
1723                         }
1724                 } while (tune_state < CT_AGC_STOP);
1725
1726                 deb_info("switching to PWM AGC\n");
1727                 dib0090_pwm_gain_reset(fe);
1728                 state->dib8000_ops.pwm_agc_reset(fe);
1729                 state->dib8000_ops.set_tune_state(fe, CT_DEMOD_START);
1730         } else {
1731                 /* for everything else than CBAND we are using standard AGC */
1732                 deb_info("not tuning in CBAND - standard AGC startup\n");
1733                 dib0090_pwm_gain_reset(fe);
1734         }
1735
1736         return 0;
1737 }
1738
1739 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1740 {
1741         struct dib0700_adapter_state *st = adap->priv;
1742         struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1743
1744         if (adap->id == 0) {
1745                 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1746                         return -ENODEV;
1747         } else {
1748                 /* FIXME: check if it is fe_adap[1] */
1749                 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1750                         return -ENODEV;
1751         }
1752
1753         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1754         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1755         return 0;
1756 }
1757
1758 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1759 {
1760         struct dib0700_adapter_state *state = adap->priv;
1761
1762         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1763                 return -ENODEV;
1764
1765         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1766         msleep(10);
1767         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1768         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1769         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1770
1771         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1772
1773         dib0700_ctrl_clock(adap->dev, 72, 1);
1774
1775         msleep(10);
1776         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1777         msleep(10);
1778         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1779
1780         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1781
1782         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1783
1784         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1785 }
1786
1787 static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap)
1788 {
1789         struct dib0700_adapter_state *state = adap->priv;
1790
1791         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1792                 return -ENODEV;
1793
1794         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0);
1795
1796         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1797
1798         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1799 }
1800
1801 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1802 {
1803         struct dib0700_adapter_state *st = adap->priv;
1804         struct i2c_adapter *tun_i2c;
1805         struct dvb_frontend *fe_slave  = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
1806
1807         if (fe_slave) {
1808                 tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1809                 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1810                         return -ENODEV;
1811                 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1812                 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1813         }
1814         tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1815         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1816                 return -ENODEV;
1817
1818         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1819         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1820
1821         return 0;
1822 }
1823
1824 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1825 {
1826         struct dvb_frontend *fe_slave;
1827         struct dib0700_adapter_state *state = adap->priv;
1828
1829         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1830                 return -ENODEV;
1831
1832         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1833         msleep(20);
1834         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1835         msleep(1000);
1836         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1837         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1838         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1839
1840         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1841
1842         dib0700_ctrl_clock(adap->dev, 72, 1);
1843
1844         msleep(20);
1845         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1846         msleep(20);
1847         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1848
1849         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1850
1851         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1852         if (adap->fe_adap[0].fe == NULL)
1853                 return -ENODEV;
1854
1855         /* Needed to increment refcount */
1856         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1857                 return -ENODEV;
1858
1859         fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1860         state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1861
1862         return fe_slave == NULL ?  -ENODEV : 0;
1863 }
1864
1865 /* TFE8096P */
1866 static struct dibx000_agc_config dib8096p_agc_config[2] = {
1867         {
1868                 .band_caps              = BAND_UHF,
1869                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1870                    P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1871                    P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1872                    P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1873                    P_agc_write=0 */
1874                 .setup                  = (0 << 15) | (0 << 14) | (5 << 11)
1875                         | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1876                         | (0 << 4) | (5 << 1) | (0 << 0),
1877
1878                 .inv_gain               = 684,
1879                 .time_stabiliz  = 10,
1880
1881                 .alpha_level    = 0,
1882                 .thlock                 = 118,
1883
1884                 .wbd_inv                = 0,
1885                 .wbd_ref                = 1200,
1886                 .wbd_sel                = 3,
1887                 .wbd_alpha              = 5,
1888
1889                 .agc1_max               = 65535,
1890                 .agc1_min               = 0,
1891
1892                 .agc2_max               = 32767,
1893                 .agc2_min               = 0,
1894
1895                 .agc1_pt1               = 0,
1896                 .agc1_pt2               = 0,
1897                 .agc1_pt3               = 105,
1898                 .agc1_slope1    = 0,
1899                 .agc1_slope2    = 156,
1900                 .agc2_pt1               = 105,
1901                 .agc2_pt2               = 255,
1902                 .agc2_slope1    = 54,
1903                 .agc2_slope2    = 0,
1904
1905                 .alpha_mant             = 28,
1906                 .alpha_exp              = 26,
1907                 .beta_mant              = 31,
1908                 .beta_exp               = 51,
1909
1910                 .perform_agc_softsplit = 0,
1911         } , {
1912                 .band_caps              = BAND_FM | BAND_VHF | BAND_CBAND,
1913                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1914                    P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1915                    P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1916                    P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1917                    P_agc_write=0 */
1918                 .setup                  = (0 << 15) | (0 << 14) | (5 << 11)
1919                         | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1920                         | (0 << 4) | (5 << 1) | (0 << 0),
1921
1922                 .inv_gain               = 732,
1923                 .time_stabiliz  = 10,
1924
1925                 .alpha_level    = 0,
1926                 .thlock                 = 118,
1927
1928                 .wbd_inv                = 0,
1929                 .wbd_ref                = 1200,
1930                 .wbd_sel                = 3,
1931                 .wbd_alpha              = 5,
1932
1933                 .agc1_max               = 65535,
1934                 .agc1_min               = 0,
1935
1936                 .agc2_max               = 32767,
1937                 .agc2_min               = 0,
1938
1939                 .agc1_pt1               = 0,
1940                 .agc1_pt2               = 0,
1941                 .agc1_pt3               = 98,
1942                 .agc1_slope1    = 0,
1943                 .agc1_slope2    = 167,
1944                 .agc2_pt1               = 98,
1945                 .agc2_pt2               = 255,
1946                 .agc2_slope1    = 52,
1947                 .agc2_slope2    = 0,
1948
1949                 .alpha_mant             = 28,
1950                 .alpha_exp              = 26,
1951                 .beta_mant              = 31,
1952                 .beta_exp               = 51,
1953
1954                 .perform_agc_softsplit = 0,
1955         }
1956 };
1957
1958 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1959         .internal = 108000,
1960         .sampling = 13500,
1961         .pll_prediv = 1,
1962         .pll_ratio = 9,
1963         .pll_range = 1,
1964         .pll_reset = 0,
1965         .pll_bypass = 0,
1966         .enable_refdiv = 0,
1967         .bypclk_div = 0,
1968         .IO_CLK_en_core = 0,
1969         .ADClkSrc = 0,
1970         .modulo = 2,
1971         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1972         .ifreq = (0 << 25) | 0,
1973         .timf = 20199729,
1974         .xtal_hz = 12000000,
1975 };
1976
1977 static struct dib8000_config tfe8096p_dib8000_config = {
1978         .output_mpeg2_in_188_bytes      = 1,
1979         .hostbus_diversity                      = 1,
1980         .update_lna                                     = NULL,
1981
1982         .agc_config_count                       = 2,
1983         .agc                                            = dib8096p_agc_config,
1984         .pll                                            = &dib8096p_clock_config_12_mhz,
1985
1986         .gpio_dir                                       = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1987         .gpio_val                                       = DIB8000_GPIO_DEFAULT_VALUES,
1988         .gpio_pwm_pos                           = DIB8000_GPIO_DEFAULT_PWM_POS,
1989
1990         .agc_control                            = NULL,
1991         .diversity_delay                        = 48,
1992         .output_mode                            = OUTMODE_MPEG2_FIFO,
1993         .enMpegOutput                           = 1,
1994 };
1995
1996 static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1997         { 380, 81, 850, 64, 540, 4},
1998         { 860, 51, 866, 21, 375, 4},
1999         {1700, 0, 250, 0, 100, 6},
2000         {2600, 0, 250, 0, 100, 6},
2001         { 0xFFFF, 0, 0, 0, 0, 0},
2002 };
2003
2004 static struct dib0090_config tfe8096p_dib0090_config = {
2005         .io.clock_khz                   = 12000,
2006         .io.pll_bypass                  = 0,
2007         .io.pll_range                   = 0,
2008         .io.pll_prediv                  = 3,
2009         .io.pll_loopdiv                 = 6,
2010         .io.adc_clock_ratio             = 0,
2011         .io.pll_int_loop_filt   = 0,
2012
2013         .freq_offset_khz_uhf    = -143,
2014         .freq_offset_khz_vhf    = -143,
2015
2016         .get_adc_power                  = dib8090_get_adc_power,
2017
2018         .clkouttobamse                  = 1,
2019         .analog_output                  = 0,
2020
2021         .wbd_vhf_offset                 = 0,
2022         .wbd_cband_offset               = 0,
2023         .use_pwm_agc                    = 1,
2024         .clkoutdrive                    = 0,
2025
2026         .fref_clock_ratio               = 1,
2027
2028         .ls_cfg_pad_drv                 = 0,
2029         .data_tx_drv                    = 0,
2030         .low_if                                 = NULL,
2031         .in_soc                                 = 1,
2032         .force_cband_input              = 0,
2033 };
2034
2035 struct dibx090p_adc {
2036         u32 freq;                       /* RF freq MHz */
2037         u32 timf;                       /* New Timf */
2038         u32 pll_loopdiv;        /* New prediv */
2039         u32 pll_prediv;         /* New loopdiv */
2040 };
2041
2042 struct dibx090p_best_adc {
2043         u32 timf;
2044         u32 pll_loopdiv;
2045         u32 pll_prediv;
2046 };
2047
2048 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
2049 {
2050         u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2051         u16 xtal = 12000;
2052         u16 fcp_min = 1900;  /* PLL, Minimum Frequency of phase comparator (KHz) */
2053         u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */
2054         u32 fmem_max = 140000; /* 140MHz max SDRAM freq */
2055         u32 fdem_min = 66000;
2056         u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
2057         u32 harmonic_id = 0;
2058
2059         adc->timf = 0;
2060         adc->pll_loopdiv = loopdiv;
2061         adc->pll_prediv = prediv;
2062
2063         deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
2064
2065         /* Find Min and Max prediv */
2066         while ((xtal / max_prediv) >= fcp_min)
2067                 max_prediv++;
2068
2069         max_prediv--;
2070         min_prediv = max_prediv;
2071         while ((xtal / min_prediv) <= fcp_max) {
2072                 min_prediv--;
2073                 if (min_prediv == 1)
2074                         break;
2075         }
2076         deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2077
2078         min_prediv = 1;
2079
2080         for (prediv = min_prediv; prediv < max_prediv; prediv++) {
2081                 fcp = xtal / prediv;
2082                 if (fcp > fcp_min && fcp < fcp_max) {
2083                         for (loopdiv = 1; loopdiv < 64; loopdiv++) {
2084                                 fmem = ((xtal/prediv) * loopdiv);
2085                                 fdem = fmem / 2;
2086                                 fs   = fdem / 4;
2087
2088                                 /* test min/max system restrictions */
2089                                 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
2090                                         spur = 0;
2091                                         /* test fs harmonics positions */
2092                                         for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs));  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
2093                                                 if (((fs * harmonic_id) >= (fe->dtv_property_cache.frequency / 1000 - (fe->dtv_property_cache.bandwidth_hz / 2000))) &&  ((fs * harmonic_id) <= (fe->dtv_property_cache.frequency / 1000 + (fe->dtv_property_cache.bandwidth_hz / 2000)))) {
2094                                                         spur = 1;
2095                                                         break;
2096                                                 }
2097                                         }
2098
2099                                         if (!spur) {
2100                                                 adc->pll_loopdiv = loopdiv;
2101                                                 adc->pll_prediv = prediv;
2102                                                 adc->timf = (4260880253U / fdem) * (1 << 8);
2103                                                 adc->timf += ((4260880253U % fdem) << 8) / fdem;
2104
2105                                                 deb_info("RF %6d; BW %6d; Xtal %6d; Fmem %6d; Fdem %6d; Fs %6d; Prediv %2d; Loopdiv %2d; Timf %8d;", fe->dtv_property_cache.frequency, fe->dtv_property_cache.bandwidth_hz, xtal, fmem, fdem, fs, prediv, loopdiv, adc->timf);
2106                                                 break;
2107                                         }
2108                                 }
2109                         }
2110                 }
2111                 if (!spur)
2112                         break;
2113         }
2114
2115         if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2116                 return -EINVAL;
2117         return 0;
2118 }
2119
2120 static int dib8096p_agc_startup(struct dvb_frontend *fe)
2121 {
2122         struct dvb_usb_adapter *adap = fe->dvb->priv;
2123         struct dib0700_adapter_state *state = adap->priv;
2124         struct dibx000_bandwidth_config pll;
2125         struct dibx090p_best_adc adc;
2126         u16 target;
2127         int ret;
2128
2129         ret = state->set_param_save(fe);
2130         if (ret < 0)
2131                 return ret;
2132         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2133
2134         dib0090_pwm_gain_reset(fe);
2135         /* dib0090_get_wbd_target is returning any possible
2136            temperature compensated wbd-target */
2137         target = (dib0090_get_wbd_target(fe) * 8  + 1) / 2;
2138         state->dib8000_ops.set_wbd_ref(fe, target);
2139
2140         if (dib8096p_get_best_sampling(fe, &adc) == 0) {
2141                 pll.pll_ratio  = adc.pll_loopdiv;
2142                 pll.pll_prediv = adc.pll_prediv;
2143
2144                 dib0700_set_i2c_speed(adap->dev, 200);
2145                 state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
2146                 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2147                 dib0700_set_i2c_speed(adap->dev, 1000);
2148         }
2149         return 0;
2150 }
2151
2152 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2153 {
2154         struct dib0700_state *st = adap->dev->priv;
2155         u32 fw_version;
2156         struct dib0700_adapter_state *state = adap->priv;
2157
2158         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
2159                 return -ENODEV;
2160
2161         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2162         if (fw_version >= 0x10200)
2163                 st->fw_use_new_i2c_api = 1;
2164
2165         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2166         msleep(20);
2167         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2168         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2169         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2170
2171         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2172
2173         dib0700_ctrl_clock(adap->dev, 72, 1);
2174
2175         msleep(20);
2176         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2177         msleep(20);
2178         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2179
2180         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2181
2182         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
2183                                              0x80, &tfe8096p_dib8000_config);
2184
2185         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2186 }
2187
2188 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2189 {
2190         struct dib0700_adapter_state *st = adap->priv;
2191         struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
2192
2193         tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
2194         tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
2195         tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
2196
2197         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2198                                 &tfe8096p_dib0090_config) == NULL)
2199                 return -ENODEV;
2200
2201         st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2202
2203         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2204         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2205         return 0;
2206 }
2207
2208 /* STK9090M */
2209 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2210 {
2211         return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2212 }
2213
2214 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2215 {
2216         return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2217 }
2218
2219 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2220 {
2221         return dib9000_set_gpio(fe, 5, 0, !onoff);
2222 }
2223
2224 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2225 {
2226         return dib9000_set_gpio(fe, 0, 0, onoff);
2227 }
2228
2229 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2230 {
2231         u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2232         u8 rb[2];
2233         struct i2c_msg msg[2] = {
2234                 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2235                 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2236         };
2237         u8 index_data;
2238
2239         dibx000_i2c_set_speed(i2c, 250);
2240
2241         if (i2c_transfer(i2c, msg, 2) != 2)
2242                 return -EIO;
2243
2244         switch (rb[0] << 8 | rb[1]) {
2245         case 0:
2246                         deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2247                         return -EIO;
2248         case 1:
2249                         deb_info("Found DiB0170 rev2");
2250                         break;
2251         case 2:
2252                         deb_info("Found DiB0190 rev2");
2253                         break;
2254         default:
2255                         deb_info("DiB01x0 not found");
2256                         return -EIO;
2257         }
2258
2259         for (index_data = 0; index_data < len; index_data += 2) {
2260                 wb[2] = (data[index_data + 1] >> 8) & 0xff;
2261                 wb[3] = (data[index_data + 1]) & 0xff;
2262
2263                 if (data[index_data] == 0) {
2264                         wb[0] = (data[index_data] >> 8) & 0xff;
2265                         wb[1] = (data[index_data]) & 0xff;
2266                         msg[0].len = 2;
2267                         if (i2c_transfer(i2c, msg, 2) != 2)
2268                                 return -EIO;
2269                         wb[2] |= rb[0];
2270                         wb[3] |= rb[1] & ~(3 << 4);
2271                 }
2272
2273                 wb[0] = (data[index_data] >> 8)&0xff;
2274                 wb[1] = (data[index_data])&0xff;
2275                 msg[0].len = 4;
2276                 if (i2c_transfer(i2c, &msg[0], 1) != 1)
2277                         return -EIO;
2278         }
2279         return 0;
2280 }
2281
2282 static struct dib9000_config stk9090m_config = {
2283         .output_mpeg2_in_188_bytes = 1,
2284         .output_mode = OUTMODE_MPEG2_FIFO,
2285         .vcxo_timer = 279620,
2286         .timing_frequency = 20452225,
2287         .demod_clock_khz = 60000,
2288         .xtal_clock_khz = 30000,
2289         .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2290         .subband = {
2291                 2,
2292                 {
2293                         { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
2294                         { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
2295                         { 0 },
2296                 },
2297         },
2298         .gpio_function = {
2299                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2300                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2301         },
2302 };
2303
2304 static struct dib9000_config nim9090md_config[2] = {
2305         {
2306                 .output_mpeg2_in_188_bytes = 1,
2307                 .output_mode = OUTMODE_MPEG2_FIFO,
2308                 .vcxo_timer = 279620,
2309                 .timing_frequency = 20452225,
2310                 .demod_clock_khz = 60000,
2311                 .xtal_clock_khz = 30000,
2312                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2313         }, {
2314                 .output_mpeg2_in_188_bytes = 1,
2315                 .output_mode = OUTMODE_DIVERSITY,
2316                 .vcxo_timer = 279620,
2317                 .timing_frequency = 20452225,
2318                 .demod_clock_khz = 60000,
2319                 .xtal_clock_khz = 30000,
2320                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2321                 .subband = {
2322                         2,
2323                         {
2324                                 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2325                                 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2326                                 { 0 },
2327                         },
2328                 },
2329                 .gpio_function = {
2330                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2331                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2332                 },
2333         }
2334 };
2335
2336 static struct dib0090_config dib9090_dib0090_config = {
2337         .io.pll_bypass = 0,
2338         .io.pll_range = 1,
2339         .io.pll_prediv = 1,
2340         .io.pll_loopdiv = 8,
2341         .io.adc_clock_ratio = 8,
2342         .io.pll_int_loop_filt = 0,
2343         .io.clock_khz = 30000,
2344         .reset = dib90x0_tuner_reset,
2345         .sleep = dib90x0_tuner_sleep,
2346         .clkouttobamse = 0,
2347         .analog_output = 0,
2348         .use_pwm_agc = 0,
2349         .clkoutdrive = 0,
2350         .freq_offset_khz_uhf = 0,
2351         .freq_offset_khz_vhf = 0,
2352 };
2353
2354 static struct dib0090_config nim9090md_dib0090_config[2] = {
2355         {
2356                 .io.pll_bypass = 0,
2357                 .io.pll_range = 1,
2358                 .io.pll_prediv = 1,
2359                 .io.pll_loopdiv = 8,
2360                 .io.adc_clock_ratio = 8,
2361                 .io.pll_int_loop_filt = 0,
2362                 .io.clock_khz = 30000,
2363                 .reset = dib90x0_tuner_reset,
2364                 .sleep = dib90x0_tuner_sleep,
2365                 .clkouttobamse = 1,
2366                 .analog_output = 0,
2367                 .use_pwm_agc = 0,
2368                 .clkoutdrive = 0,
2369                 .freq_offset_khz_uhf = 0,
2370                 .freq_offset_khz_vhf = 0,
2371         }, {
2372                 .io.pll_bypass = 0,
2373                 .io.pll_range = 1,
2374                 .io.pll_prediv = 1,
2375                 .io.pll_loopdiv = 8,
2376                 .io.adc_clock_ratio = 8,
2377                 .io.pll_int_loop_filt = 0,
2378                 .io.clock_khz = 30000,
2379                 .reset = dib90x0_tuner_reset,
2380                 .sleep = dib90x0_tuner_sleep,
2381                 .clkouttobamse = 0,
2382                 .analog_output = 0,
2383                 .use_pwm_agc = 0,
2384                 .clkoutdrive = 0,
2385                 .freq_offset_khz_uhf = 0,
2386                 .freq_offset_khz_vhf = 0,
2387         }
2388 };
2389
2390
2391 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2392 {
2393         struct dib0700_adapter_state *state = adap->priv;
2394         struct dib0700_state *st = adap->dev->priv;
2395         u32 fw_version;
2396
2397         /* Make use of the new i2c functions from FW 1.20 */
2398         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2399         if (fw_version >= 0x10200)
2400                 st->fw_use_new_i2c_api = 1;
2401         dib0700_set_i2c_speed(adap->dev, 340);
2402
2403         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2404         msleep(20);
2405         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2406         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2407         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2408         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2409
2410         dib0700_ctrl_clock(adap->dev, 72, 1);
2411
2412         msleep(20);
2413         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2414         msleep(20);
2415         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2416
2417         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2418
2419         if (reject_firmware(&state->frontend_firmware, "/*(DEBLOBBED)*/", &adap->dev->udev->dev)) {
2420                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2421                 return -ENODEV;
2422         } else {
2423                 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2424         }
2425         stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2426         stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2427
2428         adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2429
2430         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2431 }
2432
2433 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2434 {
2435         struct dib0700_adapter_state *state = adap->priv;
2436         struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2437         u16 data_dib190[10] = {
2438                 1, 0x1374,
2439                 2, 0x01a2,
2440                 7, 0x0020,
2441                 0, 0x00ef,
2442                 8, 0x0486,
2443         };
2444
2445         if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2446                 return -ENODEV;
2447         if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2448                 return -ENODEV;
2449         i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2450         if (!i2c)
2451                 return -ENODEV;
2452         if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2453                 return -ENODEV;
2454         dib0700_set_i2c_speed(adap->dev, 1500);
2455         if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2456                 return -ENODEV;
2457         release_firmware(state->frontend_firmware);
2458         return 0;
2459 }
2460
2461 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2462 {
2463         struct dib0700_adapter_state *state = adap->priv;
2464         struct dib0700_state *st = adap->dev->priv;
2465         struct i2c_adapter *i2c;
2466         struct dvb_frontend *fe_slave;
2467         u32 fw_version;
2468
2469         /* Make use of the new i2c functions from FW 1.20 */
2470         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2471         if (fw_version >= 0x10200)
2472                 st->fw_use_new_i2c_api = 1;
2473         dib0700_set_i2c_speed(adap->dev, 340);
2474
2475         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2476         msleep(20);
2477         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2478         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2479         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2480         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2481
2482         dib0700_ctrl_clock(adap->dev, 72, 1);
2483
2484         msleep(20);
2485         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2486         msleep(20);
2487         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2488
2489         if (reject_firmware(&state->frontend_firmware, "/*(DEBLOBBED)*/", &adap->dev->udev->dev)) {
2490                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2491                 return -EIO;
2492         } else {
2493                 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2494         }
2495         nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2496         nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2497         nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2498         nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2499
2500         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2501         adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2502
2503         if (adap->fe_adap[0].fe == NULL)
2504                 return -ENODEV;
2505
2506         i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2507         dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2508
2509         fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2510         dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2511
2512         return fe_slave == NULL ?  -ENODEV : 0;
2513 }
2514
2515 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2516 {
2517         struct dib0700_adapter_state *state = adap->priv;
2518         struct i2c_adapter *i2c;
2519         struct dvb_frontend *fe_slave;
2520         u16 data_dib190[10] = {
2521                 1, 0x5374,
2522                 2, 0x01ae,
2523                 7, 0x0020,
2524                 0, 0x00ef,
2525                 8, 0x0406,
2526         };
2527         if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2528                 return -ENODEV;
2529         i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2530         if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2531                 return -ENODEV;
2532         i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2533         if (!i2c)
2534                 return -ENODEV;
2535         if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2536                 return -ENODEV;
2537
2538         dib0700_set_i2c_speed(adap->dev, 1500);
2539         if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2540                 return -ENODEV;
2541
2542         fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2543         if (fe_slave != NULL) {
2544                 i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2545                 dib9000_set_i2c_adapter(fe_slave, i2c);
2546
2547                 i2c = dib9000_get_tuner_interface(fe_slave);
2548                 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2549                         return -ENODEV;
2550                 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2551                 dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2552                 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2553                         return -ENODEV;
2554         }
2555         release_firmware(state->frontend_firmware);
2556
2557         return 0;
2558 }
2559
2560 /* NIM7090 */
2561 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dibx090p_best_adc *adc)
2562 {
2563         u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2564
2565         u16 xtal = 12000;
2566         u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
2567         u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2568         u32 fdem_max = 76000;
2569         u32 fdem_min = 69500;
2570         u32 fcp = 0, fs = 0, fdem = 0;
2571         u32 harmonic_id = 0;
2572
2573         adc->pll_loopdiv = loopdiv;
2574         adc->pll_prediv = prediv;
2575         adc->timf = 0;
2576
2577         deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2578
2579         /* Find Min and Max prediv */
2580         while ((xtal/max_prediv) >= fcp_min)
2581                 max_prediv++;
2582
2583         max_prediv--;
2584         min_prediv = max_prediv;
2585         while ((xtal/min_prediv) <= fcp_max) {
2586                 min_prediv--;
2587                 if (min_prediv == 1)
2588                         break;
2589         }
2590         deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2591
2592         min_prediv = 2;
2593
2594         for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2595                 fcp = xtal / prediv;
2596                 if (fcp > fcp_min && fcp < fcp_max) {
2597                         for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2598                                 fdem = ((xtal/prediv) * loopdiv);
2599                                 fs   = fdem / 4;
2600                                 /* test min/max system restrictions */
2601
2602                                 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2603                                         spur = 0;
2604                                         /* test fs harmonics positions */
2605                                         for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2606                                                 if (((fs*harmonic_id) >= ((fe->dtv_property_cache.frequency/1000) - (fe->dtv_property_cache.bandwidth_hz/2000))) &&  ((fs*harmonic_id) <= ((fe->dtv_property_cache.frequency/1000) + (fe->dtv_property_cache.bandwidth_hz/2000)))) {
2607                                                         spur = 1;
2608                                                         break;
2609                                                 }
2610                                         }
2611
2612                                         if (!spur) {
2613                                                 adc->pll_loopdiv = loopdiv;
2614                                                 adc->pll_prediv = prediv;
2615                                                 adc->timf = 2396745143UL/fdem*(1 << 9);
2616                                                 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2617                                                 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2618                                                 break;
2619                                         }
2620                                 }
2621                         }
2622                 }
2623                 if (!spur)
2624                         break;
2625         }
2626
2627
2628         if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2629                 return -EINVAL;
2630         else
2631                 return 0;
2632 }
2633
2634 static int dib7090_agc_startup(struct dvb_frontend *fe)
2635 {
2636         struct dvb_usb_adapter *adap = fe->dvb->priv;
2637         struct dib0700_adapter_state *state = adap->priv;
2638         struct dibx000_bandwidth_config pll;
2639         u16 target;
2640         struct dibx090p_best_adc adc;
2641         int ret;
2642
2643         ret = state->set_param_save(fe);
2644         if (ret < 0)
2645                 return ret;
2646
2647         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2648         dib0090_pwm_gain_reset(fe);
2649         target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2650         state->dib7000p_ops.set_wbd_ref(fe, target);
2651
2652         if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2653                 pll.pll_ratio  = adc.pll_loopdiv;
2654                 pll.pll_prediv = adc.pll_prediv;
2655
2656                 state->dib7000p_ops.update_pll(fe, &pll);
2657                 state->dib7000p_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2658         }
2659         return 0;
2660 }
2661
2662 static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2663 {
2664         deb_info("AGC restart callback: %d", restart);
2665         if (restart == 0) /* before AGC startup */
2666                 dib0090_set_dc_servo(fe, 1);
2667         return 0;
2668 }
2669
2670 static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
2671 {
2672         struct dvb_usb_adapter *adap = fe->dvb->priv;
2673         struct dib0700_adapter_state *state = adap->priv;
2674
2675         deb_info("update LNA: agc global=%i", agc_global);
2676
2677         if (agc_global < 25000) {
2678                 state->dib7000p_ops.set_gpio(fe, 8, 0, 0);
2679                 state->dib7000p_ops.set_agc1_min(fe, 0);
2680         } else {
2681                 state->dib7000p_ops.set_gpio(fe, 8, 0, 1);
2682                 state->dib7000p_ops.set_agc1_min(fe, 32768);
2683         }
2684
2685         return 0;
2686 }
2687
2688 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2689         { 380,   81, 850, 64, 540,  4},
2690         { 860,   51, 866, 21,  375, 4},
2691         {1700,    0, 250, 0,   100, 6},
2692         {2600,    0, 250, 0,   100, 6},
2693         { 0xFFFF, 0,   0, 0,   0,   0},
2694 };
2695
2696 static struct dibx000_agc_config dib7090_agc_config[2] = {
2697         {
2698                 .band_caps      = BAND_UHF,
2699                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2700                 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
2701                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2702
2703                 .inv_gain       = 687,
2704                 .time_stabiliz  = 10,
2705
2706                 .alpha_level    = 0,
2707                 .thlock         = 118,
2708
2709                 .wbd_inv        = 0,
2710                 .wbd_ref        = 1200,
2711                 .wbd_sel        = 3,
2712                 .wbd_alpha      = 5,
2713
2714                 .agc1_max       = 65535,
2715                 .agc1_min       = 32768,
2716
2717                 .agc2_max       = 65535,
2718                 .agc2_min       = 0,
2719
2720                 .agc1_pt1       = 0,
2721                 .agc1_pt2       = 32,
2722                 .agc1_pt3       = 114,
2723                 .agc1_slope1    = 143,
2724                 .agc1_slope2    = 144,
2725                 .agc2_pt1       = 114,
2726                 .agc2_pt2       = 227,
2727                 .agc2_slope1    = 116,
2728                 .agc2_slope2    = 117,
2729
2730                 .alpha_mant     = 18,
2731                 .alpha_exp      = 0,
2732                 .beta_mant      = 20,
2733                 .beta_exp       = 59,
2734
2735                 .perform_agc_softsplit = 0,
2736         } , {
2737                 .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
2738                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2739                 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
2740                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2741
2742                 .inv_gain       = 732,
2743                 .time_stabiliz  = 10,
2744
2745                 .alpha_level    = 0,
2746                 .thlock         = 118,
2747
2748                 .wbd_inv        = 0,
2749                 .wbd_ref        = 1200,
2750                 .wbd_sel        = 3,
2751                 .wbd_alpha      = 5,
2752
2753                 .agc1_max       = 65535,
2754                 .agc1_min       = 0,
2755
2756                 .agc2_max       = 65535,
2757                 .agc2_min       = 0,
2758
2759                 .agc1_pt1       = 0,
2760                 .agc1_pt2       = 0,
2761                 .agc1_pt3       = 98,
2762                 .agc1_slope1    = 0,
2763                 .agc1_slope2    = 167,
2764                 .agc2_pt1       = 98,
2765                 .agc2_pt2       = 255,
2766                 .agc2_slope1    = 104,
2767                 .agc2_slope2    = 0,
2768
2769                 .alpha_mant     = 18,
2770                 .alpha_exp      = 0,
2771                 .beta_mant      = 20,
2772                 .beta_exp       = 59,
2773
2774                 .perform_agc_softsplit = 0,
2775         }
2776 };
2777
2778 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2779         .internal = 60000,
2780         .sampling = 15000,
2781         .pll_prediv = 1,
2782         .pll_ratio = 5,
2783         .pll_range = 0,
2784         .pll_reset = 0,
2785         .pll_bypass = 0,
2786         .enable_refdiv = 0,
2787         .bypclk_div = 0,
2788         .IO_CLK_en_core = 1,
2789         .ADClkSrc = 1,
2790         .modulo = 2,
2791         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
2792         .ifreq = (0 << 25) | 0,
2793         .timf = 20452225,
2794         .xtal_hz = 15000000,
2795 };
2796
2797 static struct dib7000p_config nim7090_dib7000p_config = {
2798         .output_mpeg2_in_188_bytes  = 1,
2799         .hostbus_diversity                      = 1,
2800         .tuner_is_baseband                      = 1,
2801         .update_lna                                     = tfe7790p_update_lna, /* GPIO used is the same as TFE7790 */
2802
2803         .agc_config_count                       = 2,
2804         .agc                                            = dib7090_agc_config,
2805
2806         .bw                                                     = &dib7090_clock_config_12_mhz,
2807
2808         .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2809         .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2810         .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2811
2812         .pwm_freq_div                           = 0,
2813
2814         .agc_control                            = dib7090_agc_restart,
2815
2816         .spur_protect                           = 0,
2817         .disable_sample_and_hold        = 0,
2818         .enable_current_mirror          = 0,
2819         .diversity_delay                        = 0,
2820
2821         .output_mode                            = OUTMODE_MPEG2_FIFO,
2822         .enMpegOutput                           = 1,
2823 };
2824
2825 static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
2826 {
2827         struct dvb_usb_adapter *adap = fe->dvb->priv;
2828         struct dib0700_adapter_state *state = adap->priv;
2829
2830         deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
2831         if (agc_global < 25000) {
2832                 state->dib7000p_ops.set_gpio(fe, 5, 0, 0);
2833                 state->dib7000p_ops.set_agc1_min(fe, 0);
2834         } else {
2835                 state->dib7000p_ops.set_gpio(fe, 5, 0, 1);
2836                 state->dib7000p_ops.set_agc1_min(fe, 32768);
2837         }
2838
2839         return 0;
2840 }
2841
2842 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2843         {
2844                 .output_mpeg2_in_188_bytes  = 1,
2845                 .hostbus_diversity                      = 1,
2846                 .tuner_is_baseband                      = 1,
2847                 .update_lna                                     = tfe7090p_pvr_update_lna,
2848
2849                 .agc_config_count                       = 2,
2850                 .agc                                            = dib7090_agc_config,
2851
2852                 .bw                                                     = &dib7090_clock_config_12_mhz,
2853
2854                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2855                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2856                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2857
2858                 .pwm_freq_div                           = 0,
2859
2860                 .agc_control                            = dib7090_agc_restart,
2861
2862                 .spur_protect                           = 0,
2863                 .disable_sample_and_hold        = 0,
2864                 .enable_current_mirror          = 0,
2865                 .diversity_delay                        = 0,
2866
2867                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2868                 .default_i2c_addr                       = 0x90,
2869                 .enMpegOutput                           = 1,
2870         }, {
2871                 .output_mpeg2_in_188_bytes  = 1,
2872                 .hostbus_diversity                      = 1,
2873                 .tuner_is_baseband                      = 1,
2874                 .update_lna                                     = tfe7090p_pvr_update_lna,
2875
2876                 .agc_config_count                       = 2,
2877                 .agc                                            = dib7090_agc_config,
2878
2879                 .bw                                                     = &dib7090_clock_config_12_mhz,
2880
2881                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2882                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2883                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2884
2885                 .pwm_freq_div                           = 0,
2886
2887                 .agc_control                            = dib7090_agc_restart,
2888
2889                 .spur_protect                           = 0,
2890                 .disable_sample_and_hold        = 0,
2891                 .enable_current_mirror          = 0,
2892                 .diversity_delay                        = 0,
2893
2894                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2895                 .default_i2c_addr                       = 0x92,
2896                 .enMpegOutput                           = 0,
2897         }
2898 };
2899
2900 static struct dib0090_config nim7090_dib0090_config = {
2901         .io.clock_khz = 12000,
2902         .io.pll_bypass = 0,
2903         .io.pll_range = 0,
2904         .io.pll_prediv = 3,
2905         .io.pll_loopdiv = 6,
2906         .io.adc_clock_ratio = 0,
2907         .io.pll_int_loop_filt = 0,
2908
2909         .freq_offset_khz_uhf = 0,
2910         .freq_offset_khz_vhf = 0,
2911
2912         .clkouttobamse = 1,
2913         .analog_output = 0,
2914
2915         .wbd_vhf_offset = 0,
2916         .wbd_cband_offset = 0,
2917         .use_pwm_agc = 1,
2918         .clkoutdrive = 0,
2919
2920         .fref_clock_ratio = 0,
2921
2922         .wbd = dib7090_wbd_table,
2923
2924         .ls_cfg_pad_drv = 0,
2925         .data_tx_drv = 0,
2926         .low_if = NULL,
2927         .in_soc = 1,
2928 };
2929
2930 static struct dib7000p_config tfe7790p_dib7000p_config = {
2931         .output_mpeg2_in_188_bytes  = 1,
2932         .hostbus_diversity                      = 1,
2933         .tuner_is_baseband                      = 1,
2934         .update_lna                                     = tfe7790p_update_lna,
2935
2936         .agc_config_count                       = 2,
2937         .agc                                            = dib7090_agc_config,
2938
2939         .bw                                                     = &dib7090_clock_config_12_mhz,
2940
2941         .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2942         .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2943         .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2944
2945         .pwm_freq_div                           = 0,
2946
2947         .agc_control                            = dib7090_agc_restart,
2948
2949         .spur_protect                           = 0,
2950         .disable_sample_and_hold        = 0,
2951         .enable_current_mirror          = 0,
2952         .diversity_delay                        = 0,
2953
2954         .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2955         .enMpegOutput                           = 1,
2956 };
2957
2958 static struct dib0090_config tfe7790p_dib0090_config = {
2959         .io.clock_khz = 12000,
2960         .io.pll_bypass = 0,
2961         .io.pll_range = 0,
2962         .io.pll_prediv = 3,
2963         .io.pll_loopdiv = 6,
2964         .io.adc_clock_ratio = 0,
2965         .io.pll_int_loop_filt = 0,
2966
2967         .freq_offset_khz_uhf = 0,
2968         .freq_offset_khz_vhf = 0,
2969
2970         .clkouttobamse = 1,
2971         .analog_output = 0,
2972
2973         .wbd_vhf_offset = 0,
2974         .wbd_cband_offset = 0,
2975         .use_pwm_agc = 1,
2976         .clkoutdrive = 0,
2977
2978         .fref_clock_ratio = 0,
2979
2980         .wbd = dib7090_wbd_table,
2981
2982         .ls_cfg_pad_drv = 0,
2983         .data_tx_drv = 0,
2984         .low_if = NULL,
2985         .in_soc = 1,
2986         .force_cband_input = 0,
2987         .is_dib7090e = 0,
2988         .force_crystal_mode = 1,
2989 };
2990
2991 static struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2992         {
2993                 .io.clock_khz = 12000,
2994                 .io.pll_bypass = 0,
2995                 .io.pll_range = 0,
2996                 .io.pll_prediv = 3,
2997                 .io.pll_loopdiv = 6,
2998                 .io.adc_clock_ratio = 0,
2999                 .io.pll_int_loop_filt = 0,
3000
3001                 .freq_offset_khz_uhf = 50,
3002                 .freq_offset_khz_vhf = 70,
3003
3004                 .clkouttobamse = 1,
3005                 .analog_output = 0,
3006
3007                 .wbd_vhf_offset = 0,
3008                 .wbd_cband_offset = 0,
3009                 .use_pwm_agc = 1,
3010                 .clkoutdrive = 0,
3011
3012                 .fref_clock_ratio = 0,
3013
3014                 .wbd = dib7090_wbd_table,
3015
3016                 .ls_cfg_pad_drv = 0,
3017                 .data_tx_drv = 0,
3018                 .low_if = NULL,
3019                 .in_soc = 1,
3020         }, {
3021                 .io.clock_khz = 12000,
3022                 .io.pll_bypass = 0,
3023                 .io.pll_range = 0,
3024                 .io.pll_prediv = 3,
3025                 .io.pll_loopdiv = 6,
3026                 .io.adc_clock_ratio = 0,
3027                 .io.pll_int_loop_filt = 0,
3028
3029                 .freq_offset_khz_uhf = -50,
3030                 .freq_offset_khz_vhf = -70,
3031
3032                 .clkouttobamse = 1,
3033                 .analog_output = 0,
3034
3035                 .wbd_vhf_offset = 0,
3036                 .wbd_cband_offset = 0,
3037                 .use_pwm_agc = 1,
3038                 .clkoutdrive = 0,
3039
3040                 .fref_clock_ratio = 0,
3041
3042                 .wbd = dib7090_wbd_table,
3043
3044                 .ls_cfg_pad_drv = 0,
3045                 .data_tx_drv = 0,
3046                 .low_if = NULL,
3047                 .in_soc = 1,
3048         }
3049 };
3050
3051 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
3052 {
3053         struct dib0700_adapter_state *state = adap->priv;
3054
3055         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3056                 return -ENODEV;
3057
3058         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3059         msleep(20);
3060         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3061         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3062         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3063         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3064
3065         msleep(20);
3066         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3067         msleep(20);
3068         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3069
3070         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
3071                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3072                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3073                 return -ENODEV;
3074         }
3075         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
3076
3077         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3078 }
3079
3080 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
3081 {
3082         struct dib0700_adapter_state *st = adap->priv;
3083         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3084
3085         nim7090_dib0090_config.reset = st->dib7000p_ops.tuner_sleep,
3086         nim7090_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep,
3087         nim7090_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3088
3089         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
3090                 return -ENODEV;
3091
3092         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3093
3094         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3095         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3096         return 0;
3097 }
3098
3099 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
3100 {
3101         struct dib0700_state *st = adap->dev->priv;
3102         struct dib0700_adapter_state *state = adap->priv;
3103
3104         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3105                 return -ENODEV;
3106
3107         /* The TFE7090 requires the dib0700 to not be in master mode */
3108         st->disable_streaming_master_mode = 1;
3109
3110         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3111         msleep(20);
3112         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3113         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3114         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3115         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3116
3117         msleep(20);
3118         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3119         msleep(20);
3120         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3121
3122         /* initialize IC 0 */
3123         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
3124                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3125                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3126                 return -ENODEV;
3127         }
3128
3129         dib0700_set_i2c_speed(adap->dev, 340);
3130         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
3131         if (adap->fe_adap[0].fe == NULL)
3132                 return -ENODEV;
3133
3134         state->dib7000p_ops.slave_reset(adap->fe_adap[0].fe);
3135
3136         return 0;
3137 }
3138
3139 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
3140 {
3141         struct i2c_adapter *i2c;
3142         struct dib0700_adapter_state *state = adap->priv;
3143
3144         if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
3145                 err("the master dib7090 has to be initialized first");
3146                 return -ENODEV; /* the master device has not been initialized */
3147         }
3148
3149         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3150                 return -ENODEV;
3151
3152         i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
3153         if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
3154                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3155                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3156                 return -ENODEV;
3157         }
3158
3159         adap->fe_adap[0].fe = state->dib7000p_ops.init(i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
3160         dib0700_set_i2c_speed(adap->dev, 200);
3161
3162         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3163 }
3164
3165 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
3166 {
3167         struct dib0700_adapter_state *st = adap->priv;
3168         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3169
3170         tfe7090pvr_dib0090_config[0].reset = st->dib7000p_ops.tuner_sleep;
3171         tfe7090pvr_dib0090_config[0].sleep = st->dib7000p_ops.tuner_sleep;
3172         tfe7090pvr_dib0090_config[0].get_adc_power = st->dib7000p_ops.get_adc_power;
3173
3174         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
3175                 return -ENODEV;
3176
3177         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3178
3179         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3180         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3181         return 0;
3182 }
3183
3184 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
3185 {
3186         struct dib0700_adapter_state *st = adap->priv;
3187         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3188
3189         tfe7090pvr_dib0090_config[1].reset = st->dib7000p_ops.tuner_sleep;
3190         tfe7090pvr_dib0090_config[1].sleep = st->dib7000p_ops.tuner_sleep;
3191         tfe7090pvr_dib0090_config[1].get_adc_power = st->dib7000p_ops.get_adc_power;
3192
3193         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
3194                 return -ENODEV;
3195
3196         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3197
3198         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3199         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3200         return 0;
3201 }
3202
3203 static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
3204 {
3205         struct dib0700_state *st = adap->dev->priv;
3206         struct dib0700_adapter_state *state = adap->priv;
3207
3208         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3209                 return -ENODEV;
3210
3211         /* The TFE7790P requires the dib0700 to not be in master mode */
3212         st->disable_streaming_master_mode = 1;
3213
3214         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3215         msleep(20);
3216         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3217         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3218         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3219         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3220         msleep(20);
3221         dib0700_ctrl_clock(adap->dev, 72, 1);
3222         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3223         msleep(20);
3224         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3225
3226         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap,
3227                                 1, 0x10, &tfe7790p_dib7000p_config) != 0) {
3228                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3229                                 __func__);
3230                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3231                 return -ENODEV;
3232         }
3233         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
3234                         0x80, &tfe7790p_dib7000p_config);
3235
3236         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3237 }
3238
3239 static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
3240 {
3241         struct dib0700_adapter_state *st = adap->priv;
3242         struct i2c_adapter *tun_i2c =
3243                 st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3244
3245
3246         tfe7790p_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3247         tfe7790p_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3248         tfe7790p_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3249
3250         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3251                                 &tfe7790p_dib0090_config) == NULL)
3252                 return -ENODEV;
3253
3254         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3255
3256         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3257         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3258         return 0;
3259 }
3260
3261 /* STK7070PD */
3262 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3263         {
3264                 .output_mpeg2_in_188_bytes = 1,
3265
3266                 .agc_config_count = 1,
3267                 .agc = &dib7070_agc_config,
3268                 .bw  = &dib7070_bw_config_12_mhz,
3269                 .tuner_is_baseband = 1,
3270                 .spur_protect = 1,
3271
3272                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3273                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3274                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3275
3276                 .hostbus_diversity = 1,
3277         }, {
3278                 .output_mpeg2_in_188_bytes = 1,
3279
3280                 .agc_config_count = 1,
3281                 .agc = &dib7070_agc_config,
3282                 .bw  = &dib7070_bw_config_12_mhz,
3283                 .tuner_is_baseband = 1,
3284                 .spur_protect = 1,
3285
3286                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3287                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3288                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3289
3290                 .hostbus_diversity = 1,
3291         }
3292 };
3293
3294 static void stk7070pd_init(struct dvb_usb_device *dev)
3295 {
3296         dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3297         msleep(10);
3298         dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3299         dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3300         dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3301         dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3302
3303         dib0700_ctrl_clock(dev, 72, 1);
3304
3305         msleep(10);
3306         dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3307 }
3308
3309 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3310 {
3311         struct dib0700_adapter_state *state = adap->priv;
3312
3313         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3314                 return -ENODEV;
3315
3316         stk7070pd_init(adap->dev);
3317
3318         msleep(10);
3319         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3320
3321         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3322                                      stk7070pd_dib7000p_config) != 0) {
3323                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3324                     __func__);
3325                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3326                 return -ENODEV;
3327         }
3328
3329         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3330         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3331 }
3332
3333 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3334 {
3335         struct dib0700_adapter_state *state = adap->priv;
3336
3337         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3338                 return -ENODEV;
3339
3340         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3341         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3342 }
3343
3344 static int novatd_read_status_override(struct dvb_frontend *fe,
3345                                        enum fe_status *stat)
3346 {
3347         struct dvb_usb_adapter *adap = fe->dvb->priv;
3348         struct dvb_usb_device *dev = adap->dev;
3349         struct dib0700_state *state = dev->priv;
3350         int ret;
3351
3352         ret = state->read_status(fe, stat);
3353
3354         if (!ret)
3355                 dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3356                                 !!(*stat & FE_HAS_LOCK));
3357
3358         return ret;
3359 }
3360
3361 static int novatd_sleep_override(struct dvb_frontend* fe)
3362 {
3363         struct dvb_usb_adapter *adap = fe->dvb->priv;
3364         struct dvb_usb_device *dev = adap->dev;
3365         struct dib0700_state *state = dev->priv;
3366
3367         /* turn off LED */
3368         dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3369
3370         return state->sleep(fe);
3371 }
3372
3373 /*
3374  * novatd_frontend_attach - Nova-TD specific attach
3375  *
3376  * Nova-TD has GPIO0, 1 and 2 for LEDs. So do not fiddle with them except for
3377  * information purposes.
3378  */
3379 static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3380 {
3381         struct dvb_usb_device *dev = adap->dev;
3382         struct dib0700_state *st = dev->priv;
3383         struct dib0700_adapter_state *state = adap->priv;
3384
3385         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3386                 return -ENODEV;
3387
3388         if (adap->id == 0) {
3389                 stk7070pd_init(dev);
3390
3391                 /* turn the power LED on, the other two off (just in case) */
3392                 dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3393                 dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3394                 dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3395
3396                 if (state->dib7000p_ops.i2c_enumeration(&dev->i2c_adap, 2, 18,
3397                                              stk7070pd_dib7000p_config) != 0) {
3398                         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3399                             __func__);
3400                         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3401                         return -ENODEV;
3402                 }
3403         }
3404
3405         adap->fe_adap[0].fe = state->dib7000p_ops.init(&dev->i2c_adap,
3406                         adap->id == 0 ? 0x80 : 0x82,
3407                         &stk7070pd_dib7000p_config[adap->id]);
3408
3409         if (adap->fe_adap[0].fe == NULL)
3410                 return -ENODEV;
3411
3412         st->read_status = adap->fe_adap[0].fe->ops.read_status;
3413         adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3414         st->sleep = adap->fe_adap[0].fe->ops.sleep;
3415         adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3416
3417         return 0;
3418 }
3419
3420 /* S5H1411 */
3421 static struct s5h1411_config pinnacle_801e_config = {
3422         .output_mode   = S5H1411_PARALLEL_OUTPUT,
3423         .gpio          = S5H1411_GPIO_OFF,
3424         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINUOUS_NONINVERTING_CLOCK,
3425         .qam_if        = S5H1411_IF_44000,
3426         .vsb_if        = S5H1411_IF_44000,
3427         .inversion     = S5H1411_INVERSION_OFF,
3428         .status_mode   = S5H1411_DEMODLOCKING
3429 };
3430
3431 /* Pinnacle PCTV HD Pro 801e GPIOs map:
3432    GPIO0  - currently unknown
3433    GPIO1  - xc5000 tuner reset
3434    GPIO2  - CX25843 sleep
3435    GPIO3  - currently unknown
3436    GPIO4  - currently unknown
3437    GPIO6  - currently unknown
3438    GPIO7  - currently unknown
3439    GPIO9  - currently unknown
3440    GPIO10 - CX25843 reset
3441  */
3442 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3443 {
3444         struct dib0700_state *st = adap->dev->priv;
3445
3446         /* Make use of the new i2c functions from FW 1.20 */
3447         st->fw_use_new_i2c_api = 1;
3448
3449         /* The s5h1411 requires the dib0700 to not be in master mode */
3450         st->disable_streaming_master_mode = 1;
3451
3452         /* All msleep values taken from Windows USB trace */
3453         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3454         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3455         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3456         msleep(400);
3457         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3458         msleep(60);
3459         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3460         msleep(30);
3461         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3462         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3463         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3464         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3465         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3466         msleep(30);
3467
3468         /* Put the CX25843 to sleep for now since we're in digital mode */
3469         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3470
3471         /* GPIOs are initialized, do the attach */
3472         adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3473                               &adap->dev->i2c_adap);
3474         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3475 }
3476
3477 static int dib0700_xc5000_tuner_callback(void *priv, int component,
3478                                          int command, int arg)
3479 {
3480         struct dvb_usb_adapter *adap = priv;
3481
3482         if (command == XC5000_TUNER_RESET) {
3483                 /* Reset the tuner */
3484                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3485                 msleep(10);
3486                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3487                 msleep(10);
3488         } else {
3489                 err("xc5000: unknown tuner callback command: %d\n", command);
3490                 return -EINVAL;
3491         }
3492
3493         return 0;
3494 }
3495
3496 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3497         .i2c_address      = 0x64,
3498         .if_khz           = 5380,
3499 };
3500
3501 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3502 {
3503         /* FIXME: generalize & move to common area */
3504         adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3505
3506         return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3507                           &s5h1411_xc5000_tunerconfig)
3508                 == NULL ? -ENODEV : 0;
3509 }
3510
3511 static int dib0700_xc4000_tuner_callback(void *priv, int component,
3512                                          int command, int arg)
3513 {
3514         struct dvb_usb_adapter *adap = priv;
3515         struct dib0700_adapter_state *state = adap->priv;
3516
3517         if (command == XC4000_TUNER_RESET) {
3518                 /* Reset the tuner */
3519                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3520                 msleep(10);
3521                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3522         } else {
3523                 err("xc4000: unknown tuner callback command: %d\n", command);
3524                 return -EINVAL;
3525         }
3526
3527         return 0;
3528 }
3529
3530 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3531         .band_caps = BAND_UHF | BAND_VHF,
3532         .setup = 0x64,
3533         .inv_gain = 0x02c8,
3534         .time_stabiliz = 0x15,
3535         .alpha_level = 0x00,
3536         .thlock = 0x76,
3537         .wbd_inv = 0x01,
3538         .wbd_ref = 0x0b33,
3539         .wbd_sel = 0x00,
3540         .wbd_alpha = 0x02,
3541         .agc1_max = 0x00,
3542         .agc1_min = 0x00,
3543         .agc2_max = 0x9b26,
3544         .agc2_min = 0x26ca,
3545         .agc1_pt1 = 0x00,
3546         .agc1_pt2 = 0x00,
3547         .agc1_pt3 = 0x00,
3548         .agc1_slope1 = 0x00,
3549         .agc1_slope2 = 0x00,
3550         .agc2_pt1 = 0x00,
3551         .agc2_pt2 = 0x80,
3552         .agc2_slope1 = 0x1d,
3553         .agc2_slope2 = 0x1d,
3554         .alpha_mant = 0x11,
3555         .alpha_exp = 0x1b,
3556         .beta_mant = 0x17,
3557         .beta_exp = 0x33,
3558         .perform_agc_softsplit = 0x00,
3559 };
3560
3561 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3562         .internal = 60000,
3563         .sampling = 30000,
3564         .pll_prediv = 1,
3565         .pll_ratio = 8,
3566         .pll_range = 3,
3567         .pll_reset = 1,
3568         .pll_bypass = 0,
3569         .enable_refdiv = 0,
3570         .bypclk_div = 0,
3571         .IO_CLK_en_core = 1,
3572         .ADClkSrc = 1,
3573         .modulo = 0,
3574         .sad_cfg = (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
3575         .ifreq = 39370534,
3576         .timf = 20452225,
3577         .xtal_hz = 30000000
3578 };
3579
3580 /* FIXME: none of these inputs are validated yet */
3581 static struct dib7000p_config pctv_340e_config = {
3582         .output_mpeg2_in_188_bytes = 1,
3583
3584         .agc_config_count = 1,
3585         .agc = &stk7700p_7000p_xc4000_agc_config,
3586         .bw  = &stk7700p_xc4000_pll_config,
3587
3588         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3589         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3590         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3591 };
3592
3593 /* PCTV 340e GPIOs map:
3594    dib0700:
3595    GPIO2  - CX25843 sleep
3596    GPIO3  - CS5340 reset
3597    GPIO5  - IRD
3598    GPIO6  - Power Supply
3599    GPIO8  - LNA (1=off 0=on)
3600    GPIO10 - CX25843 reset
3601    dib7000:
3602    GPIO8  - xc4000 reset
3603  */
3604 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3605 {
3606         struct dib0700_state *st = adap->dev->priv;
3607         struct dib0700_adapter_state *state = adap->priv;
3608
3609         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3610                 return -ENODEV;
3611
3612         /* Power Supply on */
3613         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
3614         msleep(50);
3615         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1);
3616         msleep(100); /* Allow power supply to settle before probing */
3617
3618         /* cx25843 reset */
3619         dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 0);
3620         msleep(1); /* cx25843 datasheet say 350us required */
3621         dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 1);
3622
3623         /* LNA off for now */
3624         dib0700_set_gpio(adap->dev, GPIO8,  GPIO_OUT, 1);
3625
3626         /* Put the CX25843 to sleep for now since we're in digital mode */
3627         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3628
3629         /* FIXME: not verified yet */
3630         dib0700_ctrl_clock(adap->dev, 72, 1);
3631
3632         msleep(500);
3633
3634         if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3635                 /* Demodulator not found for some reason? */
3636                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3637                 return -ENODEV;
3638         }
3639
3640         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x12,
3641                               &pctv_340e_config);
3642         st->is_dib7000pc = 1;
3643
3644         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3645 }
3646
3647 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3648         .i2c_address      = 0x61,
3649         .default_pm       = 1,
3650         .dvb_amplitude    = 0,
3651         .set_smoothedcvbs = 0,
3652         .if_khz           = 5400
3653 };
3654
3655 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3656 {
3657         struct i2c_adapter *tun_i2c;
3658         struct dib0700_adapter_state *state = adap->priv;
3659
3660         /* The xc4000 is not on the main i2c bus */
3661         tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
3662                                           DIBX000_I2C_INTERFACE_TUNER, 1);
3663         if (tun_i2c == NULL) {
3664                 printk(KERN_ERR "Could not reach tuner i2c bus\n");
3665                 return 0;
3666         }
3667
3668         /* Setup the reset callback */
3669         adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3670
3671         return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3672                           &dib7000p_xc4000_tunerconfig)
3673                 == NULL ? -ENODEV : 0;
3674 }
3675
3676 static struct lgdt3305_config hcw_lgdt3305_config = {
3677         .i2c_addr           = 0x0e,
3678         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
3679         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
3680         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
3681         .deny_i2c_rptr      = 0,
3682         .spectral_inversion = 1,
3683         .qam_if_khz         = 6000,
3684         .vsb_if_khz         = 6000,
3685         .usref_8vsb         = 0x0500,
3686 };
3687
3688 static struct mxl5007t_config hcw_mxl5007t_config = {
3689         .xtal_freq_hz = MxL_XTAL_25_MHZ,
3690         .if_freq_hz = MxL_IF_6_MHZ,
3691         .invert_if = 1,
3692 };
3693
3694 /* TIGER-ATSC map:
3695    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
3696    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
3697    GPIO4  - SCL2
3698    GPIO6  - EN_TUNER
3699    GPIO7  - SDA2
3700    GPIO10 - DEM_RST
3701
3702    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
3703  */
3704 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3705 {
3706         struct dib0700_state *st = adap->dev->priv;
3707
3708         /* Make use of the new i2c functions from FW 1.20 */
3709         st->fw_use_new_i2c_api = 1;
3710
3711         st->disable_streaming_master_mode = 1;
3712
3713         /* fe power enable */
3714         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3715         msleep(30);
3716         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3717         msleep(30);
3718
3719         /* demod reset */
3720         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3721         msleep(30);
3722         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3723         msleep(30);
3724         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3725         msleep(30);
3726
3727         adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3728                               &hcw_lgdt3305_config,
3729                               &adap->dev->i2c_adap);
3730
3731         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3732 }
3733
3734 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3735 {
3736         return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3737                           &adap->dev->i2c_adap, 0x60,
3738                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3739 }
3740
3741 static int xbox_one_attach(struct dvb_usb_adapter *adap)
3742 {
3743         struct dib0700_state *st = adap->dev->priv;
3744         struct i2c_client *client_demod, *client_tuner;
3745         struct dvb_usb_device *d = adap->dev;
3746         struct mn88472_config mn88472_config = { };
3747         struct tda18250_config tda18250_config;
3748         struct i2c_board_info info;
3749
3750         st->fw_use_new_i2c_api = 1;
3751         st->disable_streaming_master_mode = 1;
3752
3753         /* fe power enable */
3754         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3755         msleep(30);
3756         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3757         msleep(30);
3758
3759         /* demod reset */
3760         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3761         msleep(30);
3762         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3763         msleep(30);
3764         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3765         msleep(30);
3766
3767         /* attach demod */
3768         mn88472_config.fe = &adap->fe_adap[0].fe;
3769         mn88472_config.i2c_wr_max = 22;
3770         mn88472_config.xtal = 20500000;
3771         mn88472_config.ts_mode = PARALLEL_TS_MODE;
3772         mn88472_config.ts_clock = FIXED_TS_CLOCK;
3773         memset(&info, 0, sizeof(struct i2c_board_info));
3774         strlcpy(info.type, "mn88472", I2C_NAME_SIZE);
3775         info.addr = 0x18;
3776         info.platform_data = &mn88472_config;
3777         request_module(info.type);
3778         client_demod = i2c_new_device(&d->i2c_adap, &info);
3779         if (client_demod == NULL || client_demod->dev.driver == NULL)
3780                 goto fail_demod_device;
3781         if (!try_module_get(client_demod->dev.driver->owner))
3782                 goto fail_demod_module;
3783
3784         st->i2c_client_demod = client_demod;
3785
3786         adap->fe_adap[0].fe = mn88472_config.get_dvb_frontend(client_demod);
3787
3788         /* attach tuner */
3789         memset(&tda18250_config, 0, sizeof(tda18250_config));
3790         tda18250_config.if_dvbt_6 = 3950;
3791         tda18250_config.if_dvbt_7 = 4450;
3792         tda18250_config.if_dvbt_8 = 4950;
3793         tda18250_config.if_dvbc_6 = 4950;
3794         tda18250_config.if_dvbc_8 = 4950;
3795         tda18250_config.if_atsc = 4079;
3796         tda18250_config.loopthrough = true;
3797         tda18250_config.xtal_freq = TDA18250_XTAL_FREQ_27MHZ;
3798         tda18250_config.fe = adap->fe_adap[0].fe;
3799
3800         memset(&info, 0, sizeof(struct i2c_board_info));
3801         strlcpy(info.type, "tda18250", I2C_NAME_SIZE);
3802         info.addr = 0x60;
3803         info.platform_data = &tda18250_config;
3804
3805         request_module(info.type);
3806         client_tuner = i2c_new_device(&adap->dev->i2c_adap, &info);
3807         if (client_tuner == NULL || client_tuner->dev.driver == NULL)
3808                 goto fail_tuner_device;
3809         if (!try_module_get(client_tuner->dev.driver->owner))
3810                 goto fail_tuner_module;
3811
3812         st->i2c_client_tuner = client_tuner;
3813         return 0;
3814
3815 fail_tuner_module:
3816         i2c_unregister_device(client_tuner);
3817 fail_tuner_device:
3818         module_put(client_demod->dev.driver->owner);
3819 fail_demod_module:
3820         i2c_unregister_device(client_demod);
3821 fail_demod_device:
3822         return -ENODEV;
3823 }
3824
3825
3826 /* DVB-USB and USB stuff follows */
3827 struct usb_device_id dib0700_usb_id_table[] = {
3828 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
3829         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
3830         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
3831         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
3832         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
3833 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
3834         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
3835         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
3836         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
3837         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
3838 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
3839         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
3840         { USB_DEVICE(USB_VID_TERRATEC,
3841                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
3842         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
3843         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
3844 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
3845         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
3846         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
3847         { USB_DEVICE(USB_VID_PINNACLE,
3848                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
3849         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
3850 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
3851         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
3852         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
3853         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
3854         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
3855 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
3856         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
3857         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
3858         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
3859         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
3860 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
3861         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
3862         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
3863         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
3864         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
3865 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
3866         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
3867         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
3868         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
3869         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
3870 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
3871         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
3872         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
3873         { USB_DEVICE(USB_VID_TERRATEC,
3874                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
3875         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
3876 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
3877         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
3878         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
3879         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
3880         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
3881 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
3882         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
3883         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
3884         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
3885         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
3886 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
3887         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
3888         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
3889         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
3890         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
3891 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
3892         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
3893         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
3894         { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
3895         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
3896 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
3897         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
3898         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
3899         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
3900         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090M) },
3901 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM8096MD) },
3902         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090MD) },
3903         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM7090) },
3904         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7090PVR) },
3905         { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
3906 /* 75 */{ USB_DEVICE(USB_VID_MEDION,    USB_PID_CREATIX_CTX1921) },
3907         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E) },
3908         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E_SE) },
3909         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7790P) },
3910         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE8096P) },
3911 /* 80 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_2) },
3912         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PCTV_2002E) },
3913         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PCTV_2002E_SE) },
3914         { USB_DEVICE(USB_VID_PCTV,      USB_PID_DIBCOM_STK8096PVR) },
3915         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096PVR) },
3916 /* 85 */{ USB_DEVICE(USB_VID_HAMA,      USB_PID_HAMA_DVBT_HYBRID) },
3917         { USB_DEVICE(USB_VID_MICROSOFT, USB_PID_XBOX_ONE_TUNER) },
3918         { 0 }           /* Terminating entry */
3919 };
3920 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
3921
3922 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
3923         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
3924         .usb_ctrl          = DEVICE_SPECIFIC, \
3925         .firmware          = "/*(DEBLOBBED)*/", \
3926         .download_firmware = dib0700_download_firmware, \
3927         .no_reconnect      = 1, \
3928         .size_of_priv      = sizeof(struct dib0700_state), \
3929         .i2c_algo          = &dib0700_i2c_algo, \
3930         .identify_state    = dib0700_identify_state
3931
3932 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
3933         .streaming_ctrl   = dib0700_streaming_ctrl, \
3934         .stream = { \
3935                 .type = USB_BULK, \
3936                 .count = 4, \
3937                 .endpoint = ep, \
3938                 .u = { \
3939                         .bulk = { \
3940                                 .buffersize = 39480, \
3941                         } \
3942                 } \
3943         }
3944
3945 #define DIB0700_NUM_FRONTENDS(n) \
3946         .num_frontends = n, \
3947         .size_of_priv     = sizeof(struct dib0700_adapter_state)
3948
3949 struct dvb_usb_device_properties dib0700_devices[] = {
3950         {
3951                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
3952
3953                 .num_adapters = 1,
3954                 .adapter = {
3955                         {
3956                         DIB0700_NUM_FRONTENDS(1),
3957                         .fe = {{
3958                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3959                                 .pid_filter_count = 32,
3960                                 .pid_filter       = stk7700p_pid_filter,
3961                                 .pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
3962                                 .frontend_attach  = stk7700p_frontend_attach,
3963                                 .tuner_attach     = stk7700p_tuner_attach,
3964
3965                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3966                         }},
3967                         },
3968                 },
3969
3970                 .num_device_descs = 8,
3971                 .devices = {
3972                         {   "DiBcom STK7700P reference design",
3973                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3974                                 { NULL },
3975                         },
3976                         {   "Hauppauge Nova-T Stick",
3977                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3978                                 { NULL },
3979                         },
3980                         {   "AVerMedia AVerTV DVB-T Volar",
3981                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3982                                 { NULL },
3983                         },
3984                         {   "Compro Videomate U500",
3985                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3986                                 { NULL },
3987                         },
3988                         {   "Uniwill STK7700P based (Hama and others)",
3989                                 { &dib0700_usb_id_table[7], NULL },
3990                                 { NULL },
3991                         },
3992                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
3993                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3994                                 { NULL },
3995                         },
3996                         {   "AVerMedia AVerTV DVB-T Express",
3997                                 { &dib0700_usb_id_table[20] },
3998                                 { NULL },
3999                         },
4000                         {   "Gigabyte U7000",
4001                                 { &dib0700_usb_id_table[21], NULL },
4002                                 { NULL },
4003                         }
4004                 },
4005
4006                 .rc.core = {
4007                         .rc_interval      = DEFAULT_RC_INTERVAL,
4008                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4009                         .rc_query         = dib0700_rc_query_old_firmware,
4010                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4011                                             RC_PROTO_BIT_RC6_MCE |
4012                                             RC_PROTO_BIT_NEC,
4013                         .change_protocol  = dib0700_change_protocol,
4014                 },
4015         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4016
4017                 .num_adapters = 2,
4018                 .adapter = {
4019                         {
4020                         DIB0700_NUM_FRONTENDS(1),
4021                         .fe = {{
4022                                 .frontend_attach  = bristol_frontend_attach,
4023                                 .tuner_attach     = bristol_tuner_attach,
4024
4025                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4026                         }},
4027                         }, {
4028                         DIB0700_NUM_FRONTENDS(1),
4029                         .fe = {{
4030                                 .frontend_attach  = bristol_frontend_attach,
4031                                 .tuner_attach     = bristol_tuner_attach,
4032
4033                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4034                         }},
4035                         }
4036                 },
4037
4038                 .num_device_descs = 1,
4039                 .devices = {
4040                         {   "Hauppauge Nova-T 500 Dual DVB-T",
4041                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
4042                                 { NULL },
4043                         },
4044                 },
4045
4046                 .rc.core = {
4047                         .rc_interval      = DEFAULT_RC_INTERVAL,
4048                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4049                         .rc_query         = dib0700_rc_query_old_firmware,
4050                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4051                                             RC_PROTO_BIT_RC6_MCE |
4052                                             RC_PROTO_BIT_NEC,
4053                         .change_protocol = dib0700_change_protocol,
4054                 },
4055         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4056
4057                 .num_adapters = 2,
4058                 .adapter = {
4059                         {
4060                         DIB0700_NUM_FRONTENDS(1),
4061                         .fe = {{
4062                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4063                                 .pid_filter_count = 32,
4064                                 .pid_filter       = stk70x0p_pid_filter,
4065                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4066                                 .frontend_attach  = stk7700d_frontend_attach,
4067                                 .tuner_attach     = stk7700d_tuner_attach,
4068
4069                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4070                         }},
4071                         }, {
4072                         DIB0700_NUM_FRONTENDS(1),
4073                         .fe = {{
4074                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4075                                 .pid_filter_count = 32,
4076                                 .pid_filter       = stk70x0p_pid_filter,
4077                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4078                                 .frontend_attach  = stk7700d_frontend_attach,
4079                                 .tuner_attach     = stk7700d_tuner_attach,
4080
4081                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4082                         }},
4083                         }
4084                 },
4085
4086                 .num_device_descs = 5,
4087                 .devices = {
4088                         {   "Pinnacle PCTV 2000e",
4089                                 { &dib0700_usb_id_table[11], NULL },
4090                                 { NULL },
4091                         },
4092                         {   "Terratec Cinergy DT XS Diversity",
4093                                 { &dib0700_usb_id_table[12], NULL },
4094                                 { NULL },
4095                         },
4096                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
4097                                 { &dib0700_usb_id_table[13], NULL },
4098                                 { NULL },
4099                         },
4100                         {   "DiBcom STK7700D reference design",
4101                                 { &dib0700_usb_id_table[14], NULL },
4102                                 { NULL },
4103                         },
4104                         {   "YUAN High-Tech DiBcom STK7700D",
4105                                 { &dib0700_usb_id_table[55], NULL },
4106                                 { NULL },
4107                         },
4108
4109                 },
4110
4111                 .rc.core = {
4112                         .rc_interval      = DEFAULT_RC_INTERVAL,
4113                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4114                         .rc_query         = dib0700_rc_query_old_firmware,
4115                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4116                                             RC_PROTO_BIT_RC6_MCE |
4117                                             RC_PROTO_BIT_NEC,
4118                         .change_protocol = dib0700_change_protocol,
4119                 },
4120         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4121
4122                 .num_adapters = 1,
4123                 .adapter = {
4124                         {
4125                         DIB0700_NUM_FRONTENDS(1),
4126                         .fe = {{
4127                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4128                                 .pid_filter_count = 32,
4129                                 .pid_filter       = stk70x0p_pid_filter,
4130                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4131                                 .frontend_attach  = stk7700P2_frontend_attach,
4132                                 .tuner_attach     = stk7700d_tuner_attach,
4133
4134                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4135                         }},
4136                         },
4137                 },
4138
4139                 .num_device_descs = 3,
4140                 .devices = {
4141                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
4142                                 { &dib0700_usb_id_table[23], NULL },
4143                                 { NULL },
4144                         },
4145                         {   "Yuan EC372S",
4146                                 { &dib0700_usb_id_table[31], NULL },
4147                                 { NULL },
4148                         },
4149                         {   "Terratec Cinergy T Express",
4150                                 { &dib0700_usb_id_table[42], NULL },
4151                                 { NULL },
4152                         }
4153                 },
4154
4155                 .rc.core = {
4156                         .rc_interval      = DEFAULT_RC_INTERVAL,
4157                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4158                         .module_name      = "dib0700",
4159                         .rc_query         = dib0700_rc_query_old_firmware,
4160                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4161                                             RC_PROTO_BIT_RC6_MCE |
4162                                             RC_PROTO_BIT_NEC,
4163                         .change_protocol = dib0700_change_protocol,
4164                 },
4165         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4166
4167                 .num_adapters = 1,
4168                 .adapter = {
4169                         {
4170                         DIB0700_NUM_FRONTENDS(1),
4171                         .fe = {{
4172                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4173                                 .pid_filter_count = 32,
4174                                 .pid_filter       = stk70x0p_pid_filter,
4175                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4176                                 .frontend_attach  = stk7070p_frontend_attach,
4177                                 .tuner_attach     = dib7070p_tuner_attach,
4178
4179                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4180                         }},
4181                         },
4182                 },
4183
4184                 .num_device_descs = 12,
4185                 .devices = {
4186                         {   "DiBcom STK7070P reference design",
4187                                 { &dib0700_usb_id_table[15], NULL },
4188                                 { NULL },
4189                         },
4190                         {   "Pinnacle PCTV DVB-T Flash Stick",
4191                                 { &dib0700_usb_id_table[16], NULL },
4192                                 { NULL },
4193                         },
4194                         {   "Artec T14BR DVB-T",
4195                                 { &dib0700_usb_id_table[22], NULL },
4196                                 { NULL },
4197                         },
4198                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
4199                                 { &dib0700_usb_id_table[24], NULL },
4200                                 { NULL },
4201                         },
4202                         {   "Hauppauge Nova-T Stick",
4203                                 { &dib0700_usb_id_table[25], NULL },
4204                                 { NULL },
4205                         },
4206                         {   "Hauppauge Nova-T MyTV.t",
4207                                 { &dib0700_usb_id_table[26], NULL },
4208                                 { NULL },
4209                         },
4210                         {   "Pinnacle PCTV 72e",
4211                                 { &dib0700_usb_id_table[29], NULL },
4212                                 { NULL },
4213                         },
4214                         {   "Pinnacle PCTV 73e",
4215                                 { &dib0700_usb_id_table[30], NULL },
4216                                 { NULL },
4217                         },
4218                         {   "Elgato EyeTV DTT",
4219                                 { &dib0700_usb_id_table[49], NULL },
4220                                 { NULL },
4221                         },
4222                         {   "Yuan PD378S",
4223                                 { &dib0700_usb_id_table[45], NULL },
4224                                 { NULL },
4225                         },
4226                         {   "Elgato EyeTV Dtt Dlx PD378S",
4227                                 { &dib0700_usb_id_table[50], NULL },
4228                                 { NULL },
4229                         },
4230                         {   "Elgato EyeTV DTT rev. 2",
4231                                 { &dib0700_usb_id_table[80], NULL },
4232                                 { NULL },
4233                         },
4234                 },
4235
4236                 .rc.core = {
4237                         .rc_interval      = DEFAULT_RC_INTERVAL,
4238                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4239                         .module_name      = "dib0700",
4240                         .rc_query         = dib0700_rc_query_old_firmware,
4241                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4242                                             RC_PROTO_BIT_RC6_MCE |
4243                                             RC_PROTO_BIT_NEC,
4244                         .change_protocol  = dib0700_change_protocol,
4245                 },
4246         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4247
4248                 .num_adapters = 1,
4249                 .adapter = {
4250                         {
4251                         DIB0700_NUM_FRONTENDS(1),
4252                         .fe = {{
4253                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4254                                 .pid_filter_count = 32,
4255                                 .pid_filter       = stk70x0p_pid_filter,
4256                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4257                                 .frontend_attach  = stk7070p_frontend_attach,
4258                                 .tuner_attach     = dib7070p_tuner_attach,
4259
4260                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4261                         }},
4262                         },
4263                 },
4264
4265                 .num_device_descs = 3,
4266                 .devices = {
4267                         {   "Pinnacle PCTV 73A",
4268                                 { &dib0700_usb_id_table[56], NULL },
4269                                 { NULL },
4270                         },
4271                         {   "Pinnacle PCTV 73e SE",
4272                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
4273                                 { NULL },
4274                         },
4275                         {   "Pinnacle PCTV 282e",
4276                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
4277                                 { NULL },
4278                         },
4279                 },
4280
4281                 .rc.core = {
4282                         .rc_interval      = DEFAULT_RC_INTERVAL,
4283                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4284                         .module_name      = "dib0700",
4285                         .rc_query         = dib0700_rc_query_old_firmware,
4286                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4287                                             RC_PROTO_BIT_RC6_MCE |
4288                                             RC_PROTO_BIT_NEC,
4289                         .change_protocol  = dib0700_change_protocol,
4290                 },
4291         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4292
4293                 .num_adapters = 2,
4294                 .adapter = {
4295                         {
4296                         DIB0700_NUM_FRONTENDS(1),
4297                         .fe = {{
4298                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4299                                 .pid_filter_count = 32,
4300                                 .pid_filter       = stk70x0p_pid_filter,
4301                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4302                                 .frontend_attach  = novatd_frontend_attach,
4303                                 .tuner_attach     = dib7070p_tuner_attach,
4304
4305                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4306                         }},
4307                         }, {
4308                         DIB0700_NUM_FRONTENDS(1),
4309                         .fe = {{
4310                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4311                                 .pid_filter_count = 32,
4312                                 .pid_filter       = stk70x0p_pid_filter,
4313                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4314                                 .frontend_attach  = novatd_frontend_attach,
4315                                 .tuner_attach     = dib7070p_tuner_attach,
4316
4317                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4318                         }},
4319                         }
4320                 },
4321
4322                 .num_device_descs = 3,
4323                 .devices = {
4324                         {   "Hauppauge Nova-TD Stick (52009)",
4325                                 { &dib0700_usb_id_table[35], NULL },
4326                                 { NULL },
4327                         },
4328                         {   "PCTV 2002e",
4329                                 { &dib0700_usb_id_table[81], NULL },
4330                                 { NULL },
4331                         },
4332                         {   "PCTV 2002e SE",
4333                                 { &dib0700_usb_id_table[82], NULL },
4334                                 { NULL },
4335                         },
4336                 },
4337
4338                 .rc.core = {
4339                         .rc_interval      = DEFAULT_RC_INTERVAL,
4340                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4341                         .module_name      = "dib0700",
4342                         .rc_query         = dib0700_rc_query_old_firmware,
4343                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4344                                             RC_PROTO_BIT_RC6_MCE |
4345                                             RC_PROTO_BIT_NEC,
4346                         .change_protocol = dib0700_change_protocol,
4347                 },
4348         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4349
4350                 .num_adapters = 2,
4351                 .adapter = {
4352                         {
4353                         DIB0700_NUM_FRONTENDS(1),
4354                         .fe = {{
4355                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4356                                 .pid_filter_count = 32,
4357                                 .pid_filter       = stk70x0p_pid_filter,
4358                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4359                                 .frontend_attach  = stk7070pd_frontend_attach0,
4360                                 .tuner_attach     = dib7070p_tuner_attach,
4361
4362                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4363                         }},
4364                         }, {
4365                         DIB0700_NUM_FRONTENDS(1),
4366                         .fe = {{
4367                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4368                                 .pid_filter_count = 32,
4369                                 .pid_filter       = stk70x0p_pid_filter,
4370                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4371                                 .frontend_attach  = stk7070pd_frontend_attach1,
4372                                 .tuner_attach     = dib7070p_tuner_attach,
4373
4374                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4375                         }},
4376                         }
4377                 },
4378
4379                 .num_device_descs = 5,
4380                 .devices = {
4381                         {   "DiBcom STK7070PD reference design",
4382                                 { &dib0700_usb_id_table[17], NULL },
4383                                 { NULL },
4384                         },
4385                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
4386                                 { &dib0700_usb_id_table[18], NULL },
4387                                 { NULL },
4388                         },
4389                         {   "Hauppauge Nova-TD-500 (84xxx)",
4390                                 { &dib0700_usb_id_table[36], NULL },
4391                                 { NULL },
4392                         },
4393                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
4394                                 { &dib0700_usb_id_table[43],
4395                                         &dib0700_usb_id_table[53], NULL},
4396                                 { NULL },
4397                         },
4398                         {  "Sony PlayTV",
4399                                 { &dib0700_usb_id_table[44], NULL },
4400                                 { NULL },
4401                         },
4402                 },
4403
4404                 .rc.core = {
4405                         .rc_interval      = DEFAULT_RC_INTERVAL,
4406                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4407                         .module_name      = "dib0700",
4408                         .rc_query         = dib0700_rc_query_old_firmware,
4409                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4410                                             RC_PROTO_BIT_RC6_MCE |
4411                                             RC_PROTO_BIT_NEC,
4412                         .change_protocol = dib0700_change_protocol,
4413                 },
4414         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4415
4416                 .num_adapters = 2,
4417                 .adapter = {
4418                         {
4419                         DIB0700_NUM_FRONTENDS(1),
4420                         .fe = {{
4421                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4422                                 .pid_filter_count = 32,
4423                                 .pid_filter       = stk70x0p_pid_filter,
4424                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4425                                 .frontend_attach  = stk7070pd_frontend_attach0,
4426                                 .tuner_attach     = dib7070p_tuner_attach,
4427
4428                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4429                         }},
4430                         }, {
4431                         DIB0700_NUM_FRONTENDS(1),
4432                         .fe = {{
4433                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4434                                 .pid_filter_count = 32,
4435                                 .pid_filter       = stk70x0p_pid_filter,
4436                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4437                                 .frontend_attach  = stk7070pd_frontend_attach1,
4438                                 .tuner_attach     = dib7070p_tuner_attach,
4439
4440                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4441                         }},
4442                         }
4443                 },
4444
4445                 .num_device_descs = 1,
4446                 .devices = {
4447                         {   "Elgato EyeTV Diversity",
4448                                 { &dib0700_usb_id_table[68], NULL },
4449                                 { NULL },
4450                         },
4451                 },
4452
4453                 .rc.core = {
4454                         .rc_interval      = DEFAULT_RC_INTERVAL,
4455                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4456                         .module_name      = "dib0700",
4457                         .rc_query         = dib0700_rc_query_old_firmware,
4458                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4459                                             RC_PROTO_BIT_RC6_MCE |
4460                                             RC_PROTO_BIT_NEC,
4461                         .change_protocol  = dib0700_change_protocol,
4462                 },
4463         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4464
4465                 .num_adapters = 1,
4466                 .adapter = {
4467                         {
4468                         DIB0700_NUM_FRONTENDS(1),
4469                         .fe = {{
4470                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4471                                 .pid_filter_count = 32,
4472                                 .pid_filter       = stk70x0p_pid_filter,
4473                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4474                                 .frontend_attach  = stk7700ph_frontend_attach,
4475                                 .tuner_attach     = stk7700ph_tuner_attach,
4476
4477                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4478                         }},
4479                         },
4480                 },
4481
4482                 .num_device_descs = 10,
4483                 .devices = {
4484                         {   "Terratec Cinergy HT USB XE",
4485                                 { &dib0700_usb_id_table[27], NULL },
4486                                 { NULL },
4487                         },
4488                         {   "Pinnacle Expresscard 320cx",
4489                                 { &dib0700_usb_id_table[28], NULL },
4490                                 { NULL },
4491                         },
4492                         {   "Terratec Cinergy HT Express",
4493                                 { &dib0700_usb_id_table[32], NULL },
4494                                 { NULL },
4495                         },
4496                         {   "Gigabyte U8000-RH",
4497                                 { &dib0700_usb_id_table[37], NULL },
4498                                 { NULL },
4499                         },
4500                         {   "YUAN High-Tech STK7700PH",
4501                                 { &dib0700_usb_id_table[38], NULL },
4502                                 { NULL },
4503                         },
4504                         {   "Asus My Cinema-U3000Hybrid",
4505                                 { &dib0700_usb_id_table[39], NULL },
4506                                 { NULL },
4507                         },
4508                         {   "YUAN High-Tech MC770",
4509                                 { &dib0700_usb_id_table[48], NULL },
4510                                 { NULL },
4511                         },
4512                         {   "Leadtek WinFast DTV Dongle H",
4513                                 { &dib0700_usb_id_table[51], NULL },
4514                                 { NULL },
4515                         },
4516                         {   "YUAN High-Tech STK7700D",
4517                                 { &dib0700_usb_id_table[54], NULL },
4518                                 { NULL },
4519                         },
4520                         {   "Hama DVB=T Hybrid USB Stick",
4521                                 { &dib0700_usb_id_table[85], NULL },
4522                                 { NULL },
4523                         },
4524                 },
4525
4526                 .rc.core = {
4527                         .rc_interval      = DEFAULT_RC_INTERVAL,
4528                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4529                         .module_name      = "dib0700",
4530                         .rc_query         = dib0700_rc_query_old_firmware,
4531                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4532                                             RC_PROTO_BIT_RC6_MCE |
4533                                             RC_PROTO_BIT_NEC,
4534                         .change_protocol  = dib0700_change_protocol,
4535                 },
4536         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4537                 .num_adapters = 1,
4538                 .adapter = {
4539                         {
4540                         DIB0700_NUM_FRONTENDS(1),
4541                         .fe = {{
4542                                 .frontend_attach  = s5h1411_frontend_attach,
4543                                 .tuner_attach     = xc5000_tuner_attach,
4544
4545                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4546                         }},
4547                         },
4548                 },
4549
4550                 .num_device_descs = 2,
4551                 .devices = {
4552                         {   "Pinnacle PCTV HD Pro USB Stick",
4553                                 { &dib0700_usb_id_table[40], NULL },
4554                                 { NULL },
4555                         },
4556                         {   "Pinnacle PCTV HD USB Stick",
4557                                 { &dib0700_usb_id_table[41], NULL },
4558                                 { NULL },
4559                         },
4560                 },
4561
4562                 .rc.core = {
4563                         .rc_interval      = DEFAULT_RC_INTERVAL,
4564                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4565                         .module_name      = "dib0700",
4566                         .rc_query         = dib0700_rc_query_old_firmware,
4567                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4568                                             RC_PROTO_BIT_RC6_MCE |
4569                                             RC_PROTO_BIT_NEC,
4570                         .change_protocol  = dib0700_change_protocol,
4571                 },
4572         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4573                 .num_adapters = 1,
4574                 .adapter = {
4575                         {
4576                         DIB0700_NUM_FRONTENDS(1),
4577                         .fe = {{
4578                                 .frontend_attach  = lgdt3305_frontend_attach,
4579                                 .tuner_attach     = mxl5007t_tuner_attach,
4580
4581                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4582                         }},
4583                         },
4584                 },
4585
4586                 .num_device_descs = 2,
4587                 .devices = {
4588                         {   "Hauppauge ATSC MiniCard (B200)",
4589                                 { &dib0700_usb_id_table[46], NULL },
4590                                 { NULL },
4591                         },
4592                         {   "Hauppauge ATSC MiniCard (B210)",
4593                                 { &dib0700_usb_id_table[47], NULL },
4594                                 { NULL },
4595                         },
4596                 },
4597         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4598
4599                 .num_adapters = 1,
4600                 .adapter = {
4601                         {
4602                         DIB0700_NUM_FRONTENDS(1),
4603                         .fe = {{
4604                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4605                                 .pid_filter_count = 32,
4606                                 .pid_filter       = stk70x0p_pid_filter,
4607                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4608                                 .frontend_attach  = stk7770p_frontend_attach,
4609                                 .tuner_attach     = dib7770p_tuner_attach,
4610
4611                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4612                         }},
4613                         },
4614                 },
4615
4616                 .num_device_descs = 4,
4617                 .devices = {
4618                         {   "DiBcom STK7770P reference design",
4619                                 { &dib0700_usb_id_table[59], NULL },
4620                                 { NULL },
4621                         },
4622                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
4623                                 { &dib0700_usb_id_table[33],
4624                                         &dib0700_usb_id_table[52],
4625                                         &dib0700_usb_id_table[60], NULL},
4626                                 { NULL },
4627                         },
4628                         {   "TechniSat AirStar TeleStick 2",
4629                                 { &dib0700_usb_id_table[74], NULL },
4630                                 { NULL },
4631                         },
4632                         {   "Medion CTX1921 DVB-T USB",
4633                                 { &dib0700_usb_id_table[75], NULL },
4634                                 { NULL },
4635                         },
4636                 },
4637
4638                 .rc.core = {
4639                         .rc_interval      = DEFAULT_RC_INTERVAL,
4640                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4641                         .module_name      = "dib0700",
4642                         .rc_query         = dib0700_rc_query_old_firmware,
4643                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4644                                             RC_PROTO_BIT_RC6_MCE |
4645                                             RC_PROTO_BIT_NEC,
4646                         .change_protocol  = dib0700_change_protocol,
4647                 },
4648         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4649                 .num_adapters = 1,
4650                 .adapter = {
4651                         {
4652                         DIB0700_NUM_FRONTENDS(1),
4653                         .fe = {{
4654                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4655                                 .pid_filter_count = 32,
4656                                 .pid_filter = stk80xx_pid_filter,
4657                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4658                                 .frontend_attach  = stk807x_frontend_attach,
4659                                 .tuner_attach     = dib807x_tuner_attach,
4660
4661                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4662                         }},
4663                         },
4664                 },
4665
4666                 .num_device_descs = 3,
4667                 .devices = {
4668                         {   "DiBcom STK807xP reference design",
4669                                 { &dib0700_usb_id_table[62], NULL },
4670                                 { NULL },
4671                         },
4672                         {   "Prolink Pixelview SBTVD",
4673                                 { &dib0700_usb_id_table[63], NULL },
4674                                 { NULL },
4675                         },
4676                         {   "EvolutePC TVWay+",
4677                                 { &dib0700_usb_id_table[64], NULL },
4678                                 { NULL },
4679                         },
4680                 },
4681
4682                 .rc.core = {
4683                         .rc_interval      = DEFAULT_RC_INTERVAL,
4684                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4685                         .module_name      = "dib0700",
4686                         .rc_query         = dib0700_rc_query_old_firmware,
4687                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4688                                             RC_PROTO_BIT_RC6_MCE |
4689                                             RC_PROTO_BIT_NEC,
4690                         .change_protocol  = dib0700_change_protocol,
4691                 },
4692         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4693                 .num_adapters = 2,
4694                 .adapter = {
4695                         {
4696                         DIB0700_NUM_FRONTENDS(1),
4697                         .fe = {{
4698                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4699                                 .pid_filter_count = 32,
4700                                 .pid_filter = stk80xx_pid_filter,
4701                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4702                                 .frontend_attach  = stk807xpvr_frontend_attach0,
4703                                 .tuner_attach     = dib807x_tuner_attach,
4704
4705                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4706                         }},
4707                         },
4708                         {
4709                         DIB0700_NUM_FRONTENDS(1),
4710                         .fe = {{
4711                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4712                                 .pid_filter_count = 32,
4713                                 .pid_filter = stk80xx_pid_filter,
4714                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4715                                 .frontend_attach  = stk807xpvr_frontend_attach1,
4716                                 .tuner_attach     = dib807x_tuner_attach,
4717
4718                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4719                         }},
4720                         },
4721                 },
4722
4723                 .num_device_descs = 1,
4724                 .devices = {
4725                         {   "DiBcom STK807xPVR reference design",
4726                                 { &dib0700_usb_id_table[61], NULL },
4727                                 { NULL },
4728                         },
4729                 },
4730
4731                 .rc.core = {
4732                         .rc_interval      = DEFAULT_RC_INTERVAL,
4733                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4734                         .module_name      = "dib0700",
4735                         .rc_query         = dib0700_rc_query_old_firmware,
4736                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4737                                             RC_PROTO_BIT_RC6_MCE |
4738                                             RC_PROTO_BIT_NEC,
4739                         .change_protocol  = dib0700_change_protocol,
4740                 },
4741         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4742                 .num_adapters = 1,
4743                 .adapter = {
4744                         {
4745                         DIB0700_NUM_FRONTENDS(1),
4746                         .fe = {{
4747                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4748                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4749                                 .pid_filter_count = 32,
4750                                 .pid_filter = stk80xx_pid_filter,
4751                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4752                                 .frontend_attach  = stk809x_frontend_attach,
4753                                 .tuner_attach     = dib809x_tuner_attach,
4754
4755                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4756                         }},
4757                         },
4758                 },
4759
4760                 .num_device_descs = 1,
4761                 .devices = {
4762                         {   "DiBcom STK8096GP reference design",
4763                                 { &dib0700_usb_id_table[67], NULL },
4764                                 { NULL },
4765                         },
4766                 },
4767
4768                 .rc.core = {
4769                         .rc_interval      = DEFAULT_RC_INTERVAL,
4770                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4771                         .module_name      = "dib0700",
4772                         .rc_query         = dib0700_rc_query_old_firmware,
4773                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4774                                             RC_PROTO_BIT_RC6_MCE |
4775                                             RC_PROTO_BIT_NEC,
4776                         .change_protocol  = dib0700_change_protocol,
4777                 },
4778         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4779                 .num_adapters = 1,
4780                 .adapter = {
4781                         {
4782                         DIB0700_NUM_FRONTENDS(1),
4783                         .fe = {{
4784                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4785                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4786                                 .pid_filter_count = 32,
4787                                 .pid_filter = dib90x0_pid_filter,
4788                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4789                                 .frontend_attach  = stk9090m_frontend_attach,
4790                                 .tuner_attach     = dib9090_tuner_attach,
4791
4792                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4793                         }},
4794                         },
4795                 },
4796
4797                 .num_device_descs = 1,
4798                 .devices = {
4799                         {   "DiBcom STK9090M reference design",
4800                                 { &dib0700_usb_id_table[69], NULL },
4801                                 { NULL },
4802                         },
4803                 },
4804
4805                 .rc.core = {
4806                         .rc_interval      = DEFAULT_RC_INTERVAL,
4807                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4808                         .module_name      = "dib0700",
4809                         .rc_query         = dib0700_rc_query_old_firmware,
4810                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4811                                             RC_PROTO_BIT_RC6_MCE |
4812                                             RC_PROTO_BIT_NEC,
4813                         .change_protocol  = dib0700_change_protocol,
4814                 },
4815         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4816                 .num_adapters = 1,
4817                 .adapter = {
4818                         {
4819                         DIB0700_NUM_FRONTENDS(1),
4820                         .fe = {{
4821                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4822                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4823                                 .pid_filter_count = 32,
4824                                 .pid_filter = stk80xx_pid_filter,
4825                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4826                                 .frontend_attach  = nim8096md_frontend_attach,
4827                                 .tuner_attach     = nim8096md_tuner_attach,
4828
4829                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4830                         }},
4831                         },
4832                 },
4833
4834                 .num_device_descs = 1,
4835                 .devices = {
4836                         {   "DiBcom NIM8096MD reference design",
4837                                 { &dib0700_usb_id_table[70], NULL },
4838                                 { NULL },
4839                         },
4840                 },
4841
4842                 .rc.core = {
4843                         .rc_interval      = DEFAULT_RC_INTERVAL,
4844                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4845                         .module_name      = "dib0700",
4846                         .rc_query         = dib0700_rc_query_old_firmware,
4847                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4848                                             RC_PROTO_BIT_RC6_MCE |
4849                                             RC_PROTO_BIT_NEC,
4850                         .change_protocol  = dib0700_change_protocol,
4851                 },
4852         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4853                 .num_adapters = 1,
4854                 .adapter = {
4855                         {
4856                         DIB0700_NUM_FRONTENDS(1),
4857                         .fe = {{
4858                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4859                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4860                                 .pid_filter_count = 32,
4861                                 .pid_filter = dib90x0_pid_filter,
4862                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4863                                 .frontend_attach  = nim9090md_frontend_attach,
4864                                 .tuner_attach     = nim9090md_tuner_attach,
4865
4866                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4867                         }},
4868                         },
4869                 },
4870
4871                 .num_device_descs = 1,
4872                 .devices = {
4873                         {   "DiBcom NIM9090MD reference design",
4874                                 { &dib0700_usb_id_table[71], NULL },
4875                                 { NULL },
4876                         },
4877                 },
4878
4879                 .rc.core = {
4880                         .rc_interval      = DEFAULT_RC_INTERVAL,
4881                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4882                         .module_name      = "dib0700",
4883                         .rc_query         = dib0700_rc_query_old_firmware,
4884                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4885                                             RC_PROTO_BIT_RC6_MCE |
4886                                             RC_PROTO_BIT_NEC,
4887                         .change_protocol  = dib0700_change_protocol,
4888                 },
4889         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4890                 .num_adapters = 1,
4891                 .adapter = {
4892                         {
4893                         DIB0700_NUM_FRONTENDS(1),
4894                         .fe = {{
4895                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4896                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4897                                 .pid_filter_count = 32,
4898                                 .pid_filter = stk70x0p_pid_filter,
4899                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4900                                 .frontend_attach  = nim7090_frontend_attach,
4901                                 .tuner_attach     = nim7090_tuner_attach,
4902
4903                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4904                         }},
4905                         },
4906                 },
4907
4908                 .num_device_descs = 1,
4909                 .devices = {
4910                         {   "DiBcom NIM7090 reference design",
4911                                 { &dib0700_usb_id_table[72], NULL },
4912                                 { NULL },
4913                         },
4914                 },
4915
4916                 .rc.core = {
4917                         .rc_interval      = DEFAULT_RC_INTERVAL,
4918                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4919                         .module_name      = "dib0700",
4920                         .rc_query         = dib0700_rc_query_old_firmware,
4921                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4922                                             RC_PROTO_BIT_RC6_MCE |
4923                                             RC_PROTO_BIT_NEC,
4924                         .change_protocol  = dib0700_change_protocol,
4925                 },
4926         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4927                 .num_adapters = 2,
4928                 .adapter = {
4929                         {
4930                         DIB0700_NUM_FRONTENDS(1),
4931                         .fe = {{
4932                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4933                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4934                                 .pid_filter_count = 32,
4935                                 .pid_filter = stk70x0p_pid_filter,
4936                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4937                                 .frontend_attach  = tfe7090pvr_frontend0_attach,
4938                                 .tuner_attach     = tfe7090pvr_tuner0_attach,
4939
4940                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4941                         }},
4942                         },
4943                         {
4944                         DIB0700_NUM_FRONTENDS(1),
4945                         .fe = {{
4946                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4947                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4948                                 .pid_filter_count = 32,
4949                                 .pid_filter = stk70x0p_pid_filter,
4950                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4951                                 .frontend_attach  = tfe7090pvr_frontend1_attach,
4952                                 .tuner_attach     = tfe7090pvr_tuner1_attach,
4953
4954                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4955                         }},
4956                         },
4957                 },
4958
4959                 .num_device_descs = 1,
4960                 .devices = {
4961                         {   "DiBcom TFE7090PVR reference design",
4962                                 { &dib0700_usb_id_table[73], NULL },
4963                                 { NULL },
4964                         },
4965                 },
4966
4967                 .rc.core = {
4968                         .rc_interval      = DEFAULT_RC_INTERVAL,
4969                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4970                         .module_name      = "dib0700",
4971                         .rc_query         = dib0700_rc_query_old_firmware,
4972                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4973                                             RC_PROTO_BIT_RC6_MCE |
4974                                             RC_PROTO_BIT_NEC,
4975                         .change_protocol  = dib0700_change_protocol,
4976                 },
4977         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4978                 .num_adapters = 1,
4979                 .adapter = {
4980                         {
4981                         DIB0700_NUM_FRONTENDS(1),
4982                         .fe = {{
4983                                 .frontend_attach  = pctv340e_frontend_attach,
4984                                 .tuner_attach     = xc4000_tuner_attach,
4985
4986                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4987                         }},
4988                         },
4989                 },
4990
4991                 .num_device_descs = 2,
4992                 .devices = {
4993                         {   "Pinnacle PCTV 340e HD Pro USB Stick",
4994                                 { &dib0700_usb_id_table[76], NULL },
4995                                 { NULL },
4996                         },
4997                         {   "Pinnacle PCTV Hybrid Stick Solo",
4998                                 { &dib0700_usb_id_table[77], NULL },
4999                                 { NULL },
5000                         },
5001                 },
5002                 .rc.core = {
5003                         .rc_interval      = DEFAULT_RC_INTERVAL,
5004                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5005                         .module_name      = "dib0700",
5006                         .rc_query         = dib0700_rc_query_old_firmware,
5007                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5008                                             RC_PROTO_BIT_RC6_MCE |
5009                                             RC_PROTO_BIT_NEC,
5010                         .change_protocol  = dib0700_change_protocol,
5011                 },
5012         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5013                 .num_adapters = 1,
5014                 .adapter = {
5015                         {
5016                                 DIB0700_NUM_FRONTENDS(1),
5017                                 .fe = {{
5018                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5019                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5020                                         .pid_filter_count = 32,
5021                                         .pid_filter = stk70x0p_pid_filter,
5022                                         .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5023                                         .frontend_attach  = tfe7790p_frontend_attach,
5024                                         .tuner_attach     = tfe7790p_tuner_attach,
5025
5026                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5027                                 } },
5028                         },
5029                 },
5030
5031                 .num_device_descs = 1,
5032                 .devices = {
5033                         {   "DiBcom TFE7790P reference design",
5034                                 { &dib0700_usb_id_table[78], NULL },
5035                                 { NULL },
5036                         },
5037                 },
5038
5039                 .rc.core = {
5040                         .rc_interval      = DEFAULT_RC_INTERVAL,
5041                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5042                         .module_name      = "dib0700",
5043                         .rc_query         = dib0700_rc_query_old_firmware,
5044                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5045                                             RC_PROTO_BIT_RC6_MCE |
5046                                             RC_PROTO_BIT_NEC,
5047                         .change_protocol  = dib0700_change_protocol,
5048                 },
5049         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5050                 .num_adapters = 1,
5051                 .adapter = {
5052                         {
5053                                 DIB0700_NUM_FRONTENDS(1),
5054                                 .fe = {{
5055                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5056                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5057                                         .pid_filter_count = 32,
5058                                         .pid_filter = stk80xx_pid_filter,
5059                                         .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5060                                         .frontend_attach  = tfe8096p_frontend_attach,
5061                                         .tuner_attach     = tfe8096p_tuner_attach,
5062
5063                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5064
5065                                 } },
5066                         },
5067                 },
5068
5069                 .num_device_descs = 1,
5070                 .devices = {
5071                         {   "DiBcom TFE8096P reference design",
5072                                 { &dib0700_usb_id_table[79], NULL },
5073                                 { NULL },
5074                         },
5075                 },
5076
5077                 .rc.core = {
5078                         .rc_interval      = DEFAULT_RC_INTERVAL,
5079                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5080                         .module_name      = "dib0700",
5081                         .rc_query         = dib0700_rc_query_old_firmware,
5082                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5083                                             RC_PROTO_BIT_RC6_MCE |
5084                                             RC_PROTO_BIT_NEC,
5085                         .change_protocol  = dib0700_change_protocol,
5086                 },
5087         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5088                 .num_adapters = 2,
5089                 .adapter = {
5090                         {
5091                                 .num_frontends = 1,
5092                                 .fe = {{
5093                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5094                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5095                                         .pid_filter_count = 32,
5096                                         .pid_filter = stk80xx_pid_filter,
5097                                         .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5098                                         .frontend_attach  = stk809x_frontend_attach,
5099                                         .tuner_attach     = dib809x_tuner_attach,
5100
5101                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5102                                 } },
5103                                 .size_of_priv =
5104                                         sizeof(struct dib0700_adapter_state),
5105                         }, {
5106                                 .num_frontends = 1,
5107                                 .fe = { {
5108                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5109                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5110                                         .pid_filter_count = 32,
5111                                         .pid_filter = stk80xx_pid_filter,
5112                                         .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5113                                         .frontend_attach  = stk809x_frontend1_attach,
5114                                         .tuner_attach     = dib809x_tuner_attach,
5115
5116                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5117                                 } },
5118                                 .size_of_priv =
5119                                         sizeof(struct dib0700_adapter_state),
5120                         },
5121                 },
5122                 .num_device_descs = 1,
5123                 .devices = {
5124                         {   "DiBcom STK8096-PVR reference design",
5125                                 { &dib0700_usb_id_table[83],
5126                                         &dib0700_usb_id_table[84], NULL},
5127                                 { NULL },
5128                         },
5129                 },
5130
5131                 .rc.core = {
5132                         .rc_interval      = DEFAULT_RC_INTERVAL,
5133                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5134                         .module_name  = "dib0700",
5135                         .rc_query         = dib0700_rc_query_old_firmware,
5136                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5137                                 RC_PROTO_BIT_RC6_MCE |
5138                                 RC_PROTO_BIT_NEC,
5139                         .change_protocol  = dib0700_change_protocol,
5140                 },
5141         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5142                 .num_adapters = 1,
5143                 .adapter = {
5144                         {
5145                                 DIB0700_NUM_FRONTENDS(1),
5146                                 .fe = {{
5147                                         .frontend_attach = xbox_one_attach,
5148
5149                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x82),
5150                                 } },
5151                         },
5152                 },
5153                 .num_device_descs = 1,
5154                 .devices = {
5155                         { "Microsoft Xbox One Digital TV Tuner",
5156                                 { &dib0700_usb_id_table[86], NULL },
5157                                 { NULL },
5158                         },
5159                 },
5160         },
5161 };
5162
5163 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);