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