drivers/media/dvb/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 "s5h1411.h"
  21 #include "dib0070.h"
  22 #include "dib0090.h"
  23 #include "lgdt3305.h"
  24 #include "mxl5007t.h"
  25
  26 static int force_lna_activation;
  27 module_param(force_lna_activation, int, 0644);
  28 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
  29                 "if applicable for the device (default: 0=automatic/off).");
  30
  31 struct dib0700_adapter_state {
  32         int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
  33         const struct firmware *frontend_firmware;
  34 };
  35
  36 /* Hauppauge Nova-T 500 (aka Bristol)
  37  *  has a LNA on GPIO0 which is enabled by setting 1 */
  38 static struct mt2060_config bristol_mt2060_config[2] = {
  39         {
  40                 .i2c_address = 0x60,
  41                 .clock_out   = 3,
  42         }, {
  43                 .i2c_address = 0x61,
  44         }
  45 };
  46
  47
  48 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  49         .band_caps = BAND_VHF | BAND_UHF,
  50         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  51
  52         .agc1_max = 42598,
  53         .agc1_min = 17694,
  54         .agc2_max = 45875,
  55         .agc2_min = 0,
  56
  57         .agc1_pt1 = 0,
  58         .agc1_pt2 = 59,
  59
  60         .agc1_slope1 = 0,
  61         .agc1_slope2 = 69,
  62
  63         .agc2_pt1 = 0,
  64         .agc2_pt2 = 59,
  65
  66         .agc2_slope1 = 111,
  67         .agc2_slope2 = 28,
  68 };
  69
  70 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  71         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  72                 .max_time     = 0x196,
  73                 .ln_adc_level = 0x1cc7,
  74                 .output_mpeg2_in_188_bytes = 1,
  75         },
  76         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  77                 .max_time     = 0x196,
  78                 .ln_adc_level = 0x1cc7,
  79                 .output_mpeg2_in_188_bytes = 1,
  80         }
  81 };
  82
  83 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  84 {
  85         struct dib0700_state *st = adap->dev->priv;
  86         if (adap->id == 0) {
  87                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  88                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  89                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  90                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  91
  92                 if (force_lna_activation)
  93                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  94                 else
  95                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  96
  97                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
  98                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
  99                         return -ENODEV;
 100                 }
 101         }
 102         st->mt2060_if1[adap->id] = 1220;
 103         return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 104                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 105 }
 106
 107 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 108 {
 109         struct i2c_msg msg[2] = {
 110                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 111                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 112         };
 113         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 114         return 0;
 115 }
 116
 117 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 118 {
 119         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 120         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
 121         s8 a;
 122         int if1=1220;
 123         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 124                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 125                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 126         }
 127         return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
 128                 if1) == NULL ? -ENODEV : 0;
 129 }
 130
 131 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 132
 133 /* MT226x */
 134 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 135         {
 136                 BAND_UHF,
 137
 138                 /* 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,
 139                 * 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 */
 140                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 141             | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 142
 143                 1130,
 144                 21,
 145
 146                 0,
 147                 118,
 148
 149                 0,
 150                 3530,
 151                 1,
 152                 0,
 153
 154                 65535,
 155                 33770,
 156                 65535,
 157                 23592,
 158
 159                 0,
 160                 62,
 161                 255,
 162                 64,
 163                 64,
 164                 132,
 165                 192,
 166                 80,
 167                 80,
 168
 169                 17,
 170                 27,
 171                 23,
 172                 51,
 173
 174                 1,
 175         }, {
 176                 BAND_VHF | BAND_LBAND,
 177
 178                 /* 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,
 179                 * 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 */
 180                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 181             | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 182
 183                 2372,
 184                 21,
 185
 186                 0,
 187                 118,
 188
 189                 0,
 190                 3530,
 191                 1,
 192                 0,
 193
 194                 65535,
 195                 0,
 196                 65535,
 197                 23592,
 198
 199                 0,
 200                 128,
 201                 128,
 202                 128,
 203                 0,
 204                 128,
 205                 253,
 206                 81,
 207                 0,
 208
 209                 17,
 210                 27,
 211                 23,
 212                 51,
 213
 214                 1,
 215         }
 216 };
 217
 218 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 219         60000, 30000,
 220         1, 8, 3, 1, 0,
 221         0, 0, 1, 1, 2,
 222         (3 << 14) | (1 << 12) | (524 << 0),
 223         0,
 224         20452225,
 225 };
 226
 227 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 228         {       .output_mpeg2_in_188_bytes = 1,
 229                 .hostbus_diversity = 1,
 230                 .tuner_is_baseband = 1,
 231
 232                 .agc_config_count = 2,
 233                 .agc = stk7700d_7000p_mt2266_agc_config,
 234                 .bw  = &stk7700d_mt2266_pll_config,
 235
 236                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 237                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 238                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 239         },
 240         {       .output_mpeg2_in_188_bytes = 1,
 241                 .hostbus_diversity = 1,
 242                 .tuner_is_baseband = 1,
 243
 244                 .agc_config_count = 2,
 245                 .agc = stk7700d_7000p_mt2266_agc_config,
 246                 .bw  = &stk7700d_mt2266_pll_config,
 247
 248                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 249                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 250                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 251         }
 252 };
 253
 254 static struct mt2266_config stk7700d_mt2266_config[2] = {
 255         {       .i2c_address = 0x60
 256         },
 257         {       .i2c_address = 0x60
 258         }
 259 };
 260
 261 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 262 {
 263         if (adap->id == 0) {
 264                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 265                 msleep(10);
 266                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 267                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 268                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 269                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 270                 msleep(10);
 271                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 272                 msleep(10);
 273                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 274                                              stk7700d_dib7000p_mt2266_config)
 275                     != 0) {
 276                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 277                         return -ENODEV;
 278                 }
 279         }
 280
 281         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 282                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 283
 284         return adap->fe == NULL ? -ENODEV : 0;
 285 }
 286
 287 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 288 {
 289         if (adap->id == 0) {
 290                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 291                 msleep(10);
 292                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 293                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 294                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 295                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 296                 msleep(10);
 297                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 298                 msleep(10);
 299                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 300                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 301                                              stk7700d_dib7000p_mt2266_config)
 302                     != 0) {
 303                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 304                         return -ENODEV;
 305                 }
 306         }
 307
 308         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 309                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 310
 311         return adap->fe == NULL ? -ENODEV : 0;
 312 }
 313
 314 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 315 {
 316         struct i2c_adapter *tun_i2c;
 317         tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 318         return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
 319                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 320 }
 321
 322 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 323 static struct dibx000_agc_config xc3028_agc_config = {
 324         BAND_VHF | BAND_UHF,       /* band_caps */
 325
 326         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 327          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 328          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 329         (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
 330         (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
 331
 332         712,    /* inv_gain */
 333         21,     /* time_stabiliz */
 334
 335         0,      /* alpha_level */
 336         118,    /* thlock */
 337
 338         0,      /* wbd_inv */
 339         2867,   /* wbd_ref */
 340         0,      /* wbd_sel */
 341         2,      /* wbd_alpha */
 342
 343         0,      /* agc1_max */
 344         0,      /* agc1_min */
 345         39718,  /* agc2_max */
 346         9930,   /* agc2_min */
 347         0,      /* agc1_pt1 */
 348         0,      /* agc1_pt2 */
 349         0,      /* agc1_pt3 */
 350         0,      /* agc1_slope1 */
 351         0,      /* agc1_slope2 */
 352         0,      /* agc2_pt1 */
 353         128,    /* agc2_pt2 */
 354         29,     /* agc2_slope1 */
 355         29,     /* agc2_slope2 */
 356
 357         17,     /* alpha_mant */
 358         27,     /* alpha_exp */
 359         23,     /* beta_mant */
 360         51,     /* beta_exp */
 361
 362         1,      /* perform_agc_softsplit */
 363 };
 364
 365 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 366 static struct dibx000_bandwidth_config xc3028_bw_config = {
 367         60000, 30000, /* internal, sampling */
 368         1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
 369         0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
 370                           modulo */
 371         (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 372         (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
 373         20452225, /* timf */
 374         30000000, /* xtal_hz */
 375 };
 376
 377 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 378         .output_mpeg2_in_188_bytes = 1,
 379         .tuner_is_baseband = 1,
 380
 381         .agc_config_count = 1,
 382         .agc = &xc3028_agc_config,
 383         .bw  = &xc3028_bw_config,
 384
 385         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 386         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 387         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 388 };
 389
 390 static int stk7700ph_xc3028_callback(void *ptr, int component,
 391                                      int command, int arg)
 392 {
 393         struct dvb_usb_adapter *adap = ptr;
 394
 395         switch (command) {
 396         case XC2028_TUNER_RESET:
 397                 /* Send the tuner in then out of reset */
 398                 dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
 399                 dib7000p_set_gpio(adap->fe, 8, 0, 1);
 400                 break;
 401         case XC2028_RESET_CLK:
 402                 break;
 403         default:
 404                 err("%s: unknown command %d, arg %d\n", __func__,
 405                         command, arg);
 406                 return -EINVAL;
 407         }
 408         return 0;
 409 }
 410
 411 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
 412         .fname = XC2028_DEFAULT_FIRMWARE,
 413         .max_len = 64,
 414         .demod = XC3028_FE_DIBCOM52,
 415 };
 416
 417 static struct xc2028_config stk7700ph_xc3028_config = {
 418         .i2c_addr = 0x61,
 419         .ctrl = &stk7700ph_xc3028_ctrl,
 420 };
 421
 422 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 423 {
 424         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 425
 426         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 427             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
 428         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 429         else
 430         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 431         msleep(20);
 432         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 433         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 434         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 435         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 436         msleep(10);
 437         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 438         msleep(20);
 439         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 440         msleep(10);
 441
 442         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 443                                      &stk7700ph_dib7700_xc3028_config) != 0) {
 444                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 445                     __func__);
 446                 return -ENODEV;
 447         }
 448
 449         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 450                 &stk7700ph_dib7700_xc3028_config);
 451
 452         return adap->fe == NULL ? -ENODEV : 0;
 453 }
 454
 455 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 456 {
 457         struct i2c_adapter *tun_i2c;
 458
 459         tun_i2c = dib7000p_get_i2c_master(adap->fe,
 460                 DIBX000_I2C_INTERFACE_TUNER, 1);
 461
 462         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
 463
 464         /* FIXME: generalize & move to common area */
 465         adap->fe->callback = stk7700ph_xc3028_callback;
 466
 467         return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
 468                 == NULL ? -ENODEV : 0;
 469 }
 470
 471 #define DEFAULT_RC_INTERVAL 50
 472
 473 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 474
 475 /* Number of keypresses to ignore before start repeating */
 476 #define RC_REPEAT_DELAY 6
 477
 478 /*
 479  * This function is used only when firmware is < 1.20 version. Newer
 480  * firmwares use bulk mode, with functions implemented at dib0700_core,
 481  * at dib0700_rc_urb_completion()
 482  */
 483 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 484 {
 485         u8 key[4];
 486         u32 keycode;
 487         u8 toggle;
 488         int i;
 489         struct dib0700_state *st = d->priv;
 490
 491         if (st->fw_version >= 0x10200) {
 492                 /* For 1.20 firmware , We need to keep the RC polling
 493                    callback so we can reuse the input device setup in
 494                    dvb-usb-remote.c.  However, the actual work is being done
 495                    in the bulk URB completion handler. */
 496                 return 0;
 497         }
 498
 499         i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
 500         if (i <= 0) {
 501                 err("RC Query Failed");
 502                 return -1;
 503         }
 504
 505         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 506         if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
 507                 return 0;
 508
 509         /* 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]);  */
 510
 511         dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
 512
 513         d->last_event = 0;
 514         switch (d->props.rc.core.protocol) {
 515         case RC_TYPE_NEC:
 516                 /* NEC protocol sends repeat code as 0 0 0 FF */
 517                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
 518                     (key[3] == 0xff))
 519                         keycode = d->last_event;
 520                 else {
 521                         keycode = key[3-2] << 8 | key[3-3];
 522                         d->last_event = keycode;
 523                 }
 524
 525                 rc_keydown(d->rc_dev, keycode, 0);
 526                 break;
 527         default:
 528                 /* RC-5 protocol changes toggle bit on new keypress */
 529                 keycode = key[3-2] << 8 | key[3-3];
 530                 toggle = key[3-1];
 531                 rc_keydown(d->rc_dev, keycode, toggle);
 532
 533                 break;
 534         }
 535         return 0;
 536 }
 537
 538 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 539 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 540         BAND_UHF | BAND_VHF,
 541
 542         /* 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,
 543          * 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 */
 544         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 545         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 546
 547         712,
 548         41,
 549
 550         0,
 551         118,
 552
 553         0,
 554         4095,
 555         0,
 556         0,
 557
 558         42598,
 559         17694,
 560         45875,
 561         2621,
 562         0,
 563         76,
 564         139,
 565         52,
 566         59,
 567         107,
 568         172,
 569         57,
 570         70,
 571
 572         21,
 573         25,
 574         28,
 575         48,
 576
 577         1,
 578         {  0,
 579            107,
 580            51800,
 581            24700
 582         },
 583 };
 584
 585 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 586         BAND_UHF | BAND_VHF,
 587
 588         /* 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,
 589          * 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 */
 590         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 591         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 592
 593         712,
 594         41,
 595
 596         0,
 597         118,
 598
 599         0,
 600         4095,
 601         0,
 602         0,
 603
 604         42598,
 605         16384,
 606         42598,
 607             0,
 608
 609           0,
 610         137,
 611         255,
 612
 613           0,
 614         255,
 615
 616         0,
 617         0,
 618
 619          0,
 620         41,
 621
 622         15,
 623         25,
 624
 625         28,
 626         48,
 627
 628         0,
 629 };
 630
 631 static struct dibx000_bandwidth_config stk7700p_pll_config = {
 632         60000, 30000,
 633         1, 8, 3, 1, 0,
 634         0, 0, 1, 1, 0,
 635         (3 << 14) | (1 << 12) | (524 << 0),
 636         60258167,
 637         20452225,
 638         30000000,
 639 };
 640
 641 static struct dib7000m_config stk7700p_dib7000m_config = {
 642         .dvbt_mode = 1,
 643         .output_mpeg2_in_188_bytes = 1,
 644         .quartz_direct = 1,
 645
 646         .agc_config_count = 1,
 647         .agc = &stk7700p_7000m_mt2060_agc_config,
 648         .bw  = &stk7700p_pll_config,
 649
 650         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 651         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 652         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 653 };
 654
 655 static struct dib7000p_config stk7700p_dib7000p_config = {
 656         .output_mpeg2_in_188_bytes = 1,
 657
 658         .agc_config_count = 1,
 659         .agc = &stk7700p_7000p_mt2060_agc_config,
 660         .bw  = &stk7700p_pll_config,
 661
 662         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 663         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 664         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 665 };
 666
 667 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 668 {
 669         struct dib0700_state *st = adap->dev->priv;
 670         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 671
 672         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 673         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 674
 675         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 676         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 677
 678         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 679         dib0700_ctrl_clock(adap->dev, 72, 1);
 680         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 681
 682         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 683
 684         st->mt2060_if1[0] = 1220;
 685
 686         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
 687                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 688                 st->is_dib7000pc = 1;
 689         } else
 690                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 691
 692         return adap->fe == NULL ? -ENODEV : 0;
 693 }
 694
 695 static struct mt2060_config stk7700p_mt2060_config = {
 696         0x60
 697 };
 698
 699 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 700 {
 701         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 702         struct dib0700_state *st = adap->dev->priv;
 703         struct i2c_adapter *tun_i2c;
 704         s8 a;
 705         int if1=1220;
 706         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 707                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
 708                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
 709         }
 710         if (st->is_dib7000pc)
 711                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 712         else
 713                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 714
 715         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
 716                 if1) == NULL ? -ENODEV : 0;
 717 }
 718
 719 /* DIB7070 generic */
 720 static struct dibx000_agc_config dib7070_agc_config = {
 721         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 722         /* 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,
 723          * 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 */
 724         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 725         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 726
 727         600,
 728         10,
 729
 730         0,
 731         118,
 732
 733         0,
 734         3530,
 735         1,
 736         5,
 737
 738         65535,
 739                 0,
 740
 741         65535,
 742         0,
 743
 744         0,
 745         40,
 746         183,
 747         206,
 748         255,
 749         72,
 750         152,
 751         88,
 752         90,
 753
 754         17,
 755         27,
 756         23,
 757         51,
 758
 759         0,
 760 };
 761
 762 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 763 {
 764         deb_info("reset: %d", onoff);
 765         return dib7000p_set_gpio(fe, 8, 0, !onoff);
 766 }
 767
 768 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 769 {
 770         deb_info("sleep: %d", onoff);
 771         return dib7000p_set_gpio(fe, 9, 0, onoff);
 772 }
 773
 774 static struct dib0070_config dib7070p_dib0070_config[2] = {
 775         {
 776                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 777                 .reset = dib7070_tuner_reset,
 778                 .sleep = dib7070_tuner_sleep,
 779                 .clock_khz = 12000,
 780                 .clock_pad_drive = 4,
 781                 .charge_pump = 2,
 782         }, {
 783                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 784                 .reset = dib7070_tuner_reset,
 785                 .sleep = dib7070_tuner_sleep,
 786                 .clock_khz = 12000,
 787                 .charge_pump = 2,
 788         }
 789 };
 790
 791 static struct dib0070_config dib7770p_dib0070_config = {
 792          .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 793          .reset = dib7070_tuner_reset,
 794          .sleep = dib7070_tuner_sleep,
 795          .clock_khz = 12000,
 796          .clock_pad_drive = 0,
 797          .flip_chip = 1,
 798          .charge_pump = 2,
 799 };
 800
 801 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
 802 {
 803         struct dvb_usb_adapter *adap = fe->dvb->priv;
 804         struct dib0700_adapter_state *state = adap->priv;
 805
 806         u16 offset;
 807         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 808         switch (band) {
 809                 case BAND_VHF: offset = 950; break;
 810                 case BAND_UHF:
 811                 default: offset = 550; break;
 812         }
 813         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 814         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 815         return state->set_param_save(fe, fep);
 816 }
 817
 818 static int dib7770_set_param_override(struct dvb_frontend *fe,
 819                 struct dvb_frontend_parameters *fep)
 820 {
 821          struct dvb_usb_adapter *adap = fe->dvb->priv;
 822          struct dib0700_adapter_state *state = adap->priv;
 823
 824          u16 offset;
 825          u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 826          switch (band) {
 827          case BAND_VHF:
 828                   dib7000p_set_gpio(fe, 0, 0, 1);
 829                   offset = 850;
 830                   break;
 831          case BAND_UHF:
 832          default:
 833                   dib7000p_set_gpio(fe, 0, 0, 0);
 834                   offset = 250;
 835                   break;
 836          }
 837          deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 838          dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 839          return state->set_param_save(fe, fep);
 840 }
 841
 842 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
 843 {
 844          struct dib0700_adapter_state *st = adap->priv;
 845          struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
 846                          DIBX000_I2C_INTERFACE_TUNER, 1);
 847
 848          if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
 849                                  &dib7770p_dib0070_config) == NULL)
 850                  return -ENODEV;
 851
 852          st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 853          adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
 854          return 0;
 855 }
 856
 857 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 858 {
 859         struct dib0700_adapter_state *st = adap->priv;
 860         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 861
 862         if (adap->id == 0) {
 863                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
 864                         return -ENODEV;
 865         } else {
 866                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
 867                         return -ENODEV;
 868         }
 869
 870         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 871         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
 872         return 0;
 873 }
 874
 875 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
 876                 u16 pid, int onoff)
 877 {
 878         struct dib0700_state *st = adapter->dev->priv;
 879         if (st->is_dib7000pc)
 880                 return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
 881         return dib7000m_pid_filter(adapter->fe, index, pid, onoff);
 882 }
 883
 884 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 885 {
 886         struct dib0700_state *st = adapter->dev->priv;
 887         if (st->is_dib7000pc)
 888                 return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
 889         return dib7000m_pid_filter_ctrl(adapter->fe, onoff);
 890 }
 891
 892 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
 893 {
 894     return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
 895 }
 896
 897 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 898 {
 899     return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
 900 }
 901
 902 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
 903         60000, 15000,
 904         1, 20, 3, 1, 0,
 905         0, 0, 1, 1, 2,
 906         (3 << 14) | (1 << 12) | (524 << 0),
 907         (0 << 25) | 0,
 908         20452225,
 909         12000000,
 910 };
 911
 912 static struct dib7000p_config dib7070p_dib7000p_config = {
 913         .output_mpeg2_in_188_bytes = 1,
 914
 915         .agc_config_count = 1,
 916         .agc = &dib7070_agc_config,
 917         .bw  = &dib7070_bw_config_12_mhz,
 918         .tuner_is_baseband = 1,
 919         .spur_protect = 1,
 920
 921         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 922         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 923         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 924
 925         .hostbus_diversity = 1,
 926 };
 927
 928 /* STK7070P */
 929 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 930 {
 931         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 932         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 933             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 934                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 935         else
 936                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 937         msleep(10);
 938         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 939         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 940         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 941         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 942
 943         dib0700_ctrl_clock(adap->dev, 72, 1);
 944
 945         msleep(10);
 946         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 947         msleep(10);
 948         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 949
 950         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 951                                      &dib7070p_dib7000p_config) != 0) {
 952                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 953                     __func__);
 954                 return -ENODEV;
 955         }
 956
 957         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 958                 &dib7070p_dib7000p_config);
 959         return adap->fe == NULL ? -ENODEV : 0;
 960 }
 961
 962 /* STK7770P */
 963 static struct dib7000p_config dib7770p_dib7000p_config = {
 964         .output_mpeg2_in_188_bytes = 1,
 965
 966         .agc_config_count = 1,
 967         .agc = &dib7070_agc_config,
 968         .bw  = &dib7070_bw_config_12_mhz,
 969         .tuner_is_baseband = 1,
 970         .spur_protect = 1,
 971
 972         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 973         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 974         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 975
 976         .hostbus_diversity = 1,
 977         .enable_current_mirror = 1,
 978         .disable_sample_and_hold = 0,
 979 };
 980
 981 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
 982 {
 983         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 984         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 985             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 986                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 987         else
 988                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 989         msleep(10);
 990         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 991         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 992         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 993         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 994
 995         dib0700_ctrl_clock(adap->dev, 72, 1);
 996
 997         msleep(10);
 998         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 999         msleep(10);
1000         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1001
1002         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1003                                      &dib7770p_dib7000p_config) != 0) {
1004                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1005                     __func__);
1006                 return -ENODEV;
1007         }
1008
1009         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1010                 &dib7770p_dib7000p_config);
1011         return adap->fe == NULL ? -ENODEV : 0;
1012 }
1013
1014 /* DIB807x generic */
1015 static struct dibx000_agc_config dib807x_agc_config[2] = {
1016         {
1017                 BAND_VHF,
1018                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1019                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1020                  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1021                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1022                  * P_agc_write=0 */
1023                 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1024                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1025                         (0 << 0), /* setup*/
1026
1027                 600, /* inv_gain*/
1028                 10,  /* time_stabiliz*/
1029
1030                 0,  /* alpha_level*/
1031                 118,  /* thlock*/
1032
1033                 0,     /* wbd_inv*/
1034                 3530,  /* wbd_ref*/
1035                 1,     /* wbd_sel*/
1036                 5,     /* wbd_alpha*/
1037
1038                 65535,  /* agc1_max*/
1039                 0,  /* agc1_min*/
1040
1041                 65535,  /* agc2_max*/
1042                 0,      /* agc2_min*/
1043
1044                 0,      /* agc1_pt1*/
1045                 40,     /* agc1_pt2*/
1046                 183,    /* agc1_pt3*/
1047                 206,    /* agc1_slope1*/
1048                 255,    /* agc1_slope2*/
1049                 72,     /* agc2_pt1*/
1050                 152,    /* agc2_pt2*/
1051                 88,     /* agc2_slope1*/
1052                 90,     /* agc2_slope2*/
1053
1054                 17,  /* alpha_mant*/
1055                 27,  /* alpha_exp*/
1056                 23,  /* beta_mant*/
1057                 51,  /* beta_exp*/
1058
1059                 0,  /* perform_agc_softsplit*/
1060         }, {
1061                 BAND_UHF,
1062                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1063                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1064                  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1065                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1066                  * P_agc_write=0 */
1067                 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1068                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1069                         (0 << 0), /* setup */
1070
1071                 600, /* inv_gain*/
1072                 10,  /* time_stabiliz*/
1073
1074                 0,  /* alpha_level*/
1075                 118,  /* thlock*/
1076
1077                 0,     /* wbd_inv*/
1078                 3530,  /* wbd_ref*/
1079                 1,     /* wbd_sel*/
1080                 5,     /* wbd_alpha*/
1081
1082                 65535,  /* agc1_max*/
1083                 0,  /* agc1_min*/
1084
1085                 65535,  /* agc2_max*/
1086                 0,      /* agc2_min*/
1087
1088                 0,      /* agc1_pt1*/
1089                 40,     /* agc1_pt2*/
1090                 183,    /* agc1_pt3*/
1091                 206,    /* agc1_slope1*/
1092                 255,    /* agc1_slope2*/
1093                 72,     /* agc2_pt1*/
1094                 152,    /* agc2_pt2*/
1095                 88,     /* agc2_slope1*/
1096                 90,     /* agc2_slope2*/
1097
1098                 17,  /* alpha_mant*/
1099                 27,  /* alpha_exp*/
1100                 23,  /* beta_mant*/
1101                 51,  /* beta_exp*/
1102
1103                 0,  /* perform_agc_softsplit*/
1104         }
1105 };
1106
1107 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1108         60000, 15000, /* internal, sampling*/
1109         1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1110         0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1111                           ADClkSrc, modulo */
1112         (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1113         (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1114         18179755, /* timf*/
1115         12000000, /* xtal_hz*/
1116 };
1117
1118 static struct dib8000_config dib807x_dib8000_config[2] = {
1119         {
1120                 .output_mpeg2_in_188_bytes = 1,
1121
1122                 .agc_config_count = 2,
1123                 .agc = dib807x_agc_config,
1124                 .pll = &dib807x_bw_config_12_mhz,
1125                 .tuner_is_baseband = 1,
1126
1127                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1128                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1129                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1130
1131                 .hostbus_diversity = 1,
1132                 .div_cfg = 1,
1133                 .agc_control = &dib0070_ctrl_agc_filter,
1134                 .output_mode = OUTMODE_MPEG2_FIFO,
1135                 .drives = 0x2d98,
1136         }, {
1137                 .output_mpeg2_in_188_bytes = 1,
1138
1139                 .agc_config_count = 2,
1140                 .agc = dib807x_agc_config,
1141                 .pll = &dib807x_bw_config_12_mhz,
1142                 .tuner_is_baseband = 1,
1143
1144                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1145                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1146                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1147
1148                 .hostbus_diversity = 1,
1149                 .agc_control = &dib0070_ctrl_agc_filter,
1150                 .output_mode = OUTMODE_MPEG2_FIFO,
1151                 .drives = 0x2d98,
1152         }
1153 };
1154
1155 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1156 {
1157         return dib8000_set_gpio(fe, 5, 0, !onoff);
1158 }
1159
1160 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1161 {
1162         return dib8000_set_gpio(fe, 0, 0, onoff);
1163 }
1164
1165 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1166     { 240,      7},
1167     { 0xffff,   6},
1168 };
1169
1170 static struct dib0070_config dib807x_dib0070_config[2] = {
1171         {
1172                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1173                 .reset = dib80xx_tuner_reset,
1174                 .sleep = dib80xx_tuner_sleep,
1175                 .clock_khz = 12000,
1176                 .clock_pad_drive = 4,
1177                 .vga_filter = 1,
1178                 .force_crystal_mode = 1,
1179                 .enable_third_order_filter = 1,
1180                 .charge_pump = 0,
1181                 .wbd_gain = dib8070_wbd_gain_cfg,
1182                 .osc_buffer_state = 0,
1183                 .freq_offset_khz_uhf = -100,
1184                 .freq_offset_khz_vhf = -100,
1185         }, {
1186                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1187                 .reset = dib80xx_tuner_reset,
1188                 .sleep = dib80xx_tuner_sleep,
1189                 .clock_khz = 12000,
1190                 .clock_pad_drive = 2,
1191                 .vga_filter = 1,
1192                 .force_crystal_mode = 1,
1193                 .enable_third_order_filter = 1,
1194                 .charge_pump = 0,
1195                 .wbd_gain = dib8070_wbd_gain_cfg,
1196                 .osc_buffer_state = 0,
1197                 .freq_offset_khz_uhf = -25,
1198                 .freq_offset_khz_vhf = -25,
1199         }
1200 };
1201
1202 static int dib807x_set_param_override(struct dvb_frontend *fe,
1203                 struct dvb_frontend_parameters *fep)
1204 {
1205         struct dvb_usb_adapter *adap = fe->dvb->priv;
1206         struct dib0700_adapter_state *state = adap->priv;
1207
1208         u16 offset = dib0070_wbd_offset(fe);
1209         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1210         switch (band) {
1211         case BAND_VHF:
1212                 offset += 750;
1213                 break;
1214         case BAND_UHF:  /* fall-thru wanted */
1215         default:
1216                 offset += 250; break;
1217         }
1218         deb_info("WBD for DiB8000: %d\n", offset);
1219         dib8000_set_wbd_ref(fe, offset);
1220
1221         return state->set_param_save(fe, fep);
1222 }
1223
1224 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1225 {
1226         struct dib0700_adapter_state *st = adap->priv;
1227         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1228                         DIBX000_I2C_INTERFACE_TUNER, 1);
1229
1230         if (adap->id == 0) {
1231                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1232                                 &dib807x_dib0070_config[0]) == NULL)
1233                         return -ENODEV;
1234         } else {
1235                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1236                                 &dib807x_dib0070_config[1]) == NULL)
1237                         return -ENODEV;
1238         }
1239
1240         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1241         adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1242         return 0;
1243 }
1244
1245 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1246         u16 pid, int onoff)
1247 {
1248         return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1249 }
1250
1251 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1252                 int onoff)
1253 {
1254         return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1255 }
1256
1257 /* STK807x */
1258 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1259 {
1260         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1261         msleep(10);
1262         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1263         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1264         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1265
1266         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1267
1268         dib0700_ctrl_clock(adap->dev, 72, 1);
1269
1270         msleep(10);
1271         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1272         msleep(10);
1273         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1274
1275         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1276                                 0x80);
1277
1278         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1279                               &dib807x_dib8000_config[0]);
1280
1281         return adap->fe == NULL ?  -ENODEV : 0;
1282 }
1283
1284 /* STK807xPVR */
1285 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1286 {
1287         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1288         msleep(30);
1289         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1290         msleep(500);
1291         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1292         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1293         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1294
1295         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1296
1297         dib0700_ctrl_clock(adap->dev, 72, 1);
1298
1299         msleep(10);
1300         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1301         msleep(10);
1302         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1303
1304         /* initialize IC 0 */
1305         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1306
1307         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1308                               &dib807x_dib8000_config[0]);
1309
1310         return adap->fe == NULL ? -ENODEV : 0;
1311 }
1312
1313 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1314 {
1315         /* initialize IC 1 */
1316         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1317
1318         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1319                               &dib807x_dib8000_config[1]);
1320
1321         return adap->fe == NULL ? -ENODEV : 0;
1322 }
1323
1324 /* STK8096GP */
1325 struct dibx000_agc_config dib8090_agc_config[2] = {
1326         {
1327         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1328         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1329          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1330          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1331         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1332         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1333
1334         787,
1335         10,
1336
1337         0,
1338         118,
1339
1340         0,
1341         3530,
1342         1,
1343         5,
1344
1345         65535,
1346         0,
1347
1348         65535,
1349         0,
1350
1351         0,
1352         32,
1353         114,
1354         143,
1355         144,
1356         114,
1357         227,
1358         116,
1359         117,
1360
1361         28,
1362         26,
1363         31,
1364         51,
1365
1366         0,
1367         },
1368         {
1369         BAND_CBAND,
1370         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1371          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1372          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1373         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1374         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1375
1376         787,
1377         10,
1378
1379         0,
1380         118,
1381
1382         0,
1383         3530,
1384         1,
1385         5,
1386
1387         0,
1388         0,
1389
1390         65535,
1391         0,
1392
1393         0,
1394         32,
1395         114,
1396         143,
1397         144,
1398         114,
1399         227,
1400         116,
1401         117,
1402
1403         28,
1404         26,
1405         31,
1406         51,
1407
1408         0,
1409         }
1410 };
1411
1412 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1413         54000, 13500,
1414         1, 18, 3, 1, 0,
1415         0, 0, 1, 1, 2,
1416         (3 << 14) | (1 << 12) | (599 << 0),
1417         (0 << 25) | 0,
1418         20199727,
1419         12000000,
1420 };
1421
1422 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1423 {
1424         return dib8000_get_adc_power(fe, 1);
1425 }
1426
1427 static struct dib8000_config dib809x_dib8000_config[2] = {
1428         {
1429         .output_mpeg2_in_188_bytes = 1,
1430
1431         .agc_config_count = 2,
1432         .agc = dib8090_agc_config,
1433         .agc_control = dib0090_dcc_freq,
1434         .pll = &dib8090_pll_config_12mhz,
1435         .tuner_is_baseband = 1,
1436
1437         .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1438         .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1439         .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1440
1441         .hostbus_diversity = 1,
1442         .div_cfg = 0x31,
1443         .output_mode = OUTMODE_MPEG2_FIFO,
1444         .drives = 0x2d98,
1445         .diversity_delay = 48,
1446         .refclksel = 3,
1447         }, {
1448         .output_mpeg2_in_188_bytes = 1,
1449
1450         .agc_config_count = 2,
1451         .agc = dib8090_agc_config,
1452         .agc_control = dib0090_dcc_freq,
1453         .pll = &dib8090_pll_config_12mhz,
1454         .tuner_is_baseband = 1,
1455
1456         .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1457         .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1458         .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1459
1460         .hostbus_diversity = 1,
1461         .div_cfg = 0x31,
1462         .output_mode = OUTMODE_DIVERSITY,
1463         .drives = 0x2d08,
1464         .diversity_delay = 1,
1465         .refclksel = 3,
1466         }
1467 };
1468
1469 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1470         /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1471         { 120,     0, 500,  0,   500, 4 }, /* CBAND */
1472         { 170,     0, 450,  0,   450, 4 }, /* CBAND */
1473         { 380,    48, 373, 28,   259, 6 }, /* VHF */
1474         { 860,    34, 700, 36,   616, 6 }, /* high UHF */
1475         { 0xFFFF, 34, 700, 36,   616, 6 }, /* default */
1476 };
1477
1478 static struct dib0090_config dib809x_dib0090_config = {
1479         .io.pll_bypass = 1,
1480         .io.pll_range = 1,
1481         .io.pll_prediv = 1,
1482         .io.pll_loopdiv = 20,
1483         .io.adc_clock_ratio = 8,
1484         .io.pll_int_loop_filt = 0,
1485         .io.clock_khz = 12000,
1486         .reset = dib80xx_tuner_reset,
1487         .sleep = dib80xx_tuner_sleep,
1488         .clkouttobamse = 1,
1489         .analog_output = 1,
1490         .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1491         .use_pwm_agc = 1,
1492         .clkoutdrive = 1,
1493         .get_adc_power = dib8090_get_adc_power,
1494         .freq_offset_khz_uhf = -63,
1495         .freq_offset_khz_vhf = -143,
1496         .wbd = dib8090_wbd_table,
1497         .fref_clock_ratio = 6,
1498 };
1499
1500 static int dib8096_set_param_override(struct dvb_frontend *fe,
1501                 struct dvb_frontend_parameters *fep)
1502 {
1503         struct dvb_usb_adapter *adap = fe->dvb->priv;
1504         struct dib0700_adapter_state *state = adap->priv;
1505         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1506         u16 target;
1507         int ret = 0;
1508         enum frontend_tune_state tune_state = CT_SHUTDOWN;
1509         u16 ltgain, rf_gain_limit;
1510
1511         ret = state->set_param_save(fe, fep);
1512         if (ret < 0)
1513                 return ret;
1514
1515         target = (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1516         dib8000_set_wbd_ref(fe, target);
1517
1518
1519         if (band == BAND_CBAND) {
1520                 deb_info("tuning in CBAND - soft-AGC startup\n");
1521                 dib0090_set_tune_state(fe, CT_AGC_START);
1522                 do {
1523                         ret = dib0090_gain_control(fe);
1524                         msleep(ret);
1525                         tune_state = dib0090_get_tune_state(fe);
1526                         if (tune_state == CT_AGC_STEP_0)
1527                                 dib8000_set_gpio(fe, 6, 0, 1);
1528                         else if (tune_state == CT_AGC_STEP_1) {
1529                                 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1530                                 if (rf_gain_limit == 0)
1531                                         dib8000_set_gpio(fe, 6, 0, 0);
1532                         }
1533                 } while (tune_state < CT_AGC_STOP);
1534                 dib0090_pwm_gain_reset(fe);
1535                 dib8000_pwm_agc_reset(fe);
1536                 dib8000_set_tune_state(fe, CT_DEMOD_START);
1537         } else {
1538                 deb_info("not tuning in CBAND - standard AGC startup\n");
1539                 dib0090_pwm_gain_reset(fe);
1540         }
1541
1542         return 0;
1543 }
1544
1545 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1546 {
1547         struct dib0700_adapter_state *st = adap->priv;
1548         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1549
1550         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1551                 return -ENODEV;
1552
1553         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1554         adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1555         return 0;
1556 }
1557
1558 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1559 {
1560         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1561         msleep(10);
1562         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1563         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1564         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1565
1566         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1567
1568         dib0700_ctrl_clock(adap->dev, 72, 1);
1569
1570         msleep(10);
1571         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1572         msleep(10);
1573         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1574
1575         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1576
1577         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1578
1579         return adap->fe == NULL ?  -ENODEV : 0;
1580 }
1581
1582 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1583 {
1584         struct dib0700_adapter_state *st = adap->priv;
1585         struct i2c_adapter *tun_i2c;
1586         struct dvb_frontend *fe_slave  = dib8000_get_slave_frontend(adap->fe, 1);
1587
1588         if (fe_slave) {
1589                 tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1590                 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1591                         return -ENODEV;
1592                 fe_slave->dvb = adap->fe->dvb;
1593                 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1594         }
1595         tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1596         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1597                 return -ENODEV;
1598
1599         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1600         adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1601
1602         return 0;
1603 }
1604
1605 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1606 {
1607         struct dvb_frontend *fe_slave;
1608
1609         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1610         msleep(20);
1611         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1612         msleep(1000);
1613         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1614         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1615         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1616
1617         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1618
1619         dib0700_ctrl_clock(adap->dev, 72, 1);
1620
1621         msleep(20);
1622         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1623         msleep(20);
1624         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1625
1626         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80);
1627
1628         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1629         if (adap->fe == NULL)
1630                 return -ENODEV;
1631
1632         fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1633         dib8000_set_slave_frontend(adap->fe, fe_slave);
1634
1635         return fe_slave == NULL ?  -ENODEV : 0;
1636 }
1637
1638 /* STK9090M */
1639 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1640 {
1641         return dib9000_fw_pid_filter(adapter->fe, index, pid, onoff);
1642 }
1643
1644 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1645 {
1646         return dib9000_fw_pid_filter_ctrl(adapter->fe, onoff);
1647 }
1648
1649 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
1650 {
1651         return dib9000_set_gpio(fe, 5, 0, !onoff);
1652 }
1653
1654 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
1655 {
1656         return dib9000_set_gpio(fe, 0, 0, onoff);
1657 }
1658
1659 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
1660 {
1661         u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
1662         u8 rb[2];
1663         struct i2c_msg msg[2] = {
1664                 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
1665                 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
1666         };
1667         u8 index_data;
1668
1669         dibx000_i2c_set_speed(i2c, 250);
1670
1671         if (i2c_transfer(i2c, msg, 2) != 2)
1672                 return -EIO;
1673
1674         switch (rb[0] << 8 | rb[1]) {
1675         case 0:
1676                         deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
1677                         return -EIO;
1678         case 1:
1679                         deb_info("Found DiB0170 rev2");
1680                         break;
1681         case 2:
1682                         deb_info("Found DiB0190 rev2");
1683                         break;
1684         default:
1685                         deb_info("DiB01x0 not found");
1686                         return -EIO;
1687         }
1688
1689         for (index_data = 0; index_data < len; index_data += 2) {
1690                 wb[2] = (data[index_data + 1] >> 8) & 0xff;
1691                 wb[3] = (data[index_data + 1]) & 0xff;
1692
1693                 if (data[index_data] == 0) {
1694                         wb[0] = (data[index_data] >> 8) & 0xff;
1695                         wb[1] = (data[index_data]) & 0xff;
1696                         msg[0].len = 2;
1697                         if (i2c_transfer(i2c, msg, 2) != 2)
1698                                 return -EIO;
1699                         wb[2] |= rb[0];
1700                         wb[3] |= rb[1] & ~(3 << 4);
1701                 }
1702
1703                 wb[0] = (data[index_data] >> 8)&0xff;
1704                 wb[1] = (data[index_data])&0xff;
1705                 msg[0].len = 4;
1706                 if (i2c_transfer(i2c, &msg[0], 1) != 1)
1707                         return -EIO;
1708         }
1709         return 0;
1710 }
1711
1712 static struct dib9000_config stk9090m_config = {
1713         .output_mpeg2_in_188_bytes = 1,
1714         .output_mode = OUTMODE_MPEG2_FIFO,
1715         .vcxo_timer = 279620,
1716         .timing_frequency = 20452225,
1717         .demod_clock_khz = 60000,
1718         .xtal_clock_khz = 30000,
1719         .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1720         .subband = {
1721                 2,
1722                 {
1723                         { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
1724                         { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
1725                         { 0 },
1726                 },
1727         },
1728         .gpio_function = {
1729                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1730                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1731         },
1732 };
1733
1734 static struct dib9000_config nim9090md_config[2] = {
1735         {
1736                 .output_mpeg2_in_188_bytes = 1,
1737                 .output_mode = OUTMODE_MPEG2_FIFO,
1738                 .vcxo_timer = 279620,
1739                 .timing_frequency = 20452225,
1740                 .demod_clock_khz = 60000,
1741                 .xtal_clock_khz = 30000,
1742                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1743         }, {
1744                 .output_mpeg2_in_188_bytes = 1,
1745                 .output_mode = OUTMODE_DIVERSITY,
1746                 .vcxo_timer = 279620,
1747                 .timing_frequency = 20452225,
1748                 .demod_clock_khz = 60000,
1749                 .xtal_clock_khz = 30000,
1750                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1751                 .subband = {
1752                         2,
1753                         {
1754                                 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
1755                                 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
1756                                 { 0 },
1757                         },
1758                 },
1759                 .gpio_function = {
1760                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1761                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1762                 },
1763         }
1764 };
1765
1766 static struct dib0090_config dib9090_dib0090_config = {
1767         .io.pll_bypass = 0,
1768         .io.pll_range = 1,
1769         .io.pll_prediv = 1,
1770         .io.pll_loopdiv = 8,
1771         .io.adc_clock_ratio = 8,
1772         .io.pll_int_loop_filt = 0,
1773         .io.clock_khz = 30000,
1774         .reset = dib90x0_tuner_reset,
1775         .sleep = dib90x0_tuner_sleep,
1776         .clkouttobamse = 0,
1777         .analog_output = 0,
1778         .use_pwm_agc = 0,
1779         .clkoutdrive = 0,
1780         .freq_offset_khz_uhf = 0,
1781         .freq_offset_khz_vhf = 0,
1782 };
1783
1784 static struct dib0090_config nim9090md_dib0090_config[2] = {
1785         {
1786                 .io.pll_bypass = 0,
1787                 .io.pll_range = 1,
1788                 .io.pll_prediv = 1,
1789                 .io.pll_loopdiv = 8,
1790                 .io.adc_clock_ratio = 8,
1791                 .io.pll_int_loop_filt = 0,
1792                 .io.clock_khz = 30000,
1793                 .reset = dib90x0_tuner_reset,
1794                 .sleep = dib90x0_tuner_sleep,
1795                 .clkouttobamse = 1,
1796                 .analog_output = 0,
1797                 .use_pwm_agc = 0,
1798                 .clkoutdrive = 0,
1799                 .freq_offset_khz_uhf = 0,
1800                 .freq_offset_khz_vhf = 0,
1801         }, {
1802                 .io.pll_bypass = 0,
1803                 .io.pll_range = 1,
1804                 .io.pll_prediv = 1,
1805                 .io.pll_loopdiv = 8,
1806                 .io.adc_clock_ratio = 8,
1807                 .io.pll_int_loop_filt = 0,
1808                 .io.clock_khz = 30000,
1809                 .reset = dib90x0_tuner_reset,
1810                 .sleep = dib90x0_tuner_sleep,
1811                 .clkouttobamse = 0,
1812                 .analog_output = 0,
1813                 .use_pwm_agc = 0,
1814                 .clkoutdrive = 0,
1815                 .freq_offset_khz_uhf = 0,
1816                 .freq_offset_khz_vhf = 0,
1817         }
1818 };
1819
1820
1821 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
1822 {
1823         struct dib0700_adapter_state *state = adap->priv;
1824         struct dib0700_state *st = adap->dev->priv;
1825         u32 fw_version;
1826
1827         /* Make use of the new i2c functions from FW 1.20 */
1828         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
1829         if (fw_version >= 0x10200)
1830                 st->fw_use_new_i2c_api = 1;
1831         dib0700_set_i2c_speed(adap->dev, 340);
1832
1833         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1834         msleep(20);
1835         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1836         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1837         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1838         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1839
1840         dib0700_ctrl_clock(adap->dev, 72, 1);
1841
1842         msleep(20);
1843         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1844         msleep(20);
1845         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1846
1847         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
1848
1849         if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
1850                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
1851                 return -ENODEV;
1852         } else {
1853                 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
1854         }
1855         stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
1856         stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
1857
1858         adap->fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
1859
1860         return adap->fe == NULL ?  -ENODEV : 0;
1861 }
1862
1863 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
1864 {
1865         struct dib0700_adapter_state *state = adap->priv;
1866         struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe);
1867         u16 data_dib190[10] = {
1868                 1, 0x1374,
1869                 2, 0x01a2,
1870                 7, 0x0020,
1871                 0, 0x00ef,
1872                 8, 0x0486,
1873         };
1874
1875         if (dvb_attach(dib0090_fw_register, adap->fe, i2c, &dib9090_dib0090_config) == NULL)
1876                 return -ENODEV;
1877         i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
1878         if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
1879                 return -ENODEV;
1880         dib0700_set_i2c_speed(adap->dev, 2000);
1881         if (dib9000_firmware_post_pll_init(adap->fe) < 0)
1882                 return -ENODEV;
1883         release_firmware(state->frontend_firmware);
1884         return 0;
1885 }
1886
1887 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
1888 {
1889         struct dib0700_adapter_state *state = adap->priv;
1890         struct dib0700_state *st = adap->dev->priv;
1891         struct i2c_adapter *i2c;
1892         struct dvb_frontend *fe_slave;
1893         u32 fw_version;
1894
1895         /* Make use of the new i2c functions from FW 1.20 */
1896         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
1897         if (fw_version >= 0x10200)
1898                 st->fw_use_new_i2c_api = 1;
1899         dib0700_set_i2c_speed(adap->dev, 340);
1900
1901         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1902         msleep(20);
1903         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1904         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1905         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1906         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1907
1908         dib0700_ctrl_clock(adap->dev, 72, 1);
1909
1910         msleep(20);
1911         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1912         msleep(20);
1913         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1914
1915         if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
1916                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
1917                 return -EIO;
1918         } else {
1919                 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
1920         }
1921         nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
1922         nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
1923         nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
1924         nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
1925
1926         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
1927         adap->fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
1928
1929         if (adap->fe == NULL)
1930                 return -ENODEV;
1931
1932         i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
1933         dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
1934
1935         fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
1936         dib9000_set_slave_frontend(adap->fe, fe_slave);
1937
1938         return fe_slave == NULL ?  -ENODEV : 0;
1939 }
1940
1941 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
1942 {
1943         struct dib0700_adapter_state *state = adap->priv;
1944         struct i2c_adapter *i2c;
1945         struct dvb_frontend *fe_slave;
1946         u16 data_dib190[10] = {
1947                 1, 0x5374,
1948                 2, 0x01ae,
1949                 7, 0x0020,
1950                 0, 0x00ef,
1951                 8, 0x0406,
1952         };
1953         i2c = dib9000_get_tuner_interface(adap->fe);
1954         if (dvb_attach(dib0090_fw_register, adap->fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
1955                 return -ENODEV;
1956         i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
1957         if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
1958                 return -ENODEV;
1959         dib0700_set_i2c_speed(adap->dev, 2000);
1960         if (dib9000_firmware_post_pll_init(adap->fe) < 0)
1961                 return -ENODEV;
1962
1963         fe_slave = dib9000_get_slave_frontend(adap->fe, 1);
1964         if (fe_slave != NULL) {
1965                 i2c = dib9000_get_component_bus_interface(adap->fe);
1966                 dib9000_set_i2c_adapter(fe_slave, i2c);
1967
1968                 i2c = dib9000_get_tuner_interface(fe_slave);
1969                 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
1970                         return -ENODEV;
1971                 fe_slave->dvb = adap->fe->dvb;
1972                 dib9000_fw_set_component_bus_speed(adap->fe, 2000);
1973                 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
1974                         return -ENODEV;
1975         }
1976         release_firmware(state->frontend_firmware);
1977
1978         return 0;
1979 }
1980
1981 /* NIM7090 */
1982 struct dib7090p_best_adc {
1983         u32 timf;
1984         u32 pll_loopdiv;
1985         u32 pll_prediv;
1986 };
1987
1988 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dib7090p_best_adc *adc)
1989 {
1990         u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
1991
1992         u16 xtal = 12000;
1993         u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
1994         u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
1995         u32 fdem_max = 76000;
1996         u32 fdem_min = 69500;
1997         u32 fcp = 0, fs = 0, fdem = 0;
1998         u32 harmonic_id = 0;
1999
2000         adc->pll_loopdiv = loopdiv;
2001         adc->pll_prediv = prediv;
2002         adc->timf = 0;
2003
2004         deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2005
2006         /* Find Min and Max prediv */
2007         while ((xtal/max_prediv) >= fcp_min)
2008                 max_prediv++;
2009
2010         max_prediv--;
2011         min_prediv = max_prediv;
2012         while ((xtal/min_prediv) <= fcp_max) {
2013                 min_prediv--;
2014                 if (min_prediv == 1)
2015                         break;
2016         }
2017         deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2018
2019         min_prediv = 2;
2020
2021         for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2022                 fcp = xtal / prediv;
2023                 if (fcp > fcp_min && fcp < fcp_max) {
2024                         for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2025                                 fdem = ((xtal/prediv) * loopdiv);
2026                                 fs   = fdem / 4;
2027                                 /* test min/max system restrictions */
2028
2029                                 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2030                                         spur = 0;
2031                                         /* test fs harmonics positions */
2032                                         for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2033                                                 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)))) {
2034                                                         spur = 1;
2035                                                         break;
2036                                                 }
2037                                         }
2038
2039                                         if (!spur) {
2040                                                 adc->pll_loopdiv = loopdiv;
2041                                                 adc->pll_prediv = prediv;
2042                                                 adc->timf = 2396745143UL/fdem*(1 << 9);
2043                                                 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2044                                                 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2045                                                 break;
2046                                         }
2047                                 }
2048                         }
2049                 }
2050                 if (!spur)
2051                         break;
2052         }
2053
2054
2055         if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2056                 return -EINVAL;
2057         else
2058                 return 0;
2059 }
2060
2061 static int dib7090_agc_startup(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
2062 {
2063         struct dvb_usb_adapter *adap = fe->dvb->priv;
2064         struct dib0700_adapter_state *state = adap->priv;
2065         struct dibx000_bandwidth_config pll;
2066         u16 target;
2067         struct dib7090p_best_adc adc;
2068         int ret;
2069
2070         ret = state->set_param_save(fe, fep);
2071         if (ret < 0)
2072                 return ret;
2073
2074         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2075         dib0090_pwm_gain_reset(fe);
2076         target = (dib0090_get_wbd_offset(fe) * 8 + 1) / 2;
2077         dib7000p_set_wbd_ref(fe, target);
2078
2079         if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2080                 pll.pll_ratio  = adc.pll_loopdiv;
2081                 pll.pll_prediv = adc.pll_prediv;
2082
2083                 dib7000p_update_pll(fe, &pll);
2084                 dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2085         }
2086         return 0;
2087 }
2088
2089 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2090         { 380,   81, 850, 64, 540,  4},
2091         { 860,   51, 866, 21,  375, 4},
2092         {1700,    0, 250, 0,   100, 6},
2093         {2600,    0, 250, 0,   100, 6},
2094         { 0xFFFF, 0,   0, 0,   0,   0},
2095 };
2096
2097 struct dibx000_agc_config dib7090_agc_config[2] = {
2098         {
2099                 .band_caps      = BAND_UHF,
2100                 /* 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,
2101                 * 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 */
2102                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2103
2104                 .inv_gain       = 687,
2105                 .time_stabiliz  = 10,
2106
2107                 .alpha_level    = 0,
2108                 .thlock         = 118,
2109
2110                 .wbd_inv        = 0,
2111                 .wbd_ref        = 1200,
2112                 .wbd_sel        = 3,
2113                 .wbd_alpha      = 5,
2114
2115                 .agc1_max       = 65535,
2116                 .agc1_min       = 0,
2117
2118                 .agc2_max       = 65535,
2119                 .agc2_min       = 0,
2120
2121                 .agc1_pt1       = 0,
2122                 .agc1_pt2       = 32,
2123                 .agc1_pt3       = 114,
2124                 .agc1_slope1    = 143,
2125                 .agc1_slope2    = 144,
2126                 .agc2_pt1       = 114,
2127                 .agc2_pt2       = 227,
2128                 .agc2_slope1    = 116,
2129                 .agc2_slope2    = 117,
2130
2131                 .alpha_mant     = 18,
2132                 .alpha_exp      = 0,
2133                 .beta_mant      = 20,
2134                 .beta_exp       = 59,
2135
2136                 .perform_agc_softsplit = 0,
2137         } , {
2138                 .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
2139                 /* 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,
2140                 * 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 */
2141                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2142
2143                 .inv_gain       = 732,
2144                 .time_stabiliz  = 10,
2145
2146                 .alpha_level    = 0,
2147                 .thlock         = 118,
2148
2149                 .wbd_inv        = 0,
2150                 .wbd_ref        = 1200,
2151                 .wbd_sel        = 3,
2152                 .wbd_alpha      = 5,
2153
2154                 .agc1_max       = 65535,
2155                 .agc1_min       = 0,
2156
2157                 .agc2_max       = 65535,
2158                 .agc2_min       = 0,
2159
2160                 .agc1_pt1       = 0,
2161                 .agc1_pt2       = 0,
2162                 .agc1_pt3       = 98,
2163                 .agc1_slope1    = 0,
2164                 .agc1_slope2    = 167,
2165                 .agc2_pt1       = 98,
2166                 .agc2_pt2       = 255,
2167                 .agc2_slope1    = 104,
2168                 .agc2_slope2    = 0,
2169
2170                 .alpha_mant     = 18,
2171                 .alpha_exp      = 0,
2172                 .beta_mant      = 20,
2173                 .beta_exp       = 59,
2174
2175                 .perform_agc_softsplit = 0,
2176         }
2177 };
2178
2179 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2180         60000, 15000,
2181         1, 5, 0, 0, 0,
2182         0, 0, 1, 1, 2,
2183         (3 << 14) | (1 << 12) | (524 << 0),
2184         (0 << 25) | 0,
2185         20452225,
2186         15000000,
2187 };
2188
2189 static struct dib7000p_config nim7090_dib7000p_config = {
2190         .output_mpeg2_in_188_bytes  = 1,
2191         .hostbus_diversity                      = 1,
2192         .tuner_is_baseband                      = 1,
2193         .update_lna                                     = NULL,
2194
2195         .agc_config_count                       = 2,
2196         .agc                                            = dib7090_agc_config,
2197
2198         .bw                                                     = &dib7090_clock_config_12_mhz,
2199
2200         .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2201         .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2202         .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2203
2204         .pwm_freq_div                           = 0,
2205
2206         .agc_control                            = dib7090_agc_restart,
2207
2208         .spur_protect                           = 0,
2209         .disable_sample_and_hold        = 0,
2210         .enable_current_mirror          = 0,
2211         .diversity_delay                        = 0,
2212
2213         .output_mode                            = OUTMODE_MPEG2_FIFO,
2214         .enMpegOutput                           = 1,
2215 };
2216
2217 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2218         {
2219                 .output_mpeg2_in_188_bytes  = 1,
2220                 .hostbus_diversity                      = 1,
2221                 .tuner_is_baseband                      = 1,
2222                 .update_lna                                     = NULL,
2223
2224                 .agc_config_count                       = 2,
2225                 .agc                                            = dib7090_agc_config,
2226
2227                 .bw                                                     = &dib7090_clock_config_12_mhz,
2228
2229                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2230                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2231                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2232
2233                 .pwm_freq_div                           = 0,
2234
2235                 .agc_control                            = dib7090_agc_restart,
2236
2237                 .spur_protect                           = 0,
2238                 .disable_sample_and_hold        = 0,
2239                 .enable_current_mirror          = 0,
2240                 .diversity_delay                        = 0,
2241
2242                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2243                 .default_i2c_addr                       = 0x90,
2244                 .enMpegOutput                           = 1,
2245         }, {
2246                 .output_mpeg2_in_188_bytes  = 1,
2247                 .hostbus_diversity                      = 1,
2248                 .tuner_is_baseband                      = 1,
2249                 .update_lna                                     = NULL,
2250
2251                 .agc_config_count                       = 2,
2252                 .agc                                            = dib7090_agc_config,
2253
2254                 .bw                                                     = &dib7090_clock_config_12_mhz,
2255
2256                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2257                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2258                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2259
2260                 .pwm_freq_div                           = 0,
2261
2262                 .agc_control                            = dib7090_agc_restart,
2263
2264                 .spur_protect                           = 0,
2265                 .disable_sample_and_hold        = 0,
2266                 .enable_current_mirror          = 0,
2267                 .diversity_delay                        = 0,
2268
2269                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2270                 .default_i2c_addr                       = 0x92,
2271                 .enMpegOutput                           = 0,
2272         }
2273 };
2274
2275 static const struct dib0090_config nim7090_dib0090_config = {
2276         .io.clock_khz = 12000,
2277         .io.pll_bypass = 0,
2278         .io.pll_range = 0,
2279         .io.pll_prediv = 3,
2280         .io.pll_loopdiv = 6,
2281         .io.adc_clock_ratio = 0,
2282         .io.pll_int_loop_filt = 0,
2283         .reset = dib7090_tuner_sleep,
2284         .sleep = dib7090_tuner_sleep,
2285
2286         .freq_offset_khz_uhf = 0,
2287         .freq_offset_khz_vhf = 0,
2288
2289         .get_adc_power = dib7090_get_adc_power,
2290
2291         .clkouttobamse = 1,
2292         .analog_output = 0,
2293
2294         .wbd_vhf_offset = 0,
2295         .wbd_cband_offset = 0,
2296         .use_pwm_agc = 1,
2297         .clkoutdrive = 0,
2298
2299         .fref_clock_ratio = 0,
2300
2301         .wbd = dib7090_wbd_table,
2302
2303         .ls_cfg_pad_drv = 0,
2304         .data_tx_drv = 0,
2305         .low_if = NULL,
2306         .in_soc = 1,
2307 };
2308
2309 static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2310         {
2311                 .io.clock_khz = 12000,
2312                 .io.pll_bypass = 0,
2313                 .io.pll_range = 0,
2314                 .io.pll_prediv = 3,
2315                 .io.pll_loopdiv = 6,
2316                 .io.adc_clock_ratio = 0,
2317                 .io.pll_int_loop_filt = 0,
2318                 .reset = dib7090_tuner_sleep,
2319                 .sleep = dib7090_tuner_sleep,
2320
2321                 .freq_offset_khz_uhf = 50,
2322                 .freq_offset_khz_vhf = 70,
2323
2324                 .get_adc_power = dib7090_get_adc_power,
2325
2326                 .clkouttobamse = 1,
2327                 .analog_output = 0,
2328
2329                 .wbd_vhf_offset = 0,
2330                 .wbd_cband_offset = 0,
2331                 .use_pwm_agc = 1,
2332                 .clkoutdrive = 0,
2333
2334                 .fref_clock_ratio = 0,
2335
2336                 .wbd = dib7090_wbd_table,
2337
2338                 .ls_cfg_pad_drv = 0,
2339                 .data_tx_drv = 0,
2340                 .low_if = NULL,
2341                 .in_soc = 1,
2342         }, {
2343                 .io.clock_khz = 12000,
2344                 .io.pll_bypass = 0,
2345                 .io.pll_range = 0,
2346                 .io.pll_prediv = 3,
2347                 .io.pll_loopdiv = 6,
2348                 .io.adc_clock_ratio = 0,
2349                 .io.pll_int_loop_filt = 0,
2350                 .reset = dib7090_tuner_sleep,
2351                 .sleep = dib7090_tuner_sleep,
2352
2353                 .freq_offset_khz_uhf = -50,
2354                 .freq_offset_khz_vhf = -70,
2355
2356                 .get_adc_power = dib7090_get_adc_power,
2357
2358                 .clkouttobamse = 1,
2359                 .analog_output = 0,
2360
2361                 .wbd_vhf_offset = 0,
2362                 .wbd_cband_offset = 0,
2363                 .use_pwm_agc = 1,
2364                 .clkoutdrive = 0,
2365
2366                 .fref_clock_ratio = 0,
2367
2368                 .wbd = dib7090_wbd_table,
2369
2370                 .ls_cfg_pad_drv = 0,
2371                 .data_tx_drv = 0,
2372                 .low_if = NULL,
2373                 .in_soc = 1,
2374         }
2375 };
2376
2377 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
2378 {
2379         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2380         msleep(20);
2381         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2382         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2383         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2384         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2385
2386         msleep(20);
2387         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2388         msleep(20);
2389         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2390
2391         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
2392                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
2393                 return -ENODEV;
2394         }
2395         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
2396
2397         return adap->fe == NULL ?  -ENODEV : 0;
2398 }
2399
2400 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
2401 {
2402         struct dib0700_adapter_state *st = adap->priv;
2403         struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
2404
2405         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &nim7090_dib0090_config) == NULL)
2406                 return -ENODEV;
2407
2408         dib7000p_set_gpio(adap->fe, 8, 0, 1);
2409
2410         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
2411         adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2412         return 0;
2413 }
2414
2415 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
2416 {
2417         struct dib0700_state *st = adap->dev->priv;
2418
2419         /* The TFE7090 requires the dib0700 to not be in master mode */
2420         st->disable_streaming_master_mode = 1;
2421
2422         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2423         msleep(20);
2424         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2425         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2426         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2427         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2428
2429         msleep(20);
2430         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2431         msleep(20);
2432         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2433
2434         /* initialize IC 0 */
2435         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
2436                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
2437                 return -ENODEV;
2438         }
2439
2440         dib0700_set_i2c_speed(adap->dev, 340);
2441         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
2442
2443         if (adap->fe == NULL)
2444                 return -ENODEV;
2445
2446         dib7090_slave_reset(adap->fe);
2447
2448         return 0;
2449 }
2450
2451 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
2452 {
2453         struct i2c_adapter *i2c;
2454
2455         if (adap->dev->adapter[0].fe == NULL) {
2456                 err("the master dib7090 has to be initialized first");
2457                 return -ENODEV; /* the master device has not been initialized */
2458         }
2459
2460         i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
2461         if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
2462                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
2463                 return -ENODEV;
2464         }
2465
2466         adap->fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
2467         dib0700_set_i2c_speed(adap->dev, 200);
2468
2469         return adap->fe == NULL ? -ENODEV : 0;
2470 }
2471
2472 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
2473 {
2474         struct dib0700_adapter_state *st = adap->priv;
2475         struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
2476
2477         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
2478                 return -ENODEV;
2479
2480         dib7000p_set_gpio(adap->fe, 8, 0, 1);
2481
2482         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
2483         adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2484         return 0;
2485 }
2486
2487 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
2488 {
2489         struct dib0700_adapter_state *st = adap->priv;
2490         struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
2491
2492         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
2493                 return -ENODEV;
2494
2495         dib7000p_set_gpio(adap->fe, 8, 0, 1);
2496
2497         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
2498         adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2499         return 0;
2500 }
2501
2502 /* STK7070PD */
2503 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
2504         {
2505                 .output_mpeg2_in_188_bytes = 1,
2506
2507                 .agc_config_count = 1,
2508                 .agc = &dib7070_agc_config,
2509                 .bw  = &dib7070_bw_config_12_mhz,
2510                 .tuner_is_baseband = 1,
2511                 .spur_protect = 1,
2512
2513                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2514                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2515                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2516
2517                 .hostbus_diversity = 1,
2518         }, {
2519                 .output_mpeg2_in_188_bytes = 1,
2520
2521                 .agc_config_count = 1,
2522                 .agc = &dib7070_agc_config,
2523                 .bw  = &dib7070_bw_config_12_mhz,
2524                 .tuner_is_baseband = 1,
2525                 .spur_protect = 1,
2526
2527                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2528                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2529                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2530
2531                 .hostbus_diversity = 1,
2532         }
2533 };
2534
2535 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
2536 {
2537         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2538         msleep(10);
2539         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2540         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2541         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2542         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2543
2544         dib0700_ctrl_clock(adap->dev, 72, 1);
2545
2546         msleep(10);
2547         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2548         msleep(10);
2549         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2550
2551         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
2552                                      stk7070pd_dib7000p_config) != 0) {
2553                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
2554                     __func__);
2555                 return -ENODEV;
2556         }
2557
2558         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
2559         return adap->fe == NULL ? -ENODEV : 0;
2560 }
2561
2562 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
2563 {
2564         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
2565         return adap->fe == NULL ? -ENODEV : 0;
2566 }
2567
2568 /* S5H1411 */
2569 static struct s5h1411_config pinnacle_801e_config = {
2570         .output_mode   = S5H1411_PARALLEL_OUTPUT,
2571         .gpio          = S5H1411_GPIO_OFF,
2572         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
2573         .qam_if        = S5H1411_IF_44000,
2574         .vsb_if        = S5H1411_IF_44000,
2575         .inversion     = S5H1411_INVERSION_OFF,
2576         .status_mode   = S5H1411_DEMODLOCKING
2577 };
2578
2579 /* Pinnacle PCTV HD Pro 801e GPIOs map:
2580    GPIO0  - currently unknown
2581    GPIO1  - xc5000 tuner reset
2582    GPIO2  - CX25843 sleep
2583    GPIO3  - currently unknown
2584    GPIO4  - currently unknown
2585    GPIO6  - currently unknown
2586    GPIO7  - currently unknown
2587    GPIO9  - currently unknown
2588    GPIO10 - CX25843 reset
2589  */
2590 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
2591 {
2592         struct dib0700_state *st = adap->dev->priv;
2593
2594         /* Make use of the new i2c functions from FW 1.20 */
2595         st->fw_use_new_i2c_api = 1;
2596
2597         /* The s5h1411 requires the dib0700 to not be in master mode */
2598         st->disable_streaming_master_mode = 1;
2599
2600         /* All msleep values taken from Windows USB trace */
2601         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
2602         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
2603         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2604         msleep(400);
2605         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2606         msleep(60);
2607         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2608         msleep(30);
2609         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2610         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2611         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2612         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2613         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
2614         msleep(30);
2615
2616         /* Put the CX25843 to sleep for now since we're in digital mode */
2617         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
2618
2619         /* GPIOs are initialized, do the attach */
2620         adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
2621                               &adap->dev->i2c_adap);
2622         return adap->fe == NULL ? -ENODEV : 0;
2623 }
2624
2625 static int dib0700_xc5000_tuner_callback(void *priv, int component,
2626                                          int command, int arg)
2627 {
2628         struct dvb_usb_adapter *adap = priv;
2629
2630         if (command == XC5000_TUNER_RESET) {
2631                 /* Reset the tuner */
2632                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
2633                 msleep(10);
2634                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
2635                 msleep(10);
2636         } else {
2637                 err("xc5000: unknown tuner callback command: %d\n", command);
2638                 return -EINVAL;
2639         }
2640
2641         return 0;
2642 }
2643
2644 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
2645         .i2c_address      = 0x64,
2646         .if_khz           = 5380,
2647 };
2648
2649 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
2650 {
2651         /* FIXME: generalize & move to common area */
2652         adap->fe->callback = dib0700_xc5000_tuner_callback;
2653
2654         return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
2655                           &s5h1411_xc5000_tunerconfig)
2656                 == NULL ? -ENODEV : 0;
2657 }
2658
2659 static struct lgdt3305_config hcw_lgdt3305_config = {
2660         .i2c_addr           = 0x0e,
2661         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
2662         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
2663         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
2664         .deny_i2c_rptr      = 0,
2665         .spectral_inversion = 1,
2666         .qam_if_khz         = 6000,
2667         .vsb_if_khz         = 6000,
2668         .usref_8vsb         = 0x0500,
2669 };
2670
2671 static struct mxl5007t_config hcw_mxl5007t_config = {
2672         .xtal_freq_hz = MxL_XTAL_25_MHZ,
2673         .if_freq_hz = MxL_IF_6_MHZ,
2674         .invert_if = 1,
2675 };
2676
2677 /* TIGER-ATSC map:
2678    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
2679    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
2680    GPIO4  - SCL2
2681    GPIO6  - EN_TUNER
2682    GPIO7  - SDA2
2683    GPIO10 - DEM_RST
2684
2685    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
2686  */
2687 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
2688 {
2689         struct dib0700_state *st = adap->dev->priv;
2690
2691         /* Make use of the new i2c functions from FW 1.20 */
2692         st->fw_use_new_i2c_api = 1;
2693
2694         st->disable_streaming_master_mode = 1;
2695
2696         /* fe power enable */
2697         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
2698         msleep(30);
2699         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2700         msleep(30);
2701
2702         /* demod reset */
2703         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2704         msleep(30);
2705         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2706         msleep(30);
2707         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2708         msleep(30);
2709
2710         adap->fe = dvb_attach(lgdt3305_attach,
2711                               &hcw_lgdt3305_config,
2712                               &adap->dev->i2c_adap);
2713
2714         return adap->fe == NULL ? -ENODEV : 0;
2715 }
2716
2717 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
2718 {
2719         return dvb_attach(mxl5007t_attach, adap->fe,
2720                           &adap->dev->i2c_adap, 0x60,
2721                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
2722 }
2723
2724
2725 /* DVB-USB and USB stuff follows */
2726 struct usb_device_id dib0700_usb_id_table[] = {
2727 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
2728         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
2729         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
2730         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
2731         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
2732 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
2733         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
2734         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
2735         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
2736         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
2737 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
2738         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
2739         { USB_DEVICE(USB_VID_TERRATEC,
2740                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
2741         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
2742         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
2743 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
2744         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
2745         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
2746         { USB_DEVICE(USB_VID_PINNACLE,
2747                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
2748         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
2749 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
2750         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
2751         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
2752         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
2753         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
2754 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
2755         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
2756         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
2757         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
2758         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
2759 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
2760         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
2761         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
2762         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
2763         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
2764 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
2765         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
2766         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
2767         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
2768         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
2769 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
2770         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
2771         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
2772         { USB_DEVICE(USB_VID_TERRATEC,
2773                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
2774         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
2775 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
2776         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
2777         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
2778         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
2779         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
2780 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
2781         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
2782         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
2783         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
2784         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
2785 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
2786         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
2787         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
2788         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
2789         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
2790 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
2791         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
2792         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
2793         { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
2794         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
2795 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
2796         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
2797         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
2798         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
2799         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090M) },
2800 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM8096MD) },
2801         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090MD) },
2802         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM7090) },
2803         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7090PVR) },
2804         { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
2805         { 0 }           /* Terminating entry */
2806 };
2807 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
2808
2809 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
2810         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
2811         .usb_ctrl          = DEVICE_SPECIFIC, \
2812         .firmware          = "dvb-usb-dib0700-1.20.fw", \
2813         .download_firmware = dib0700_download_firmware, \
2814         .no_reconnect      = 1, \
2815         .size_of_priv      = sizeof(struct dib0700_state), \
2816         .i2c_algo          = &dib0700_i2c_algo, \
2817         .identify_state    = dib0700_identify_state
2818
2819 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
2820         .streaming_ctrl   = dib0700_streaming_ctrl, \
2821         .stream = { \
2822                 .type = USB_BULK, \
2823                 .count = 4, \
2824                 .endpoint = ep, \
2825                 .u = { \
2826                         .bulk = { \
2827                                 .buffersize = 39480, \
2828                         } \
2829                 } \
2830         }
2831
2832 struct dvb_usb_device_properties dib0700_devices[] = {
2833         {
2834                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
2835
2836                 .num_adapters = 1,
2837                 .adapter = {
2838                         {
2839                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2840                                 .pid_filter_count = 32,
2841                                 .pid_filter       = stk7700p_pid_filter,
2842                                 .pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
2843                                 .frontend_attach  = stk7700p_frontend_attach,
2844                                 .tuner_attach     = stk7700p_tuner_attach,
2845
2846                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2847                         },
2848                 },
2849
2850                 .num_device_descs = 8,
2851                 .devices = {
2852                         {   "DiBcom STK7700P reference design",
2853                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
2854                                 { NULL },
2855                         },
2856                         {   "Hauppauge Nova-T Stick",
2857                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
2858                                 { NULL },
2859                         },
2860                         {   "AVerMedia AVerTV DVB-T Volar",
2861                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
2862                                 { NULL },
2863                         },
2864                         {   "Compro Videomate U500",
2865                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
2866                                 { NULL },
2867                         },
2868                         {   "Uniwill STK7700P based (Hama and others)",
2869                                 { &dib0700_usb_id_table[7], NULL },
2870                                 { NULL },
2871                         },
2872                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
2873                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
2874                                 { NULL },
2875                         },
2876                         {   "AVerMedia AVerTV DVB-T Express",
2877                                 { &dib0700_usb_id_table[20] },
2878                                 { NULL },
2879                         },
2880                         {   "Gigabyte U7000",
2881                                 { &dib0700_usb_id_table[21], NULL },
2882                                 { NULL },
2883                         }
2884                 },
2885
2886                 .rc.core = {
2887                         .rc_interval      = DEFAULT_RC_INTERVAL,
2888                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2889                         .rc_query         = dib0700_rc_query_old_firmware,
2890                         .allowed_protos   = RC_TYPE_RC5 |
2891                                             RC_TYPE_RC6 |
2892                                             RC_TYPE_NEC,
2893                         .change_protocol  = dib0700_change_protocol,
2894                 },
2895         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2896
2897                 .num_adapters = 2,
2898                 .adapter = {
2899                         {
2900                                 .frontend_attach  = bristol_frontend_attach,
2901                                 .tuner_attach     = bristol_tuner_attach,
2902
2903                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2904                         }, {
2905                                 .frontend_attach  = bristol_frontend_attach,
2906                                 .tuner_attach     = bristol_tuner_attach,
2907
2908                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2909                         }
2910                 },
2911
2912                 .num_device_descs = 1,
2913                 .devices = {
2914                         {   "Hauppauge Nova-T 500 Dual DVB-T",
2915                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
2916                                 { NULL },
2917                         },
2918                 },
2919
2920                 .rc.core = {
2921                         .rc_interval      = DEFAULT_RC_INTERVAL,
2922                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2923                         .rc_query         = dib0700_rc_query_old_firmware,
2924                         .allowed_protos   = RC_TYPE_RC5 |
2925                                             RC_TYPE_RC6 |
2926                                             RC_TYPE_NEC,
2927                         .change_protocol = dib0700_change_protocol,
2928                 },
2929         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2930
2931                 .num_adapters = 2,
2932                 .adapter = {
2933                         {
2934                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2935                                 .pid_filter_count = 32,
2936                                 .pid_filter       = stk70x0p_pid_filter,
2937                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2938                                 .frontend_attach  = stk7700d_frontend_attach,
2939                                 .tuner_attach     = stk7700d_tuner_attach,
2940
2941                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2942                         }, {
2943                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2944                                 .pid_filter_count = 32,
2945                                 .pid_filter       = stk70x0p_pid_filter,
2946                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2947                                 .frontend_attach  = stk7700d_frontend_attach,
2948                                 .tuner_attach     = stk7700d_tuner_attach,
2949
2950                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2951                         }
2952                 },
2953
2954                 .num_device_descs = 5,
2955                 .devices = {
2956                         {   "Pinnacle PCTV 2000e",
2957                                 { &dib0700_usb_id_table[11], NULL },
2958                                 { NULL },
2959                         },
2960                         {   "Terratec Cinergy DT XS Diversity",
2961                                 { &dib0700_usb_id_table[12], NULL },
2962                                 { NULL },
2963                         },
2964                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
2965                                 { &dib0700_usb_id_table[13], NULL },
2966                                 { NULL },
2967                         },
2968                         {   "DiBcom STK7700D reference design",
2969                                 { &dib0700_usb_id_table[14], NULL },
2970                                 { NULL },
2971                         },
2972                         {   "YUAN High-Tech DiBcom STK7700D",
2973                                 { &dib0700_usb_id_table[55], NULL },
2974                                 { NULL },
2975                         },
2976
2977                 },
2978
2979                 .rc.core = {
2980                         .rc_interval      = DEFAULT_RC_INTERVAL,
2981                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2982                         .rc_query         = dib0700_rc_query_old_firmware,
2983                         .allowed_protos   = RC_TYPE_RC5 |
2984                                             RC_TYPE_RC6 |
2985                                             RC_TYPE_NEC,
2986                         .change_protocol = dib0700_change_protocol,
2987                 },
2988         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2989
2990                 .num_adapters = 1,
2991                 .adapter = {
2992                         {
2993                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2994                                 .pid_filter_count = 32,
2995                                 .pid_filter       = stk70x0p_pid_filter,
2996                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2997                                 .frontend_attach  = stk7700P2_frontend_attach,
2998                                 .tuner_attach     = stk7700d_tuner_attach,
2999
3000                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3001                         },
3002                 },
3003
3004                 .num_device_descs = 3,
3005                 .devices = {
3006                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
3007                                 { &dib0700_usb_id_table[23], NULL },
3008                                 { NULL },
3009                         },
3010                         {   "Yuan EC372S",
3011                                 { &dib0700_usb_id_table[31], NULL },
3012                                 { NULL },
3013                         },
3014                         {   "Terratec Cinergy T Express",
3015                                 { &dib0700_usb_id_table[42], NULL },
3016                                 { NULL },
3017                         }
3018                 },
3019
3020                 .rc.core = {
3021                         .rc_interval      = DEFAULT_RC_INTERVAL,
3022                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3023                         .module_name      = "dib0700",
3024                         .rc_query         = dib0700_rc_query_old_firmware,
3025                         .allowed_protos   = RC_TYPE_RC5 |
3026                                             RC_TYPE_RC6 |
3027                                             RC_TYPE_NEC,
3028                         .change_protocol = dib0700_change_protocol,
3029                 },
3030         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3031
3032                 .num_adapters = 1,
3033                 .adapter = {
3034                         {
3035                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3036                                 .pid_filter_count = 32,
3037                                 .pid_filter       = stk70x0p_pid_filter,
3038                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3039                                 .frontend_attach  = stk7070p_frontend_attach,
3040                                 .tuner_attach     = dib7070p_tuner_attach,
3041
3042                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3043
3044                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3045                         },
3046                 },
3047
3048                 .num_device_descs = 11,
3049                 .devices = {
3050                         {   "DiBcom STK7070P reference design",
3051                                 { &dib0700_usb_id_table[15], NULL },
3052                                 { NULL },
3053                         },
3054                         {   "Pinnacle PCTV DVB-T Flash Stick",
3055                                 { &dib0700_usb_id_table[16], NULL },
3056                                 { NULL },
3057                         },
3058                         {   "Artec T14BR DVB-T",
3059                                 { &dib0700_usb_id_table[22], NULL },
3060                                 { NULL },
3061                         },
3062                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
3063                                 { &dib0700_usb_id_table[24], NULL },
3064                                 { NULL },
3065                         },
3066                         {   "Hauppauge Nova-T Stick",
3067                                 { &dib0700_usb_id_table[25], NULL },
3068                                 { NULL },
3069                         },
3070                         {   "Hauppauge Nova-T MyTV.t",
3071                                 { &dib0700_usb_id_table[26], NULL },
3072                                 { NULL },
3073                         },
3074                         {   "Pinnacle PCTV 72e",
3075                                 { &dib0700_usb_id_table[29], NULL },
3076                                 { NULL },
3077                         },
3078                         {   "Pinnacle PCTV 73e",
3079                                 { &dib0700_usb_id_table[30], NULL },
3080                                 { NULL },
3081                         },
3082                         {   "Elgato EyeTV DTT",
3083                                 { &dib0700_usb_id_table[49], NULL },
3084                                 { NULL },
3085                         },
3086                         {   "Yuan PD378S",
3087                                 { &dib0700_usb_id_table[45], NULL },
3088                                 { NULL },
3089                         },
3090                         {   "Elgato EyeTV Dtt Dlx PD378S",
3091                                 { &dib0700_usb_id_table[50], NULL },
3092                                 { NULL },
3093                         },
3094                 },
3095
3096                 .rc.core = {
3097                         .rc_interval      = DEFAULT_RC_INTERVAL,
3098                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3099                         .module_name      = "dib0700",
3100                         .rc_query         = dib0700_rc_query_old_firmware,
3101                         .allowed_protos   = RC_TYPE_RC5 |
3102                                             RC_TYPE_RC6 |
3103                                             RC_TYPE_NEC,
3104                         .change_protocol  = dib0700_change_protocol,
3105                 },
3106         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3107
3108                 .num_adapters = 1,
3109                 .adapter = {
3110                         {
3111                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3112                                 .pid_filter_count = 32,
3113                                 .pid_filter       = stk70x0p_pid_filter,
3114                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3115                                 .frontend_attach  = stk7070p_frontend_attach,
3116                                 .tuner_attach     = dib7070p_tuner_attach,
3117
3118                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3119
3120                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3121                         },
3122                 },
3123
3124                 .num_device_descs = 3,
3125                 .devices = {
3126                         {   "Pinnacle PCTV 73A",
3127                                 { &dib0700_usb_id_table[56], NULL },
3128                                 { NULL },
3129                         },
3130                         {   "Pinnacle PCTV 73e SE",
3131                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
3132                                 { NULL },
3133                         },
3134                         {   "Pinnacle PCTV 282e",
3135                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
3136                                 { NULL },
3137                         },
3138                 },
3139
3140                 .rc.core = {
3141                         .rc_interval      = DEFAULT_RC_INTERVAL,
3142                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3143                         .module_name      = "dib0700",
3144                         .rc_query         = dib0700_rc_query_old_firmware,
3145                         .allowed_protos   = RC_TYPE_RC5 |
3146                                             RC_TYPE_RC6 |
3147                                             RC_TYPE_NEC,
3148                         .change_protocol  = dib0700_change_protocol,
3149                 },
3150         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3151
3152                 .num_adapters = 2,
3153                 .adapter = {
3154                         {
3155                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3156                                 .pid_filter_count = 32,
3157                                 .pid_filter       = stk70x0p_pid_filter,
3158                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3159                                 .frontend_attach  = stk7070pd_frontend_attach0,
3160                                 .tuner_attach     = dib7070p_tuner_attach,
3161
3162                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3163
3164                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3165                         }, {
3166                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3167                                 .pid_filter_count = 32,
3168                                 .pid_filter       = stk70x0p_pid_filter,
3169                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3170                                 .frontend_attach  = stk7070pd_frontend_attach1,
3171                                 .tuner_attach     = dib7070p_tuner_attach,
3172
3173                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3174
3175                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3176                         }
3177                 },
3178
3179                 .num_device_descs = 6,
3180                 .devices = {
3181                         {   "DiBcom STK7070PD reference design",
3182                                 { &dib0700_usb_id_table[17], NULL },
3183                                 { NULL },
3184                         },
3185                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
3186                                 { &dib0700_usb_id_table[18], NULL },
3187                                 { NULL },
3188                         },
3189                         {   "Hauppauge Nova-TD Stick (52009)",
3190                                 { &dib0700_usb_id_table[35], NULL },
3191                                 { NULL },
3192                         },
3193                         {   "Hauppauge Nova-TD-500 (84xxx)",
3194                                 { &dib0700_usb_id_table[36], NULL },
3195                                 { NULL },
3196                         },
3197                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
3198                                 { &dib0700_usb_id_table[43],
3199                                         &dib0700_usb_id_table[53], NULL},
3200                                 { NULL },
3201                         },
3202                         {  "Sony PlayTV",
3203                                 { &dib0700_usb_id_table[44], NULL },
3204                                 { NULL },
3205                         },
3206                 },
3207
3208                 .rc.core = {
3209                         .rc_interval      = DEFAULT_RC_INTERVAL,
3210                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3211                         .module_name      = "dib0700",
3212                         .rc_query         = dib0700_rc_query_old_firmware,
3213                         .allowed_protos   = RC_TYPE_RC5 |
3214                                             RC_TYPE_RC6 |
3215                                             RC_TYPE_NEC,
3216                         .change_protocol = dib0700_change_protocol,
3217                 },
3218         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3219
3220                 .num_adapters = 2,
3221                 .adapter = {
3222                         {
3223                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3224                                 .pid_filter_count = 32,
3225                                 .pid_filter       = stk70x0p_pid_filter,
3226                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3227                                 .frontend_attach  = stk7070pd_frontend_attach0,
3228                                 .tuner_attach     = dib7070p_tuner_attach,
3229
3230                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3231
3232                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3233                         }, {
3234                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3235                                 .pid_filter_count = 32,
3236                                 .pid_filter       = stk70x0p_pid_filter,
3237                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3238                                 .frontend_attach  = stk7070pd_frontend_attach1,
3239                                 .tuner_attach     = dib7070p_tuner_attach,
3240
3241                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3242
3243                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3244                         }
3245                 },
3246
3247                 .num_device_descs = 1,
3248                 .devices = {
3249                         {   "Elgato EyeTV Diversity",
3250                                 { &dib0700_usb_id_table[68], NULL },
3251                                 { NULL },
3252                         },
3253                 },
3254
3255                 .rc.core = {
3256                         .rc_interval      = DEFAULT_RC_INTERVAL,
3257                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
3258                         .module_name      = "dib0700",
3259                         .rc_query         = dib0700_rc_query_old_firmware,
3260                         .allowed_protos   = RC_TYPE_RC5 |
3261                                             RC_TYPE_RC6 |
3262                                             RC_TYPE_NEC,
3263                         .change_protocol  = dib0700_change_protocol,
3264                 },
3265         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3266
3267                 .num_adapters = 1,
3268                 .adapter = {
3269                         {
3270                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3271                                 .pid_filter_count = 32,
3272                                 .pid_filter       = stk70x0p_pid_filter,
3273                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3274                                 .frontend_attach  = stk7700ph_frontend_attach,
3275                                 .tuner_attach     = stk7700ph_tuner_attach,
3276
3277                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3278
3279                                 .size_of_priv = sizeof(struct
3280                                                 dib0700_adapter_state),
3281                         },
3282                 },
3283
3284                 .num_device_descs = 9,
3285                 .devices = {
3286                         {   "Terratec Cinergy HT USB XE",
3287                                 { &dib0700_usb_id_table[27], NULL },
3288                                 { NULL },
3289                         },
3290                         {   "Pinnacle Expresscard 320cx",
3291                                 { &dib0700_usb_id_table[28], NULL },
3292                                 { NULL },
3293                         },
3294                         {   "Terratec Cinergy HT Express",
3295                                 { &dib0700_usb_id_table[32], NULL },
3296                                 { NULL },
3297                         },
3298                         {   "Gigabyte U8000-RH",
3299                                 { &dib0700_usb_id_table[37], NULL },
3300                                 { NULL },
3301                         },
3302                         {   "YUAN High-Tech STK7700PH",
3303                                 { &dib0700_usb_id_table[38], NULL },
3304                                 { NULL },
3305                         },
3306                         {   "Asus My Cinema-U3000Hybrid",
3307                                 { &dib0700_usb_id_table[39], NULL },
3308                                 { NULL },
3309                         },
3310                         {   "YUAN High-Tech MC770",
3311                                 { &dib0700_usb_id_table[48], NULL },
3312                                 { NULL },
3313                         },
3314                         {   "Leadtek WinFast DTV Dongle H",
3315                                 { &dib0700_usb_id_table[51], NULL },
3316                                 { NULL },
3317                         },
3318                         {   "YUAN High-Tech STK7700D",
3319                                 { &dib0700_usb_id_table[54], NULL },
3320                                 { NULL },
3321                         },
3322                 },
3323
3324                 .rc.core = {
3325                         .rc_interval      = DEFAULT_RC_INTERVAL,
3326                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3327                         .module_name      = "dib0700",
3328                         .rc_query         = dib0700_rc_query_old_firmware,
3329                         .allowed_protos   = RC_TYPE_RC5 |
3330                                             RC_TYPE_RC6 |
3331                                             RC_TYPE_NEC,
3332                         .change_protocol  = dib0700_change_protocol,
3333                 },
3334         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3335                 .num_adapters = 1,
3336                 .adapter = {
3337                         {
3338                                 .frontend_attach  = s5h1411_frontend_attach,
3339                                 .tuner_attach     = xc5000_tuner_attach,
3340
3341                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3342
3343                                 .size_of_priv = sizeof(struct
3344                                                 dib0700_adapter_state),
3345                         },
3346                 },
3347
3348                 .num_device_descs = 2,
3349                 .devices = {
3350                         {   "Pinnacle PCTV HD Pro USB Stick",
3351                                 { &dib0700_usb_id_table[40], NULL },
3352                                 { NULL },
3353                         },
3354                         {   "Pinnacle PCTV HD USB Stick",
3355                                 { &dib0700_usb_id_table[41], NULL },
3356                                 { NULL },
3357                         },
3358                 },
3359
3360                 .rc.core = {
3361                         .rc_interval      = DEFAULT_RC_INTERVAL,
3362                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3363                         .module_name      = "dib0700",
3364                         .rc_query         = dib0700_rc_query_old_firmware,
3365                         .allowed_protos   = RC_TYPE_RC5 |
3366                                             RC_TYPE_RC6 |
3367                                             RC_TYPE_NEC,
3368                         .change_protocol  = dib0700_change_protocol,
3369                 },
3370         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3371                 .num_adapters = 1,
3372                 .adapter = {
3373                         {
3374                                 .frontend_attach  = lgdt3305_frontend_attach,
3375                                 .tuner_attach     = mxl5007t_tuner_attach,
3376
3377                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3378
3379                                 .size_of_priv = sizeof(struct
3380                                                 dib0700_adapter_state),
3381                         },
3382                 },
3383
3384                 .num_device_descs = 2,
3385                 .devices = {
3386                         {   "Hauppauge ATSC MiniCard (B200)",
3387                                 { &dib0700_usb_id_table[46], NULL },
3388                                 { NULL },
3389                         },
3390                         {   "Hauppauge ATSC MiniCard (B210)",
3391                                 { &dib0700_usb_id_table[47], NULL },
3392                                 { NULL },
3393                         },
3394                 },
3395         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3396
3397                 .num_adapters = 1,
3398                 .adapter = {
3399                         {
3400                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3401                                 .pid_filter_count = 32,
3402                                 .pid_filter       = stk70x0p_pid_filter,
3403                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3404                                 .frontend_attach  = stk7770p_frontend_attach,
3405                                 .tuner_attach     = dib7770p_tuner_attach,
3406
3407                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3408
3409                                 .size_of_priv =
3410                                         sizeof(struct dib0700_adapter_state),
3411                         },
3412                 },
3413
3414                 .num_device_descs = 3,
3415                 .devices = {
3416                         {   "DiBcom STK7770P reference design",
3417                                 { &dib0700_usb_id_table[59], NULL },
3418                                 { NULL },
3419                         },
3420                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
3421                                 { &dib0700_usb_id_table[33],
3422                                         &dib0700_usb_id_table[52],
3423                                         &dib0700_usb_id_table[60], NULL},
3424                                 { NULL },
3425                         },
3426                         {   "TechniSat AirStar TeleStick 2",
3427                                 { &dib0700_usb_id_table[74], NULL },
3428                                 { NULL },
3429                         },
3430                 },
3431
3432                 .rc.core = {
3433                         .rc_interval      = DEFAULT_RC_INTERVAL,
3434                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3435                         .module_name      = "dib0700",
3436                         .rc_query         = dib0700_rc_query_old_firmware,
3437                         .allowed_protos   = RC_TYPE_RC5 |
3438                                             RC_TYPE_RC6 |
3439                                             RC_TYPE_NEC,
3440                         .change_protocol  = dib0700_change_protocol,
3441                 },
3442         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3443                 .num_adapters = 1,
3444                 .adapter = {
3445                         {
3446                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3447                                 .pid_filter_count = 32,
3448                                 .pid_filter = stk80xx_pid_filter,
3449                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3450                                 .frontend_attach  = stk807x_frontend_attach,
3451                                 .tuner_attach     = dib807x_tuner_attach,
3452
3453                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3454
3455                                 .size_of_priv =
3456                                         sizeof(struct dib0700_adapter_state),
3457                         },
3458                 },
3459
3460                 .num_device_descs = 3,
3461                 .devices = {
3462                         {   "DiBcom STK807xP reference design",
3463                                 { &dib0700_usb_id_table[62], NULL },
3464                                 { NULL },
3465                         },
3466                         {   "Prolink Pixelview SBTVD",
3467                                 { &dib0700_usb_id_table[63], NULL },
3468                                 { NULL },
3469                         },
3470                         {   "EvolutePC TVWay+",
3471                                 { &dib0700_usb_id_table[64], NULL },
3472                                 { NULL },
3473                         },
3474                 },
3475
3476                 .rc.core = {
3477                         .rc_interval      = DEFAULT_RC_INTERVAL,
3478                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
3479                         .module_name      = "dib0700",
3480                         .rc_query         = dib0700_rc_query_old_firmware,
3481                         .allowed_protos   = RC_TYPE_RC5 |
3482                                             RC_TYPE_RC6 |
3483                                             RC_TYPE_NEC,
3484                         .change_protocol  = dib0700_change_protocol,
3485                 },
3486         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3487                 .num_adapters = 2,
3488                 .adapter = {
3489                         {
3490                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3491                                 .pid_filter_count = 32,
3492                                 .pid_filter = stk80xx_pid_filter,
3493                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3494                                 .frontend_attach  = stk807xpvr_frontend_attach0,
3495                                 .tuner_attach     = dib807x_tuner_attach,
3496
3497                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3498
3499                                 .size_of_priv =
3500                                         sizeof(struct dib0700_adapter_state),
3501                         },
3502                         {
3503                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3504                                 .pid_filter_count = 32,
3505                                 .pid_filter = stk80xx_pid_filter,
3506                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3507                                 .frontend_attach  = stk807xpvr_frontend_attach1,
3508                                 .tuner_attach     = dib807x_tuner_attach,
3509
3510                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3511
3512                                 .size_of_priv =
3513                                         sizeof(struct dib0700_adapter_state),
3514                         },
3515                 },
3516
3517                 .num_device_descs = 1,
3518                 .devices = {
3519                         {   "DiBcom STK807xPVR reference design",
3520                                 { &dib0700_usb_id_table[61], NULL },
3521                                 { NULL },
3522                         },
3523                 },
3524
3525                 .rc.core = {
3526                         .rc_interval      = DEFAULT_RC_INTERVAL,
3527                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3528                         .module_name      = "dib0700",
3529                         .rc_query         = dib0700_rc_query_old_firmware,
3530                         .allowed_protos   = RC_TYPE_RC5 |
3531                                             RC_TYPE_RC6 |
3532                                             RC_TYPE_NEC,
3533                         .change_protocol  = dib0700_change_protocol,
3534                 },
3535         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3536                 .num_adapters = 1,
3537                 .adapter = {
3538                         {
3539                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3540                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3541                                 .pid_filter_count = 32,
3542                                 .pid_filter = stk80xx_pid_filter,
3543                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3544                                 .frontend_attach  = stk809x_frontend_attach,
3545                                 .tuner_attach     = dib809x_tuner_attach,
3546
3547                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3548
3549                                 .size_of_priv =
3550                                         sizeof(struct dib0700_adapter_state),
3551                         },
3552                 },
3553
3554                 .num_device_descs = 1,
3555                 .devices = {
3556                         {   "DiBcom STK8096GP reference design",
3557                                 { &dib0700_usb_id_table[67], NULL },
3558                                 { NULL },
3559                         },
3560                 },
3561
3562                 .rc.core = {
3563                         .rc_interval      = DEFAULT_RC_INTERVAL,
3564                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3565                         .module_name      = "dib0700",
3566                         .rc_query         = dib0700_rc_query_old_firmware,
3567                         .allowed_protos   = RC_TYPE_RC5 |
3568                                             RC_TYPE_RC6 |
3569                                             RC_TYPE_NEC,
3570                         .change_protocol  = dib0700_change_protocol,
3571                 },
3572         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3573                 .num_adapters = 1,
3574                 .adapter = {
3575                         {
3576                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3577                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3578                                 .pid_filter_count = 32,
3579                                 .pid_filter = dib90x0_pid_filter,
3580                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
3581                                 .frontend_attach  = stk9090m_frontend_attach,
3582                                 .tuner_attach     = dib9090_tuner_attach,
3583
3584                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3585
3586                                 .size_of_priv =
3587                                         sizeof(struct dib0700_adapter_state),
3588                         },
3589                 },
3590
3591                 .num_device_descs = 1,
3592                 .devices = {
3593                         {   "DiBcom STK9090M reference design",
3594                                 { &dib0700_usb_id_table[69], NULL },
3595                                 { NULL },
3596                         },
3597                 },
3598
3599                 .rc.core = {
3600                         .rc_interval      = DEFAULT_RC_INTERVAL,
3601                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3602                         .module_name      = "dib0700",
3603                         .rc_query         = dib0700_rc_query_old_firmware,
3604                         .allowed_protos   = RC_TYPE_RC5 |
3605                                             RC_TYPE_RC6 |
3606                                             RC_TYPE_NEC,
3607                         .change_protocol  = dib0700_change_protocol,
3608                 },
3609         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3610                 .num_adapters = 1,
3611                 .adapter = {
3612                         {
3613                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3614                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3615                                 .pid_filter_count = 32,
3616                                 .pid_filter = stk80xx_pid_filter,
3617                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3618                                 .frontend_attach  = nim8096md_frontend_attach,
3619                                 .tuner_attach     = nim8096md_tuner_attach,
3620
3621                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3622
3623                                 .size_of_priv =
3624                                         sizeof(struct dib0700_adapter_state),
3625                         },
3626                 },
3627
3628                 .num_device_descs = 1,
3629                 .devices = {
3630                         {   "DiBcom NIM8096MD reference design",
3631                                 { &dib0700_usb_id_table[70], NULL },
3632                                 { NULL },
3633                         },
3634                 },
3635
3636                 .rc.core = {
3637                         .rc_interval      = DEFAULT_RC_INTERVAL,
3638                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3639                         .module_name      = "dib0700",
3640                         .rc_query         = dib0700_rc_query_old_firmware,
3641                         .allowed_protos   = RC_TYPE_RC5 |
3642                                             RC_TYPE_RC6 |
3643                                             RC_TYPE_NEC,
3644                         .change_protocol  = dib0700_change_protocol,
3645                 },
3646         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3647                 .num_adapters = 1,
3648                 .adapter = {
3649                         {
3650                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3651                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3652                                 .pid_filter_count = 32,
3653                                 .pid_filter = dib90x0_pid_filter,
3654                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
3655                                 .frontend_attach  = nim9090md_frontend_attach,
3656                                 .tuner_attach     = nim9090md_tuner_attach,
3657
3658                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3659
3660                                 .size_of_priv =
3661                                         sizeof(struct dib0700_adapter_state),
3662                         },
3663                 },
3664
3665                 .num_device_descs = 1,
3666                 .devices = {
3667                         {   "DiBcom NIM9090MD reference design",
3668                                 { &dib0700_usb_id_table[71], NULL },
3669                                 { NULL },
3670                         },
3671                 },
3672
3673                 .rc.core = {
3674                         .rc_interval      = DEFAULT_RC_INTERVAL,
3675                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3676                         .module_name      = "dib0700",
3677                         .rc_query         = dib0700_rc_query_old_firmware,
3678                         .allowed_protos   = RC_TYPE_RC5 |
3679                                             RC_TYPE_RC6 |
3680                                             RC_TYPE_NEC,
3681                         .change_protocol  = dib0700_change_protocol,
3682                 },
3683         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3684                 .num_adapters = 1,
3685                 .adapter = {
3686                         {
3687                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3688                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3689                                 .pid_filter_count = 32,
3690                                 .pid_filter = stk70x0p_pid_filter,
3691                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3692                                 .frontend_attach  = nim7090_frontend_attach,
3693                                 .tuner_attach     = nim7090_tuner_attach,
3694
3695                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3696
3697                                 .size_of_priv =
3698                                         sizeof(struct dib0700_adapter_state),
3699                         },
3700                 },
3701
3702                 .num_device_descs = 1,
3703                 .devices = {
3704                         {   "DiBcom NIM7090 reference design",
3705                                 { &dib0700_usb_id_table[72], NULL },
3706                                 { NULL },
3707                         },
3708                 },
3709
3710                 .rc.core = {
3711                         .rc_interval      = DEFAULT_RC_INTERVAL,
3712                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3713                         .module_name      = "dib0700",
3714                         .rc_query         = dib0700_rc_query_old_firmware,
3715                         .allowed_protos   = RC_TYPE_RC5 |
3716                                             RC_TYPE_RC6 |
3717                                             RC_TYPE_NEC,
3718                         .change_protocol  = dib0700_change_protocol,
3719                 },
3720         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3721                 .num_adapters = 2,
3722                 .adapter = {
3723                         {
3724                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3725                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3726                                 .pid_filter_count = 32,
3727                                 .pid_filter = stk70x0p_pid_filter,
3728                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3729                                 .frontend_attach  = tfe7090pvr_frontend0_attach,
3730                                 .tuner_attach     = tfe7090pvr_tuner0_attach,
3731
3732                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3733
3734                                 .size_of_priv =
3735                                         sizeof(struct dib0700_adapter_state),
3736                         },
3737                         {
3738                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3739                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3740                                 .pid_filter_count = 32,
3741                                 .pid_filter = stk70x0p_pid_filter,
3742                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3743                                 .frontend_attach  = tfe7090pvr_frontend1_attach,
3744                                 .tuner_attach     = tfe7090pvr_tuner1_attach,
3745
3746                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3747
3748                                 .size_of_priv =
3749                                         sizeof(struct dib0700_adapter_state),
3750                         },
3751                 },
3752
3753                 .num_device_descs = 1,
3754                 .devices = {
3755                         {   "DiBcom TFE7090PVR reference design",
3756                                 { &dib0700_usb_id_table[73], NULL },
3757                                 { NULL },
3758                         },
3759                 },
3760
3761                 .rc.core = {
3762                         .rc_interval      = DEFAULT_RC_INTERVAL,
3763                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3764                         .module_name      = "dib0700",
3765                         .rc_query         = dib0700_rc_query_old_firmware,
3766                         .allowed_protos   = RC_TYPE_RC5 |
3767                                             RC_TYPE_RC6 |
3768                                             RC_TYPE_NEC,
3769                         .change_protocol  = dib0700_change_protocol,
3770                 },
3771         },
3772 };
3773
3774 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);