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

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