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