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

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