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 "mt2060.h"
  16 #include "mt2266.h"
  17 #include "tuner-xc2028.h"
  18 #include "xc5000.h"
  19 #include "s5h1411.h"
  20 #include "dib0070.h"
  21 #include "dib0090.h"
  22 #include "lgdt3305.h"
  23 #include "mxl5007t.h"
  24
  25 static int force_lna_activation;
  26 module_param(force_lna_activation, int, 0644);
  27 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
  28                 "if applicable for the device (default: 0=automatic/off).");
  29
  30 struct dib0700_adapter_state {
  31         int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
  32 };
  33
  34 /* Hauppauge Nova-T 500 (aka Bristol)
  35  *  has a LNA on GPIO0 which is enabled by setting 1 */
  36 static struct mt2060_config bristol_mt2060_config[2] = {
  37         {
  38                 .i2c_address = 0x60,
  39                 .clock_out   = 3,
  40         }, {
  41                 .i2c_address = 0x61,
  42         }
  43 };
  44
  45
  46 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  47         .band_caps = BAND_VHF | BAND_UHF,
  48         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  49
  50         .agc1_max = 42598,
  51         .agc1_min = 17694,
  52         .agc2_max = 45875,
  53         .agc2_min = 0,
  54
  55         .agc1_pt1 = 0,
  56         .agc1_pt2 = 59,
  57
  58         .agc1_slope1 = 0,
  59         .agc1_slope2 = 69,
  60
  61         .agc2_pt1 = 0,
  62         .agc2_pt2 = 59,
  63
  64         .agc2_slope1 = 111,
  65         .agc2_slope2 = 28,
  66 };
  67
  68 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  69         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  70                 .max_time     = 0x196,
  71                 .ln_adc_level = 0x1cc7,
  72                 .output_mpeg2_in_188_bytes = 1,
  73         },
  74         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  75                 .max_time     = 0x196,
  76                 .ln_adc_level = 0x1cc7,
  77                 .output_mpeg2_in_188_bytes = 1,
  78         }
  79 };
  80
  81 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  82 {
  83         struct dib0700_state *st = adap->dev->priv;
  84         if (adap->id == 0) {
  85                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  86                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  87                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  88                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  89
  90                 if (force_lna_activation)
  91                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  92                 else
  93                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  94
  95                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
  96                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
  97                         return -ENODEV;
  98                 }
  99         }
 100         st->mt2060_if1[adap->id] = 1220;
 101         return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 102                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 103 }
 104
 105 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 106 {
 107         struct i2c_msg msg[2] = {
 108                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 109                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 110         };
 111         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 112         return 0;
 113 }
 114
 115 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 116 {
 117         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 118         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
 119         s8 a;
 120         int if1=1220;
 121         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 122                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 123                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 124         }
 125         return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
 126                 if1) == NULL ? -ENODEV : 0;
 127 }
 128
 129 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 130
 131 /* MT226x */
 132 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 133         {
 134                 BAND_UHF,
 135
 136                 /* 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,
 137                 * 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 */
 138                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 139             | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 140
 141                 1130,
 142                 21,
 143
 144                 0,
 145                 118,
 146
 147                 0,
 148                 3530,
 149                 1,
 150                 0,
 151
 152                 65535,
 153                 33770,
 154                 65535,
 155                 23592,
 156
 157                 0,
 158                 62,
 159                 255,
 160                 64,
 161                 64,
 162                 132,
 163                 192,
 164                 80,
 165                 80,
 166
 167                 17,
 168                 27,
 169                 23,
 170                 51,
 171
 172                 1,
 173         }, {
 174                 BAND_VHF | BAND_LBAND,
 175
 176                 /* 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,
 177                 * 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 */
 178                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 179             | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 180
 181                 2372,
 182                 21,
 183
 184                 0,
 185                 118,
 186
 187                 0,
 188                 3530,
 189                 1,
 190                 0,
 191
 192                 65535,
 193                 0,
 194                 65535,
 195                 23592,
 196
 197                 0,
 198                 128,
 199                 128,
 200                 128,
 201                 0,
 202                 128,
 203                 253,
 204                 81,
 205                 0,
 206
 207                 17,
 208                 27,
 209                 23,
 210                 51,
 211
 212                 1,
 213         }
 214 };
 215
 216 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 217         60000, 30000,
 218         1, 8, 3, 1, 0,
 219         0, 0, 1, 1, 2,
 220         (3 << 14) | (1 << 12) | (524 << 0),
 221         0,
 222         20452225,
 223 };
 224
 225 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 226         {       .output_mpeg2_in_188_bytes = 1,
 227                 .hostbus_diversity = 1,
 228                 .tuner_is_baseband = 1,
 229
 230                 .agc_config_count = 2,
 231                 .agc = stk7700d_7000p_mt2266_agc_config,
 232                 .bw  = &stk7700d_mt2266_pll_config,
 233
 234                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 235                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 236                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 237         },
 238         {       .output_mpeg2_in_188_bytes = 1,
 239                 .hostbus_diversity = 1,
 240                 .tuner_is_baseband = 1,
 241
 242                 .agc_config_count = 2,
 243                 .agc = stk7700d_7000p_mt2266_agc_config,
 244                 .bw  = &stk7700d_mt2266_pll_config,
 245
 246                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 247                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 248                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 249         }
 250 };
 251
 252 static struct mt2266_config stk7700d_mt2266_config[2] = {
 253         {       .i2c_address = 0x60
 254         },
 255         {       .i2c_address = 0x60
 256         }
 257 };
 258
 259 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 260 {
 261         if (adap->id == 0) {
 262                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 263                 msleep(10);
 264                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 265                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 266                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 267                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 268                 msleep(10);
 269                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 270                 msleep(10);
 271                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 272                                              stk7700d_dib7000p_mt2266_config)
 273                     != 0) {
 274                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 275                         return -ENODEV;
 276                 }
 277         }
 278
 279         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 280                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 281
 282         return adap->fe == NULL ? -ENODEV : 0;
 283 }
 284
 285 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 286 {
 287         if (adap->id == 0) {
 288                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 289                 msleep(10);
 290                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 291                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 292                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 293                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 294                 msleep(10);
 295                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 296                 msleep(10);
 297                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 298                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 299                                              stk7700d_dib7000p_mt2266_config)
 300                     != 0) {
 301                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 302                         return -ENODEV;
 303                 }
 304         }
 305
 306         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 307                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 308
 309         return adap->fe == NULL ? -ENODEV : 0;
 310 }
 311
 312 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 313 {
 314         struct i2c_adapter *tun_i2c;
 315         tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 316         return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
 317                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 318 }
 319
 320 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 321 static struct dibx000_agc_config xc3028_agc_config = {
 322         BAND_VHF | BAND_UHF,       /* band_caps */
 323
 324         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 325          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 326          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 327         (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
 328         (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
 329
 330         712,    /* inv_gain */
 331         21,     /* time_stabiliz */
 332
 333         0,      /* alpha_level */
 334         118,    /* thlock */
 335
 336         0,      /* wbd_inv */
 337         2867,   /* wbd_ref */
 338         0,      /* wbd_sel */
 339         2,      /* wbd_alpha */
 340
 341         0,      /* agc1_max */
 342         0,      /* agc1_min */
 343         39718,  /* agc2_max */
 344         9930,   /* agc2_min */
 345         0,      /* agc1_pt1 */
 346         0,      /* agc1_pt2 */
 347         0,      /* agc1_pt3 */
 348         0,      /* agc1_slope1 */
 349         0,      /* agc1_slope2 */
 350         0,      /* agc2_pt1 */
 351         128,    /* agc2_pt2 */
 352         29,     /* agc2_slope1 */
 353         29,     /* agc2_slope2 */
 354
 355         17,     /* alpha_mant */
 356         27,     /* alpha_exp */
 357         23,     /* beta_mant */
 358         51,     /* beta_exp */
 359
 360         1,      /* perform_agc_softsplit */
 361 };
 362
 363 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 364 static struct dibx000_bandwidth_config xc3028_bw_config = {
 365         60000, 30000, /* internal, sampling */
 366         1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
 367         0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
 368                           modulo */
 369         (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 370         (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
 371         20452225, /* timf */
 372         30000000, /* xtal_hz */
 373 };
 374
 375 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 376         .output_mpeg2_in_188_bytes = 1,
 377         .tuner_is_baseband = 1,
 378
 379         .agc_config_count = 1,
 380         .agc = &xc3028_agc_config,
 381         .bw  = &xc3028_bw_config,
 382
 383         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 384         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 385         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 386 };
 387
 388 static int stk7700ph_xc3028_callback(void *ptr, int component,
 389                                      int command, int arg)
 390 {
 391         struct dvb_usb_adapter *adap = ptr;
 392
 393         switch (command) {
 394         case XC2028_TUNER_RESET:
 395                 /* Send the tuner in then out of reset */
 396                 dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
 397                 dib7000p_set_gpio(adap->fe, 8, 0, 1);
 398                 break;
 399         case XC2028_RESET_CLK:
 400                 break;
 401         default:
 402                 err("%s: unknown command %d, arg %d\n", __func__,
 403                         command, arg);
 404                 return -EINVAL;
 405         }
 406         return 0;
 407 }
 408
 409 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
 410         .fname = XC2028_DEFAULT_FIRMWARE,
 411         .max_len = 64,
 412         .demod = XC3028_FE_DIBCOM52,
 413 };
 414
 415 static struct xc2028_config stk7700ph_xc3028_config = {
 416         .i2c_addr = 0x61,
 417         .ctrl = &stk7700ph_xc3028_ctrl,
 418 };
 419
 420 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 421 {
 422         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 423
 424         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 425             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
 426         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 427         else
 428         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 429         msleep(20);
 430         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 431         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 432         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 433         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 434         msleep(10);
 435         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 436         msleep(20);
 437         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 438         msleep(10);
 439
 440         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 441                                      &stk7700ph_dib7700_xc3028_config) != 0) {
 442                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 443                     __func__);
 444                 return -ENODEV;
 445         }
 446
 447         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 448                 &stk7700ph_dib7700_xc3028_config);
 449
 450         return adap->fe == NULL ? -ENODEV : 0;
 451 }
 452
 453 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 454 {
 455         struct i2c_adapter *tun_i2c;
 456
 457         tun_i2c = dib7000p_get_i2c_master(adap->fe,
 458                 DIBX000_I2C_INTERFACE_TUNER, 1);
 459
 460         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
 461
 462         /* FIXME: generalize & move to common area */
 463         adap->fe->callback = stk7700ph_xc3028_callback;
 464
 465         return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
 466                 == NULL ? -ENODEV : 0;
 467 }
 468
 469 #define DEFAULT_RC_INTERVAL 50
 470
 471 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 472
 473 /* Number of keypresses to ignore before start repeating */
 474 #define RC_REPEAT_DELAY 6
 475
 476 static int dib0700_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
 477 {
 478         u8 key[4];
 479         int i;
 480         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
 481         struct dib0700_state *st = d->priv;
 482
 483         *event = 0;
 484         *state = REMOTE_NO_KEY_PRESSED;
 485
 486         if (st->fw_version >= 0x10200) {
 487                 /* For 1.20 firmware , We need to keep the RC polling
 488                    callback so we can reuse the input device setup in
 489                    dvb-usb-remote.c.  However, the actual work is being done
 490                    in the bulk URB completion handler. */
 491                 return 0;
 492         }
 493
 494         i=dib0700_ctrl_rd(d,rc_request,2,key,4);
 495         if (i<=0) {
 496                 err("RC Query Failed");
 497                 return -1;
 498         }
 499
 500         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 501         if (key[0]==0 && key[1]==0 && key[2]==0 && key[3]==0) return 0;
 502
 503         /* 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]);  */
 504
 505         dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
 506
 507         switch (dvb_usb_dib0700_ir_proto) {
 508         case 0: {
 509                 /* NEC protocol sends repeat code as 0 0 0 FF */
 510                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
 511                     (key[3] == 0xFF)) {
 512                         st->rc_counter++;
 513                         if (st->rc_counter > RC_REPEAT_DELAY) {
 514                                 *event = d->last_event;
 515                                 *state = REMOTE_KEY_PRESSED;
 516                                 st->rc_counter = RC_REPEAT_DELAY;
 517                         }
 518                         return 0;
 519                 }
 520                 for (i=0;i<d->props.rc_key_map_size; i++) {
 521                         if (rc5_custom(&keymap[i]) == key[3-2] &&
 522                             rc5_data(&keymap[i]) == key[3-3]) {
 523                                 st->rc_counter = 0;
 524                                 *event = keymap[i].event;
 525                                 *state = REMOTE_KEY_PRESSED;
 526                                 d->last_event = keymap[i].event;
 527                                 return 0;
 528                         }
 529                 }
 530                 break;
 531         }
 532         default: {
 533                 /* RC-5 protocol changes toggle bit on new keypress */
 534                 for (i = 0; i < d->props.rc_key_map_size; i++) {
 535                         if (rc5_custom(&keymap[i]) == key[3-2] &&
 536                             rc5_data(&keymap[i]) == key[3-3]) {
 537                                 if (d->last_event == keymap[i].event &&
 538                                         key[3-1] == st->rc_toggle) {
 539                                         st->rc_counter++;
 540                                         /* prevents unwanted double hits */
 541                                         if (st->rc_counter > RC_REPEAT_DELAY) {
 542                                                 *event = d->last_event;
 543                                                 *state = REMOTE_KEY_PRESSED;
 544                                                 st->rc_counter = RC_REPEAT_DELAY;
 545                                         }
 546
 547                                         return 0;
 548                                 }
 549                                 st->rc_counter = 0;
 550                                 *event = keymap[i].event;
 551                                 *state = REMOTE_KEY_PRESSED;
 552                                 st->rc_toggle = key[3-1];
 553                                 d->last_event = keymap[i].event;
 554                                 return 0;
 555                         }
 556                 }
 557                 break;
 558         }
 559         }
 560         err("Unknown remote controller key: %2X %2X %2X %2X", (int) key[3-2], (int) key[3-3], (int) key[3-1], (int) key[3]);
 561         d->last_event = 0;
 562         return 0;
 563 }
 564
 565 static struct dvb_usb_rc_key dib0700_rc_keys[] = {
 566         /* Key codes for the tiny Pinnacle remote*/
 567         { 0x0700, KEY_MUTE },
 568         { 0x0701, KEY_MENU }, /* Pinnacle logo */
 569         { 0x0739, KEY_POWER },
 570         { 0x0703, KEY_VOLUMEUP },
 571         { 0x0709, KEY_VOLUMEDOWN },
 572         { 0x0706, KEY_CHANNELUP },
 573         { 0x070c, KEY_CHANNELDOWN },
 574         { 0x070f, KEY_1 },
 575         { 0x0715, KEY_2 },
 576         { 0x0710, KEY_3 },
 577         { 0x0718, KEY_4 },
 578         { 0x071b, KEY_5 },
 579         { 0x071e, KEY_6 },
 580         { 0x0711, KEY_7 },
 581         { 0x0721, KEY_8 },
 582         { 0x0712, KEY_9 },
 583         { 0x0727, KEY_0 },
 584         { 0x0724, KEY_SCREEN }, /* 'Square' key */
 585         { 0x072a, KEY_TEXT },   /* 'T' key */
 586         { 0x072d, KEY_REWIND },
 587         { 0x0730, KEY_PLAY },
 588         { 0x0733, KEY_FASTFORWARD },
 589         { 0x0736, KEY_RECORD },
 590         { 0x073c, KEY_STOP },
 591         { 0x073f, KEY_CANCEL }, /* '?' key */
 592         /* Key codes for the Terratec Cinergy DT XS Diversity, similar to cinergyT2.c */
 593         { 0xeb01, KEY_POWER },
 594         { 0xeb02, KEY_1 },
 595         { 0xeb03, KEY_2 },
 596         { 0xeb04, KEY_3 },
 597         { 0xeb05, KEY_4 },
 598         { 0xeb06, KEY_5 },
 599         { 0xeb07, KEY_6 },
 600         { 0xeb08, KEY_7 },
 601         { 0xeb09, KEY_8 },
 602         { 0xeb0a, KEY_9 },
 603         { 0xeb0b, KEY_VIDEO },
 604         { 0xeb0c, KEY_0 },
 605         { 0xeb0d, KEY_REFRESH },
 606         { 0xeb0f, KEY_EPG },
 607         { 0xeb10, KEY_UP },
 608         { 0xeb11, KEY_LEFT },
 609         { 0xeb12, KEY_OK },
 610         { 0xeb13, KEY_RIGHT },
 611         { 0xeb14, KEY_DOWN },
 612         { 0xeb16, KEY_INFO },
 613         { 0xeb17, KEY_RED },
 614         { 0xeb18, KEY_GREEN },
 615         { 0xeb19, KEY_YELLOW },
 616         { 0xeb1a, KEY_BLUE },
 617         { 0xeb1b, KEY_CHANNELUP },
 618         { 0xeb1c, KEY_VOLUMEUP },
 619         { 0xeb1d, KEY_MUTE },
 620         { 0xeb1e, KEY_VOLUMEDOWN },
 621         { 0xeb1f, KEY_CHANNELDOWN },
 622         { 0xeb40, KEY_PAUSE },
 623         { 0xeb41, KEY_HOME },
 624         { 0xeb42, KEY_MENU }, /* DVD Menu */
 625         { 0xeb43, KEY_SUBTITLE },
 626         { 0xeb44, KEY_TEXT }, /* Teletext */
 627         { 0xeb45, KEY_DELETE },
 628         { 0xeb46, KEY_TV },
 629         { 0xeb47, KEY_DVD },
 630         { 0xeb48, KEY_STOP },
 631         { 0xeb49, KEY_VIDEO },
 632         { 0xeb4a, KEY_AUDIO }, /* Music */
 633         { 0xeb4b, KEY_SCREEN }, /* Pic */
 634         { 0xeb4c, KEY_PLAY },
 635         { 0xeb4d, KEY_BACK },
 636         { 0xeb4e, KEY_REWIND },
 637         { 0xeb4f, KEY_FASTFORWARD },
 638         { 0xeb54, KEY_PREVIOUS },
 639         { 0xeb58, KEY_RECORD },
 640         { 0xeb5c, KEY_NEXT },
 641
 642         /* Key codes for the Haupauge WinTV Nova-TD, copied from nova-t-usb2.c (Nova-T USB2) */
 643         { 0x1e00, KEY_0 },
 644         { 0x1e01, KEY_1 },
 645         { 0x1e02, KEY_2 },
 646         { 0x1e03, KEY_3 },
 647         { 0x1e04, KEY_4 },
 648         { 0x1e05, KEY_5 },
 649         { 0x1e06, KEY_6 },
 650         { 0x1e07, KEY_7 },
 651         { 0x1e08, KEY_8 },
 652         { 0x1e09, KEY_9 },
 653         { 0x1e0a, KEY_KPASTERISK },
 654         { 0x1e0b, KEY_RED },
 655         { 0x1e0c, KEY_RADIO },
 656         { 0x1e0d, KEY_MENU },
 657         { 0x1e0e, KEY_GRAVE }, /* # */
 658         { 0x1e0f, KEY_MUTE },
 659         { 0x1e10, KEY_VOLUMEUP },
 660         { 0x1e11, KEY_VOLUMEDOWN },
 661         { 0x1e12, KEY_CHANNEL },
 662         { 0x1e14, KEY_UP },
 663         { 0x1e15, KEY_DOWN },
 664         { 0x1e16, KEY_LEFT },
 665         { 0x1e17, KEY_RIGHT },
 666         { 0x1e18, KEY_VIDEO },
 667         { 0x1e19, KEY_AUDIO },
 668         { 0x1e1a, KEY_MEDIA },
 669         { 0x1e1b, KEY_EPG },
 670         { 0x1e1c, KEY_TV },
 671         { 0x1e1e, KEY_NEXT },
 672         { 0x1e1f, KEY_BACK },
 673         { 0x1e20, KEY_CHANNELUP },
 674         { 0x1e21, KEY_CHANNELDOWN },
 675         { 0x1e24, KEY_LAST }, /* Skip backwards */
 676         { 0x1e25, KEY_OK },
 677         { 0x1e29, KEY_BLUE},
 678         { 0x1e2e, KEY_GREEN },
 679         { 0x1e30, KEY_PAUSE },
 680         { 0x1e32, KEY_REWIND },
 681         { 0x1e34, KEY_FASTFORWARD },
 682         { 0x1e35, KEY_PLAY },
 683         { 0x1e36, KEY_STOP },
 684         { 0x1e37, KEY_RECORD },
 685         { 0x1e38, KEY_YELLOW },
 686         { 0x1e3b, KEY_GOTO },
 687         { 0x1e3d, KEY_POWER },
 688
 689         /* Key codes for the Leadtek Winfast DTV Dongle */
 690         { 0x0042, KEY_POWER },
 691         { 0x077c, KEY_TUNER },
 692         { 0x0f4e, KEY_PRINT }, /* PREVIEW */
 693         { 0x0840, KEY_SCREEN }, /* full screen toggle*/
 694         { 0x0f71, KEY_DOT }, /* frequency */
 695         { 0x0743, KEY_0 },
 696         { 0x0c41, KEY_1 },
 697         { 0x0443, KEY_2 },
 698         { 0x0b7f, KEY_3 },
 699         { 0x0e41, KEY_4 },
 700         { 0x0643, KEY_5 },
 701         { 0x097f, KEY_6 },
 702         { 0x0d7e, KEY_7 },
 703         { 0x057c, KEY_8 },
 704         { 0x0a40, KEY_9 },
 705         { 0x0e4e, KEY_CLEAR },
 706         { 0x047c, KEY_CHANNEL }, /* show channel number */
 707         { 0x0f41, KEY_LAST }, /* recall */
 708         { 0x0342, KEY_MUTE },
 709         { 0x064c, KEY_RESERVED }, /* PIP button*/
 710         { 0x0172, KEY_SHUFFLE }, /* SNAPSHOT */
 711         { 0x0c4e, KEY_PLAYPAUSE }, /* TIMESHIFT */
 712         { 0x0b70, KEY_RECORD },
 713         { 0x037d, KEY_VOLUMEUP },
 714         { 0x017d, KEY_VOLUMEDOWN },
 715         { 0x0242, KEY_CHANNELUP },
 716         { 0x007d, KEY_CHANNELDOWN },
 717
 718         /* Key codes for Nova-TD "credit card" remote control. */
 719         { 0x1d00, KEY_0 },
 720         { 0x1d01, KEY_1 },
 721         { 0x1d02, KEY_2 },
 722         { 0x1d03, KEY_3 },
 723         { 0x1d04, KEY_4 },
 724         { 0x1d05, KEY_5 },
 725         { 0x1d06, KEY_6 },
 726         { 0x1d07, KEY_7 },
 727         { 0x1d08, KEY_8 },
 728         { 0x1d09, KEY_9 },
 729         { 0x1d0a, KEY_TEXT },
 730         { 0x1d0d, KEY_MENU },
 731         { 0x1d0f, KEY_MUTE },
 732         { 0x1d10, KEY_VOLUMEUP },
 733         { 0x1d11, KEY_VOLUMEDOWN },
 734         { 0x1d12, KEY_CHANNEL },
 735         { 0x1d14, KEY_UP },
 736         { 0x1d15, KEY_DOWN },
 737         { 0x1d16, KEY_LEFT },
 738         { 0x1d17, KEY_RIGHT },
 739         { 0x1d1c, KEY_TV },
 740         { 0x1d1e, KEY_NEXT },
 741         { 0x1d1f, KEY_BACK },
 742         { 0x1d20, KEY_CHANNELUP },
 743         { 0x1d21, KEY_CHANNELDOWN },
 744         { 0x1d24, KEY_LAST },
 745         { 0x1d25, KEY_OK },
 746         { 0x1d30, KEY_PAUSE },
 747         { 0x1d32, KEY_REWIND },
 748         { 0x1d34, KEY_FASTFORWARD },
 749         { 0x1d35, KEY_PLAY },
 750         { 0x1d36, KEY_STOP },
 751         { 0x1d37, KEY_RECORD },
 752         { 0x1d3b, KEY_GOTO },
 753         { 0x1d3d, KEY_POWER },
 754
 755         /* Key codes for the Pixelview SBTVD remote (proto NEC) */
 756         { 0x8613, KEY_MUTE },
 757         { 0x8612, KEY_POWER },
 758         { 0x8601, KEY_1 },
 759         { 0x8602, KEY_2 },
 760         { 0x8603, KEY_3 },
 761         { 0x8604, KEY_4 },
 762         { 0x8605, KEY_5 },
 763         { 0x8606, KEY_6 },
 764         { 0x8607, KEY_7 },
 765         { 0x8608, KEY_8 },
 766         { 0x8609, KEY_9 },
 767         { 0x8600, KEY_0 },
 768         { 0x860d, KEY_CHANNELUP },
 769         { 0x8619, KEY_CHANNELDOWN },
 770         { 0x8610, KEY_VOLUMEUP },
 771         { 0x860c, KEY_VOLUMEDOWN },
 772
 773         { 0x860a, KEY_CAMERA },
 774         { 0x860b, KEY_ZOOM },
 775         { 0x861b, KEY_BACKSPACE },
 776         { 0x8615, KEY_ENTER },
 777
 778         { 0x861d, KEY_UP },
 779         { 0x861e, KEY_DOWN },
 780         { 0x860e, KEY_LEFT },
 781         { 0x860f, KEY_RIGHT },
 782
 783         { 0x8618, KEY_RECORD },
 784         { 0x861a, KEY_STOP },
 785
 786         /* Key codes for the EvolutePC TVWay+ remote (proto NEC) */
 787         { 0x7a00, KEY_MENU },
 788         { 0x7a01, KEY_RECORD },
 789         { 0x7a02, KEY_PLAY },
 790         { 0x7a03, KEY_STOP },
 791         { 0x7a10, KEY_CHANNELUP },
 792         { 0x7a11, KEY_CHANNELDOWN },
 793         { 0x7a12, KEY_VOLUMEUP },
 794         { 0x7a13, KEY_VOLUMEDOWN },
 795         { 0x7a40, KEY_POWER },
 796         { 0x7a41, KEY_MUTE },
 797 };
 798
 799 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 800 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 801         BAND_UHF | BAND_VHF,
 802
 803         /* 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,
 804          * 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 */
 805         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 806         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 807
 808         712,
 809         41,
 810
 811         0,
 812         118,
 813
 814         0,
 815         4095,
 816         0,
 817         0,
 818
 819         42598,
 820         17694,
 821         45875,
 822         2621,
 823         0,
 824         76,
 825         139,
 826         52,
 827         59,
 828         107,
 829         172,
 830         57,
 831         70,
 832
 833         21,
 834         25,
 835         28,
 836         48,
 837
 838         1,
 839         {  0,
 840            107,
 841            51800,
 842            24700
 843         },
 844 };
 845
 846 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 847         BAND_UHF | BAND_VHF,
 848
 849         /* 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,
 850          * 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 */
 851         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 852         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 853
 854         712,
 855         41,
 856
 857         0,
 858         118,
 859
 860         0,
 861         4095,
 862         0,
 863         0,
 864
 865         42598,
 866         16384,
 867         42598,
 868             0,
 869
 870           0,
 871         137,
 872         255,
 873
 874           0,
 875         255,
 876
 877         0,
 878         0,
 879
 880          0,
 881         41,
 882
 883         15,
 884         25,
 885
 886         28,
 887         48,
 888
 889         0,
 890 };
 891
 892 static struct dibx000_bandwidth_config stk7700p_pll_config = {
 893         60000, 30000,
 894         1, 8, 3, 1, 0,
 895         0, 0, 1, 1, 0,
 896         (3 << 14) | (1 << 12) | (524 << 0),
 897         60258167,
 898         20452225,
 899         30000000,
 900 };
 901
 902 static struct dib7000m_config stk7700p_dib7000m_config = {
 903         .dvbt_mode = 1,
 904         .output_mpeg2_in_188_bytes = 1,
 905         .quartz_direct = 1,
 906
 907         .agc_config_count = 1,
 908         .agc = &stk7700p_7000m_mt2060_agc_config,
 909         .bw  = &stk7700p_pll_config,
 910
 911         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 912         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 913         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 914 };
 915
 916 static struct dib7000p_config stk7700p_dib7000p_config = {
 917         .output_mpeg2_in_188_bytes = 1,
 918
 919         .agc_config_count = 1,
 920         .agc = &stk7700p_7000p_mt2060_agc_config,
 921         .bw  = &stk7700p_pll_config,
 922
 923         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 924         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 925         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 926 };
 927
 928 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 929 {
 930         struct dib0700_state *st = adap->dev->priv;
 931         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 932
 933         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 934         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 935
 936         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 937         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 938
 939         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 940         dib0700_ctrl_clock(adap->dev, 72, 1);
 941         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 942
 943         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 944
 945         st->mt2060_if1[0] = 1220;
 946
 947         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
 948                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 949                 st->is_dib7000pc = 1;
 950         } else
 951                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 952
 953         return adap->fe == NULL ? -ENODEV : 0;
 954 }
 955
 956 static struct mt2060_config stk7700p_mt2060_config = {
 957         0x60
 958 };
 959
 960 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 961 {
 962         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 963         struct dib0700_state *st = adap->dev->priv;
 964         struct i2c_adapter *tun_i2c;
 965         s8 a;
 966         int if1=1220;
 967         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 968                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
 969                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
 970         }
 971         if (st->is_dib7000pc)
 972                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 973         else
 974                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 975
 976         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
 977                 if1) == NULL ? -ENODEV : 0;
 978 }
 979
 980 /* DIB7070 generic */
 981 static struct dibx000_agc_config dib7070_agc_config = {
 982         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 983         /* 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,
 984          * 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 */
 985         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 986         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 987
 988         600,
 989         10,
 990
 991         0,
 992         118,
 993
 994         0,
 995         3530,
 996         1,
 997         5,
 998
 999         65535,
1000                 0,
1001
1002         65535,
1003         0,
1004
1005         0,
1006         40,
1007         183,
1008         206,
1009         255,
1010         72,
1011         152,
1012         88,
1013         90,
1014
1015         17,
1016         27,
1017         23,
1018         51,
1019
1020         0,
1021 };
1022
1023 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1024 {
1025         deb_info("reset: %d", onoff);
1026         return dib7000p_set_gpio(fe, 8, 0, !onoff);
1027 }
1028
1029 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1030 {
1031         deb_info("sleep: %d", onoff);
1032         return dib7000p_set_gpio(fe, 9, 0, onoff);
1033 }
1034
1035 static struct dib0070_config dib7070p_dib0070_config[2] = {
1036         {
1037                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1038                 .reset = dib7070_tuner_reset,
1039                 .sleep = dib7070_tuner_sleep,
1040                 .clock_khz = 12000,
1041                 .clock_pad_drive = 4,
1042                 .charge_pump = 2,
1043         }, {
1044                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1045                 .reset = dib7070_tuner_reset,
1046                 .sleep = dib7070_tuner_sleep,
1047                 .clock_khz = 12000,
1048                 .charge_pump = 2,
1049         }
1050 };
1051
1052 static struct dib0070_config dib7770p_dib0070_config = {
1053          .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1054          .reset = dib7070_tuner_reset,
1055          .sleep = dib7070_tuner_sleep,
1056          .clock_khz = 12000,
1057          .clock_pad_drive = 0,
1058          .flip_chip = 1,
1059          .charge_pump = 2,
1060 };
1061
1062 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
1063 {
1064         struct dvb_usb_adapter *adap = fe->dvb->priv;
1065         struct dib0700_adapter_state *state = adap->priv;
1066
1067         u16 offset;
1068         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1069         switch (band) {
1070                 case BAND_VHF: offset = 950; break;
1071                 case BAND_UHF:
1072                 default: offset = 550; break;
1073         }
1074         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1075         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1076         return state->set_param_save(fe, fep);
1077 }
1078
1079 static int dib7770_set_param_override(struct dvb_frontend *fe,
1080                 struct dvb_frontend_parameters *fep)
1081 {
1082          struct dvb_usb_adapter *adap = fe->dvb->priv;
1083          struct dib0700_adapter_state *state = adap->priv;
1084
1085          u16 offset;
1086          u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1087          switch (band) {
1088          case BAND_VHF:
1089                   dib7000p_set_gpio(fe, 0, 0, 1);
1090                   offset = 850;
1091                   break;
1092          case BAND_UHF:
1093          default:
1094                   dib7000p_set_gpio(fe, 0, 0, 0);
1095                   offset = 250;
1096                   break;
1097          }
1098          deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1099          dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1100          return state->set_param_save(fe, fep);
1101 }
1102
1103 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
1104 {
1105          struct dib0700_adapter_state *st = adap->priv;
1106          struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
1107                          DIBX000_I2C_INTERFACE_TUNER, 1);
1108
1109          if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1110                                  &dib7770p_dib0070_config) == NULL)
1111                  return -ENODEV;
1112
1113          st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1114          adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
1115          return 0;
1116 }
1117
1118 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
1119 {
1120         struct dib0700_adapter_state *st = adap->priv;
1121         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1122
1123         if (adap->id == 0) {
1124                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
1125                         return -ENODEV;
1126         } else {
1127                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
1128                         return -ENODEV;
1129         }
1130
1131         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1132         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1133         return 0;
1134 }
1135
1136 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1137 {
1138     return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
1139 }
1140
1141 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1142 {
1143     return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
1144 }
1145
1146 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1147         60000, 15000,
1148         1, 20, 3, 1, 0,
1149         0, 0, 1, 1, 2,
1150         (3 << 14) | (1 << 12) | (524 << 0),
1151         (0 << 25) | 0,
1152         20452225,
1153         12000000,
1154 };
1155
1156 static struct dib7000p_config dib7070p_dib7000p_config = {
1157         .output_mpeg2_in_188_bytes = 1,
1158
1159         .agc_config_count = 1,
1160         .agc = &dib7070_agc_config,
1161         .bw  = &dib7070_bw_config_12_mhz,
1162         .tuner_is_baseband = 1,
1163         .spur_protect = 1,
1164
1165         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1166         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1167         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1168
1169         .hostbus_diversity = 1,
1170 };
1171
1172 /* STK7070P */
1173 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
1174 {
1175         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1176         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
1177             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1178                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1179         else
1180                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1181         msleep(10);
1182         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1183         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1184         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1185         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1186
1187         dib0700_ctrl_clock(adap->dev, 72, 1);
1188
1189         msleep(10);
1190         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1191         msleep(10);
1192         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1193
1194         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1195                                      &dib7070p_dib7000p_config) != 0) {
1196                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1197                     __func__);
1198                 return -ENODEV;
1199         }
1200
1201         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1202                 &dib7070p_dib7000p_config);
1203         return adap->fe == NULL ? -ENODEV : 0;
1204 }
1205
1206 /* DIB807x generic */
1207 static struct dibx000_agc_config dib807x_agc_config[2] = {
1208         {
1209                 BAND_VHF,
1210                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1211                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1212                  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1213                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1214                  * P_agc_write=0 */
1215                 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1216                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1217                         (0 << 0), /* setup*/
1218
1219                 600, /* inv_gain*/
1220                 10,  /* time_stabiliz*/
1221
1222                 0,  /* alpha_level*/
1223                 118,  /* thlock*/
1224
1225                 0,     /* wbd_inv*/
1226                 3530,  /* wbd_ref*/
1227                 1,     /* wbd_sel*/
1228                 5,     /* wbd_alpha*/
1229
1230                 65535,  /* agc1_max*/
1231                 0,  /* agc1_min*/
1232
1233                 65535,  /* agc2_max*/
1234                 0,      /* agc2_min*/
1235
1236                 0,      /* agc1_pt1*/
1237                 40,     /* agc1_pt2*/
1238                 183,    /* agc1_pt3*/
1239                 206,    /* agc1_slope1*/
1240                 255,    /* agc1_slope2*/
1241                 72,     /* agc2_pt1*/
1242                 152,    /* agc2_pt2*/
1243                 88,     /* agc2_slope1*/
1244                 90,     /* agc2_slope2*/
1245
1246                 17,  /* alpha_mant*/
1247                 27,  /* alpha_exp*/
1248                 23,  /* beta_mant*/
1249                 51,  /* beta_exp*/
1250
1251                 0,  /* perform_agc_softsplit*/
1252         }, {
1253                 BAND_UHF,
1254                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1255                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1256                  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1257                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1258                  * P_agc_write=0 */
1259                 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1260                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1261                         (0 << 0), /* setup */
1262
1263                 600, /* inv_gain*/
1264                 10,  /* time_stabiliz*/
1265
1266                 0,  /* alpha_level*/
1267                 118,  /* thlock*/
1268
1269                 0,     /* wbd_inv*/
1270                 3530,  /* wbd_ref*/
1271                 1,     /* wbd_sel*/
1272                 5,     /* wbd_alpha*/
1273
1274                 65535,  /* agc1_max*/
1275                 0,  /* agc1_min*/
1276
1277                 65535,  /* agc2_max*/
1278                 0,      /* agc2_min*/
1279
1280                 0,      /* agc1_pt1*/
1281                 40,     /* agc1_pt2*/
1282                 183,    /* agc1_pt3*/
1283                 206,    /* agc1_slope1*/
1284                 255,    /* agc1_slope2*/
1285                 72,     /* agc2_pt1*/
1286                 152,    /* agc2_pt2*/
1287                 88,     /* agc2_slope1*/
1288                 90,     /* agc2_slope2*/
1289
1290                 17,  /* alpha_mant*/
1291                 27,  /* alpha_exp*/
1292                 23,  /* beta_mant*/
1293                 51,  /* beta_exp*/
1294
1295                 0,  /* perform_agc_softsplit*/
1296         }
1297 };
1298
1299 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1300         60000, 15000, /* internal, sampling*/
1301         1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1302         0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1303                           ADClkSrc, modulo */
1304         (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1305         (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1306         18179755, /* timf*/
1307         12000000, /* xtal_hz*/
1308 };
1309
1310 static struct dib8000_config dib807x_dib8000_config[2] = {
1311         {
1312                 .output_mpeg2_in_188_bytes = 1,
1313
1314                 .agc_config_count = 2,
1315                 .agc = dib807x_agc_config,
1316                 .pll = &dib807x_bw_config_12_mhz,
1317                 .tuner_is_baseband = 1,
1318
1319                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1320                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1321                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1322
1323                 .hostbus_diversity = 1,
1324                 .div_cfg = 1,
1325                 .agc_control = &dib0070_ctrl_agc_filter,
1326                 .output_mode = OUTMODE_MPEG2_FIFO,
1327                 .drives = 0x2d98,
1328         }, {
1329                 .output_mpeg2_in_188_bytes = 1,
1330
1331                 .agc_config_count = 2,
1332                 .agc = dib807x_agc_config,
1333                 .pll = &dib807x_bw_config_12_mhz,
1334                 .tuner_is_baseband = 1,
1335
1336                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1337                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1338                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1339
1340                 .hostbus_diversity = 1,
1341                 .agc_control = &dib0070_ctrl_agc_filter,
1342                 .output_mode = OUTMODE_MPEG2_FIFO,
1343                 .drives = 0x2d98,
1344         }
1345 };
1346
1347 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1348 {
1349         return dib8000_set_gpio(fe, 5, 0, !onoff);
1350 }
1351
1352 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1353 {
1354         return dib8000_set_gpio(fe, 0, 0, onoff);
1355 }
1356
1357 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1358     { 240,      7},
1359     { 0xffff,   6},
1360 };
1361
1362 static struct dib0070_config dib807x_dib0070_config[2] = {
1363         {
1364                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1365                 .reset = dib80xx_tuner_reset,
1366                 .sleep = dib80xx_tuner_sleep,
1367                 .clock_khz = 12000,
1368                 .clock_pad_drive = 4,
1369                 .vga_filter = 1,
1370                 .force_crystal_mode = 1,
1371                 .enable_third_order_filter = 1,
1372                 .charge_pump = 0,
1373                 .wbd_gain = dib8070_wbd_gain_cfg,
1374                 .osc_buffer_state = 0,
1375                 .freq_offset_khz_uhf = -100,
1376                 .freq_offset_khz_vhf = -100,
1377         }, {
1378                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1379                 .reset = dib80xx_tuner_reset,
1380                 .sleep = dib80xx_tuner_sleep,
1381                 .clock_khz = 12000,
1382                 .clock_pad_drive = 2,
1383                 .vga_filter = 1,
1384                 .force_crystal_mode = 1,
1385                 .enable_third_order_filter = 1,
1386                 .charge_pump = 0,
1387                 .wbd_gain = dib8070_wbd_gain_cfg,
1388                 .osc_buffer_state = 0,
1389                 .freq_offset_khz_uhf = -25,
1390                 .freq_offset_khz_vhf = -25,
1391         }
1392 };
1393
1394 static int dib807x_set_param_override(struct dvb_frontend *fe,
1395                 struct dvb_frontend_parameters *fep)
1396 {
1397         struct dvb_usb_adapter *adap = fe->dvb->priv;
1398         struct dib0700_adapter_state *state = adap->priv;
1399
1400         u16 offset = dib0070_wbd_offset(fe);
1401         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1402         switch (band) {
1403         case BAND_VHF:
1404                 offset += 750;
1405                 break;
1406         case BAND_UHF:  /* fall-thru wanted */
1407         default:
1408                 offset += 250; break;
1409         }
1410         deb_info("WBD for DiB8000: %d\n", offset);
1411         dib8000_set_wbd_ref(fe, offset);
1412
1413         return state->set_param_save(fe, fep);
1414 }
1415
1416 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1417 {
1418         struct dib0700_adapter_state *st = adap->priv;
1419         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1420                         DIBX000_I2C_INTERFACE_TUNER, 1);
1421
1422         if (adap->id == 0) {
1423                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1424                                 &dib807x_dib0070_config[0]) == NULL)
1425                         return -ENODEV;
1426         } else {
1427                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1428                                 &dib807x_dib0070_config[1]) == NULL)
1429                         return -ENODEV;
1430         }
1431
1432         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1433         adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1434         return 0;
1435 }
1436
1437 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1438         u16 pid, int onoff)
1439 {
1440     return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1441 }
1442
1443 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1444         int onoff)
1445 {
1446     return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1447 }
1448
1449 /* STK807x */
1450 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1451 {
1452         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1453         msleep(10);
1454         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1455         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1456         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1457
1458         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1459
1460         dib0700_ctrl_clock(adap->dev, 72, 1);
1461
1462         msleep(10);
1463         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1464         msleep(10);
1465         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1466
1467         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1468                                 0x80);
1469
1470         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1471                               &dib807x_dib8000_config[0]);
1472
1473         return adap->fe == NULL ?  -ENODEV : 0;
1474 }
1475
1476 /* STK807xPVR */
1477 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1478 {
1479         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1480         msleep(30);
1481         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1482         msleep(500);
1483         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1484         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1485         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1486
1487         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1488
1489         dib0700_ctrl_clock(adap->dev, 72, 1);
1490
1491         msleep(10);
1492         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1493         msleep(10);
1494         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1495
1496         /* initialize IC 0 */
1497         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1498
1499         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1500                               &dib807x_dib8000_config[0]);
1501
1502         return adap->fe == NULL ? -ENODEV : 0;
1503 }
1504
1505 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1506 {
1507         /* initialize IC 1 */
1508         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1509
1510         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1511                               &dib807x_dib8000_config[1]);
1512
1513         return adap->fe == NULL ? -ENODEV : 0;
1514 }
1515
1516 /* STK8096GP */
1517 struct dibx000_agc_config dib8090_agc_config[2] = {
1518     {
1519         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1520         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1521      * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1522      * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1523         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1524         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1525
1526         787,
1527         10,
1528
1529         0,
1530         118,
1531
1532         0,
1533         3530,
1534         1,
1535         5,
1536
1537         65535,
1538         0,
1539
1540         65535,
1541         0,
1542
1543         0,
1544         32,
1545         114,
1546         143,
1547         144,
1548         114,
1549         227,
1550         116,
1551         117,
1552
1553         28,
1554         26,
1555         31,
1556         51,
1557
1558         0,
1559     },
1560     {
1561         BAND_CBAND,
1562         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1563      * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1564      * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1565         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1566         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1567
1568         787,
1569         10,
1570
1571         0,
1572         118,
1573
1574         0,
1575         3530,
1576         1,
1577         5,
1578
1579         0,
1580         0,
1581
1582         65535,
1583         0,
1584
1585         0,
1586         32,
1587         114,
1588         143,
1589         144,
1590         114,
1591         227,
1592         116,
1593         117,
1594
1595         28,
1596         26,
1597         31,
1598         51,
1599
1600         0,
1601     }
1602 };
1603
1604 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1605     54000, 13500,
1606     1, 18, 3, 1, 0,
1607     0, 0, 1, 1, 2,
1608     (3 << 14) | (1 << 12) | (599 << 0),
1609     (0 << 25) | 0,
1610     20199727,
1611     12000000,
1612 };
1613
1614 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1615 {
1616     return dib8000_get_adc_power(fe, 1);
1617 }
1618
1619 static struct dib8000_config dib809x_dib8000_config = {
1620     .output_mpeg2_in_188_bytes = 1,
1621
1622     .agc_config_count = 2,
1623     .agc = dib8090_agc_config,
1624     .agc_control = dib0090_dcc_freq,
1625     .pll = &dib8090_pll_config_12mhz,
1626     .tuner_is_baseband = 1,
1627
1628     .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1629     .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1630     .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1631
1632     .hostbus_diversity = 1,
1633     .div_cfg = 0x31,
1634     .output_mode = OUTMODE_MPEG2_FIFO,
1635     .drives = 0x2d98,
1636     .diversity_delay = 144,
1637     .refclksel = 3,
1638 };
1639
1640 static struct dib0090_config dib809x_dib0090_config = {
1641     .io.pll_bypass = 1,
1642     .io.pll_range = 1,
1643     .io.pll_prediv = 1,
1644     .io.pll_loopdiv = 20,
1645     .io.adc_clock_ratio = 8,
1646     .io.pll_int_loop_filt = 0,
1647     .io.clock_khz = 12000,
1648     .reset = dib80xx_tuner_reset,
1649     .sleep = dib80xx_tuner_sleep,
1650     .clkouttobamse = 1,
1651     .analog_output = 1,
1652     .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1653     .wbd_vhf_offset = 100,
1654     .wbd_cband_offset = 450,
1655     .use_pwm_agc = 1,
1656     .clkoutdrive = 1,
1657     .get_adc_power = dib8090_get_adc_power,
1658         .freq_offset_khz_uhf = 0,
1659         .freq_offset_khz_vhf = -143,
1660 };
1661
1662 static int dib8096_set_param_override(struct dvb_frontend *fe,
1663                 struct dvb_frontend_parameters *fep)
1664 {
1665     struct dvb_usb_adapter *adap = fe->dvb->priv;
1666     struct dib0700_adapter_state *state = adap->priv;
1667     u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1668     u16 offset;
1669     int ret = 0;
1670     enum frontend_tune_state tune_state = CT_SHUTDOWN;
1671     u16 ltgain, rf_gain_limit;
1672
1673     ret = state->set_param_save(fe, fep);
1674     if (ret < 0)
1675         return ret;
1676
1677     switch (band) {
1678     case BAND_VHF:
1679             offset = 100;
1680             break;
1681     case BAND_UHF:
1682             offset = 550;
1683             break;
1684     default:
1685             offset = 0;
1686             break;
1687     }
1688     offset += (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1689     dib8000_set_wbd_ref(fe, offset);
1690
1691
1692     if (band == BAND_CBAND) {
1693         deb_info("tuning in CBAND - soft-AGC startup\n");
1694         /* TODO specific wbd target for dib0090 - needed for startup ? */
1695         dib0090_set_tune_state(fe, CT_AGC_START);
1696         do {
1697                 ret = dib0090_gain_control(fe);
1698                 msleep(ret);
1699                 tune_state = dib0090_get_tune_state(fe);
1700                 if (tune_state == CT_AGC_STEP_0)
1701                         dib8000_set_gpio(fe, 6, 0, 1);
1702                 else if (tune_state == CT_AGC_STEP_1) {
1703                         dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1704                         if (rf_gain_limit == 0)
1705                                 dib8000_set_gpio(fe, 6, 0, 0);
1706                 }
1707         } while (tune_state < CT_AGC_STOP);
1708         dib0090_pwm_gain_reset(fe);
1709         dib8000_pwm_agc_reset(fe);
1710         dib8000_set_tune_state(fe, CT_DEMOD_START);
1711     } else {
1712         deb_info("not tuning in CBAND - standard AGC startup\n");
1713         dib0090_pwm_gain_reset(fe);
1714     }
1715
1716     return 0;
1717 }
1718
1719 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1720 {
1721     struct dib0700_adapter_state *st = adap->priv;
1722     struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1723
1724     if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1725         return -ENODEV;
1726
1727     st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1728     adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1729     return 0;
1730 }
1731
1732 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1733 {
1734         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1735         msleep(10);
1736         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1737         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1738         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1739
1740         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1741
1742         dib0700_ctrl_clock(adap->dev, 72, 1);
1743
1744         msleep(10);
1745         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1746         msleep(10);
1747         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1748
1749         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1750
1751         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config);
1752
1753         return adap->fe == NULL ?  -ENODEV : 0;
1754 }
1755
1756 /* STK7070PD */
1757 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1758         {
1759                 .output_mpeg2_in_188_bytes = 1,
1760
1761                 .agc_config_count = 1,
1762                 .agc = &dib7070_agc_config,
1763                 .bw  = &dib7070_bw_config_12_mhz,
1764                 .tuner_is_baseband = 1,
1765                 .spur_protect = 1,
1766
1767                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1768                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1769                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1770
1771                 .hostbus_diversity = 1,
1772         }, {
1773                 .output_mpeg2_in_188_bytes = 1,
1774
1775                 .agc_config_count = 1,
1776                 .agc = &dib7070_agc_config,
1777                 .bw  = &dib7070_bw_config_12_mhz,
1778                 .tuner_is_baseband = 1,
1779                 .spur_protect = 1,
1780
1781                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1782                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1783                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1784
1785                 .hostbus_diversity = 1,
1786         }
1787 };
1788
1789 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1790 {
1791         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1792         msleep(10);
1793         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1794         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1795         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1796         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1797
1798         dib0700_ctrl_clock(adap->dev, 72, 1);
1799
1800         msleep(10);
1801         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1802         msleep(10);
1803         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1804
1805         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
1806                                      stk7070pd_dib7000p_config) != 0) {
1807                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1808                     __func__);
1809                 return -ENODEV;
1810         }
1811
1812         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1813         return adap->fe == NULL ? -ENODEV : 0;
1814 }
1815
1816 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1817 {
1818         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1819         return adap->fe == NULL ? -ENODEV : 0;
1820 }
1821
1822 /* S5H1411 */
1823 static struct s5h1411_config pinnacle_801e_config = {
1824         .output_mode   = S5H1411_PARALLEL_OUTPUT,
1825         .gpio          = S5H1411_GPIO_OFF,
1826         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1827         .qam_if        = S5H1411_IF_44000,
1828         .vsb_if        = S5H1411_IF_44000,
1829         .inversion     = S5H1411_INVERSION_OFF,
1830         .status_mode   = S5H1411_DEMODLOCKING
1831 };
1832
1833 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1834    GPIO0  - currently unknown
1835    GPIO1  - xc5000 tuner reset
1836    GPIO2  - CX25843 sleep
1837    GPIO3  - currently unknown
1838    GPIO4  - currently unknown
1839    GPIO6  - currently unknown
1840    GPIO7  - currently unknown
1841    GPIO9  - currently unknown
1842    GPIO10 - CX25843 reset
1843  */
1844 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1845 {
1846         struct dib0700_state *st = adap->dev->priv;
1847
1848         /* Make use of the new i2c functions from FW 1.20 */
1849         st->fw_use_new_i2c_api = 1;
1850
1851         /* The s5h1411 requires the dib0700 to not be in master mode */
1852         st->disable_streaming_master_mode = 1;
1853
1854         /* All msleep values taken from Windows USB trace */
1855         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1856         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1857         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1858         msleep(400);
1859         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1860         msleep(60);
1861         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1862         msleep(30);
1863         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1864         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1865         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1866         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1867         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
1868         msleep(30);
1869
1870         /* Put the CX25843 to sleep for now since we're in digital mode */
1871         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
1872
1873         /* GPIOs are initialized, do the attach */
1874         adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
1875                               &adap->dev->i2c_adap);
1876         return adap->fe == NULL ? -ENODEV : 0;
1877 }
1878
1879 static int dib0700_xc5000_tuner_callback(void *priv, int component,
1880                                          int command, int arg)
1881 {
1882         struct dvb_usb_adapter *adap = priv;
1883
1884         if (command == XC5000_TUNER_RESET) {
1885                 /* Reset the tuner */
1886                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
1887                 msleep(10);
1888                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
1889                 msleep(10);
1890         } else {
1891                 err("xc5000: unknown tuner callback command: %d\n", command);
1892                 return -EINVAL;
1893         }
1894
1895         return 0;
1896 }
1897
1898 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
1899         .i2c_address      = 0x64,
1900         .if_khz           = 5380,
1901 };
1902
1903 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
1904 {
1905         /* FIXME: generalize & move to common area */
1906         adap->fe->callback = dib0700_xc5000_tuner_callback;
1907
1908         return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
1909                           &s5h1411_xc5000_tunerconfig)
1910                 == NULL ? -ENODEV : 0;
1911 }
1912
1913 static struct lgdt3305_config hcw_lgdt3305_config = {
1914         .i2c_addr           = 0x0e,
1915         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
1916         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
1917         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
1918         .deny_i2c_rptr      = 0,
1919         .spectral_inversion = 1,
1920         .qam_if_khz         = 6000,
1921         .vsb_if_khz         = 6000,
1922         .usref_8vsb         = 0x0500,
1923 };
1924
1925 static struct mxl5007t_config hcw_mxl5007t_config = {
1926         .xtal_freq_hz = MxL_XTAL_25_MHZ,
1927         .if_freq_hz = MxL_IF_6_MHZ,
1928         .invert_if = 1,
1929 };
1930
1931 /* TIGER-ATSC map:
1932    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
1933    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
1934    GPIO4  - SCL2
1935    GPIO6  - EN_TUNER
1936    GPIO7  - SDA2
1937    GPIO10 - DEM_RST
1938
1939    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
1940  */
1941 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
1942 {
1943         struct dib0700_state *st = adap->dev->priv;
1944
1945         /* Make use of the new i2c functions from FW 1.20 */
1946         st->fw_use_new_i2c_api = 1;
1947
1948         st->disable_streaming_master_mode = 1;
1949
1950         /* fe power enable */
1951         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1952         msleep(30);
1953         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1954         msleep(30);
1955
1956         /* demod reset */
1957         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1958         msleep(30);
1959         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1960         msleep(30);
1961         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1962         msleep(30);
1963
1964         adap->fe = dvb_attach(lgdt3305_attach,
1965                               &hcw_lgdt3305_config,
1966                               &adap->dev->i2c_adap);
1967
1968         return adap->fe == NULL ? -ENODEV : 0;
1969 }
1970
1971 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
1972 {
1973         return dvb_attach(mxl5007t_attach, adap->fe,
1974                           &adap->dev->i2c_adap, 0x60,
1975                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
1976 }
1977
1978
1979 /* DVB-USB and USB stuff follows */
1980 struct usb_device_id dib0700_usb_id_table[] = {
1981 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
1982         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
1983         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
1984         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
1985         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
1986 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
1987         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
1988         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
1989         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
1990         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
1991 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
1992         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
1993         { USB_DEVICE(USB_VID_TERRATEC,
1994                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
1995         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
1996         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
1997 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
1998         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
1999         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
2000         { USB_DEVICE(USB_VID_PINNACLE,
2001                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
2002         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
2003 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
2004         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
2005         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
2006         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
2007         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
2008 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
2009         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
2010         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
2011         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
2012         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
2013 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
2014         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
2015         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
2016         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
2017         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
2018 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
2019         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
2020         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
2021         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
2022         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
2023 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
2024         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
2025         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
2026         { USB_DEVICE(USB_VID_TERRATEC,
2027                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
2028         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
2029 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
2030         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
2031         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
2032         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
2033         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
2034 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
2035         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
2036         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
2037         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
2038         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
2039 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
2040         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
2041         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
2042         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
2043         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
2044 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
2045         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
2046         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
2047         { USB_DEVICE(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD) },
2048         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
2049 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
2050         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
2051         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
2052         { 0 }           /* Terminating entry */
2053 };
2054 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
2055
2056 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
2057         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
2058         .usb_ctrl          = DEVICE_SPECIFIC, \
2059         .firmware          = "dvb-usb-dib0700-1.20.fw", \
2060         .download_firmware = dib0700_download_firmware, \
2061         .no_reconnect      = 1, \
2062         .size_of_priv      = sizeof(struct dib0700_state), \
2063         .i2c_algo          = &dib0700_i2c_algo, \
2064         .identify_state    = dib0700_identify_state
2065
2066 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
2067         .streaming_ctrl   = dib0700_streaming_ctrl, \
2068         .stream = { \
2069                 .type = USB_BULK, \
2070                 .count = 4, \
2071                 .endpoint = ep, \
2072                 .u = { \
2073                         .bulk = { \
2074                                 .buffersize = 39480, \
2075                         } \
2076                 } \
2077         }
2078
2079 struct dvb_usb_device_properties dib0700_devices[] = {
2080         {
2081                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
2082
2083                 .num_adapters = 1,
2084                 .adapter = {
2085                         {
2086                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2087                                 .pid_filter_count = 32,
2088                                 .pid_filter       = stk70x0p_pid_filter,
2089                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2090                                 .frontend_attach  = stk7700p_frontend_attach,
2091                                 .tuner_attach     = stk7700p_tuner_attach,
2092
2093                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2094                         },
2095                 },
2096
2097                 .num_device_descs = 8,
2098                 .devices = {
2099                         {   "DiBcom STK7700P reference design",
2100                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
2101                                 { NULL },
2102                         },
2103                         {   "Hauppauge Nova-T Stick",
2104                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
2105                                 { NULL },
2106                         },
2107                         {   "AVerMedia AVerTV DVB-T Volar",
2108                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
2109                                 { NULL },
2110                         },
2111                         {   "Compro Videomate U500",
2112                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
2113                                 { NULL },
2114                         },
2115                         {   "Uniwill STK7700P based (Hama and others)",
2116                                 { &dib0700_usb_id_table[7], NULL },
2117                                 { NULL },
2118                         },
2119                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
2120                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
2121                                 { NULL },
2122                         },
2123                         {   "AVerMedia AVerTV DVB-T Express",
2124                                 { &dib0700_usb_id_table[20] },
2125                                 { NULL },
2126                         },
2127                         {   "Gigabyte U7000",
2128                                 { &dib0700_usb_id_table[21], NULL },
2129                                 { NULL },
2130                         }
2131                 },
2132
2133                 .rc_interval      = DEFAULT_RC_INTERVAL,
2134                 .rc_key_map       = dib0700_rc_keys,
2135                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2136                 .rc_query         = dib0700_rc_query
2137         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2138
2139                 .num_adapters = 2,
2140                 .adapter = {
2141                         {
2142                                 .frontend_attach  = bristol_frontend_attach,
2143                                 .tuner_attach     = bristol_tuner_attach,
2144
2145                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2146                         }, {
2147                                 .frontend_attach  = bristol_frontend_attach,
2148                                 .tuner_attach     = bristol_tuner_attach,
2149
2150                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2151                         }
2152                 },
2153
2154                 .num_device_descs = 1,
2155                 .devices = {
2156                         {   "Hauppauge Nova-T 500 Dual DVB-T",
2157                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
2158                                 { NULL },
2159                         },
2160                 },
2161
2162                 .rc_interval      = DEFAULT_RC_INTERVAL,
2163                 .rc_key_map       = dib0700_rc_keys,
2164                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2165                 .rc_query         = dib0700_rc_query
2166         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2167
2168                 .num_adapters = 2,
2169                 .adapter = {
2170                         {
2171                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2172                                 .pid_filter_count = 32,
2173                                 .pid_filter       = stk70x0p_pid_filter,
2174                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2175                                 .frontend_attach  = stk7700d_frontend_attach,
2176                                 .tuner_attach     = stk7700d_tuner_attach,
2177
2178                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2179                         }, {
2180                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2181                                 .pid_filter_count = 32,
2182                                 .pid_filter       = stk70x0p_pid_filter,
2183                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2184                                 .frontend_attach  = stk7700d_frontend_attach,
2185                                 .tuner_attach     = stk7700d_tuner_attach,
2186
2187                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2188                         }
2189                 },
2190
2191                 .num_device_descs = 5,
2192                 .devices = {
2193                         {   "Pinnacle PCTV 2000e",
2194                                 { &dib0700_usb_id_table[11], NULL },
2195                                 { NULL },
2196                         },
2197                         {   "Terratec Cinergy DT XS Diversity",
2198                                 { &dib0700_usb_id_table[12], NULL },
2199                                 { NULL },
2200                         },
2201                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
2202                                 { &dib0700_usb_id_table[13], NULL },
2203                                 { NULL },
2204                         },
2205                         {   "DiBcom STK7700D reference design",
2206                                 { &dib0700_usb_id_table[14], NULL },
2207                                 { NULL },
2208                         },
2209                         {   "YUAN High-Tech DiBcom STK7700D",
2210                                 { &dib0700_usb_id_table[55], NULL },
2211                                 { NULL },
2212                         },
2213
2214                 },
2215
2216                 .rc_interval      = DEFAULT_RC_INTERVAL,
2217                 .rc_key_map       = dib0700_rc_keys,
2218                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2219                 .rc_query         = dib0700_rc_query
2220
2221         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2222
2223                 .num_adapters = 1,
2224                 .adapter = {
2225                         {
2226                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2227                                 .pid_filter_count = 32,
2228                                 .pid_filter       = stk70x0p_pid_filter,
2229                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2230                                 .frontend_attach  = stk7700P2_frontend_attach,
2231                                 .tuner_attach     = stk7700d_tuner_attach,
2232
2233                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2234                         },
2235                 },
2236
2237                 .num_device_descs = 3,
2238                 .devices = {
2239                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
2240                                 { &dib0700_usb_id_table[23], NULL },
2241                                 { NULL },
2242                         },
2243                         {   "Yuan EC372S",
2244                                 { &dib0700_usb_id_table[31], NULL },
2245                                 { NULL },
2246                         },
2247                         {   "Terratec Cinergy T Express",
2248                                 { &dib0700_usb_id_table[42], NULL },
2249                                 { NULL },
2250                         }
2251                 },
2252
2253                 .rc_interval      = DEFAULT_RC_INTERVAL,
2254                 .rc_key_map       = dib0700_rc_keys,
2255                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2256                 .rc_query         = dib0700_rc_query
2257         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2258
2259                 .num_adapters = 1,
2260                 .adapter = {
2261                         {
2262                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2263                                 .pid_filter_count = 32,
2264                                 .pid_filter       = stk70x0p_pid_filter,
2265                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2266                                 .frontend_attach  = stk7070p_frontend_attach,
2267                                 .tuner_attach     = dib7070p_tuner_attach,
2268
2269                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2270
2271                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2272                         },
2273                 },
2274
2275                 .num_device_descs = 11,
2276                 .devices = {
2277                         {   "DiBcom STK7070P reference design",
2278                                 { &dib0700_usb_id_table[15], NULL },
2279                                 { NULL },
2280                         },
2281                         {   "Pinnacle PCTV DVB-T Flash Stick",
2282                                 { &dib0700_usb_id_table[16], NULL },
2283                                 { NULL },
2284                         },
2285                         {   "Artec T14BR DVB-T",
2286                                 { &dib0700_usb_id_table[22], NULL },
2287                                 { NULL },
2288                         },
2289                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
2290                                 { &dib0700_usb_id_table[24], NULL },
2291                                 { NULL },
2292                         },
2293                         {   "Hauppauge Nova-T Stick",
2294                                 { &dib0700_usb_id_table[25], NULL },
2295                                 { NULL },
2296                         },
2297                         {   "Hauppauge Nova-T MyTV.t",
2298                                 { &dib0700_usb_id_table[26], NULL },
2299                                 { NULL },
2300                         },
2301                         {   "Pinnacle PCTV 72e",
2302                                 { &dib0700_usb_id_table[29], NULL },
2303                                 { NULL },
2304                         },
2305                         {   "Pinnacle PCTV 73e",
2306                                 { &dib0700_usb_id_table[30], NULL },
2307                                 { NULL },
2308                         },
2309                         {   "Elgato EyeTV DTT",
2310                                 { &dib0700_usb_id_table[49], NULL },
2311                                 { NULL },
2312                         },
2313                         {   "Yuan PD378S",
2314                                 { &dib0700_usb_id_table[45], NULL },
2315                                 { NULL },
2316                         },
2317                         {   "Elgato EyeTV Dtt Dlx PD378S",
2318                                 { &dib0700_usb_id_table[50], NULL },
2319                                 { NULL },
2320                         },
2321                 },
2322
2323                 .rc_interval      = DEFAULT_RC_INTERVAL,
2324                 .rc_key_map       = dib0700_rc_keys,
2325                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2326                 .rc_query         = dib0700_rc_query
2327
2328         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2329
2330                 .num_adapters = 1,
2331                 .adapter = {
2332                         {
2333                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2334                                 .pid_filter_count = 32,
2335                                 .pid_filter       = stk70x0p_pid_filter,
2336                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2337                                 .frontend_attach  = stk7070p_frontend_attach,
2338                                 .tuner_attach     = dib7070p_tuner_attach,
2339
2340                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2341
2342                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2343                         },
2344                 },
2345
2346                 .num_device_descs = 3,
2347                 .devices = {
2348                         {   "Pinnacle PCTV 73A",
2349                                 { &dib0700_usb_id_table[56], NULL },
2350                                 { NULL },
2351                         },
2352                         {   "Pinnacle PCTV 73e SE",
2353                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
2354                                 { NULL },
2355                         },
2356                         {   "Pinnacle PCTV 282e",
2357                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
2358                                 { NULL },
2359                         },
2360                 },
2361
2362                 .rc_interval      = DEFAULT_RC_INTERVAL,
2363                 .rc_key_map       = dib0700_rc_keys,
2364                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2365                 .rc_query         = dib0700_rc_query
2366
2367         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2368
2369                 .num_adapters = 2,
2370                 .adapter = {
2371                         {
2372                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2373                                 .pid_filter_count = 32,
2374                                 .pid_filter       = stk70x0p_pid_filter,
2375                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2376                                 .frontend_attach  = stk7070pd_frontend_attach0,
2377                                 .tuner_attach     = dib7070p_tuner_attach,
2378
2379                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2380
2381                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2382                         }, {
2383                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2384                                 .pid_filter_count = 32,
2385                                 .pid_filter       = stk70x0p_pid_filter,
2386                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2387                                 .frontend_attach  = stk7070pd_frontend_attach1,
2388                                 .tuner_attach     = dib7070p_tuner_attach,
2389
2390                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2391
2392                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2393                         }
2394                 },
2395
2396                 .num_device_descs = 6,
2397                 .devices = {
2398                         {   "DiBcom STK7070PD reference design",
2399                                 { &dib0700_usb_id_table[17], NULL },
2400                                 { NULL },
2401                         },
2402                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
2403                                 { &dib0700_usb_id_table[18], NULL },
2404                                 { NULL },
2405                         },
2406                         {   "Hauppauge Nova-TD Stick (52009)",
2407                                 { &dib0700_usb_id_table[35], NULL },
2408                                 { NULL },
2409                         },
2410                         {   "Hauppauge Nova-TD-500 (84xxx)",
2411                                 { &dib0700_usb_id_table[36], NULL },
2412                                 { NULL },
2413                         },
2414                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
2415                                 { &dib0700_usb_id_table[43],
2416                                         &dib0700_usb_id_table[53], NULL},
2417                                 { NULL },
2418                         },
2419                         {  "Sony PlayTV",
2420                                 { &dib0700_usb_id_table[44], NULL },
2421                                 { NULL },
2422                         }
2423                 },
2424                 .rc_interval      = DEFAULT_RC_INTERVAL,
2425                 .rc_key_map       = dib0700_rc_keys,
2426                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2427                 .rc_query         = dib0700_rc_query
2428         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2429
2430                 .num_adapters = 1,
2431                 .adapter = {
2432                         {
2433                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2434                                 .pid_filter_count = 32,
2435                                 .pid_filter       = stk70x0p_pid_filter,
2436                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2437                                 .frontend_attach  = stk7700ph_frontend_attach,
2438                                 .tuner_attach     = stk7700ph_tuner_attach,
2439
2440                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2441
2442                                 .size_of_priv = sizeof(struct
2443                                                 dib0700_adapter_state),
2444                         },
2445                 },
2446
2447                 .num_device_descs = 9,
2448                 .devices = {
2449                         {   "Terratec Cinergy HT USB XE",
2450                                 { &dib0700_usb_id_table[27], NULL },
2451                                 { NULL },
2452                         },
2453                         {   "Pinnacle Expresscard 320cx",
2454                                 { &dib0700_usb_id_table[28], NULL },
2455                                 { NULL },
2456                         },
2457                         {   "Terratec Cinergy HT Express",
2458                                 { &dib0700_usb_id_table[32], NULL },
2459                                 { NULL },
2460                         },
2461                         {   "Gigabyte U8000-RH",
2462                                 { &dib0700_usb_id_table[37], NULL },
2463                                 { NULL },
2464                         },
2465                         {   "YUAN High-Tech STK7700PH",
2466                                 { &dib0700_usb_id_table[38], NULL },
2467                                 { NULL },
2468                         },
2469                         {   "Asus My Cinema-U3000Hybrid",
2470                                 { &dib0700_usb_id_table[39], NULL },
2471                                 { NULL },
2472                         },
2473                         {   "YUAN High-Tech MC770",
2474                                 { &dib0700_usb_id_table[48], NULL },
2475                                 { NULL },
2476                         },
2477                         {   "Leadtek WinFast DTV Dongle H",
2478                                 { &dib0700_usb_id_table[51], NULL },
2479                                 { NULL },
2480                         },
2481                         {   "YUAN High-Tech STK7700D",
2482                                 { &dib0700_usb_id_table[54], NULL },
2483                                 { NULL },
2484                         },
2485                 },
2486                 .rc_interval      = DEFAULT_RC_INTERVAL,
2487                 .rc_key_map       = dib0700_rc_keys,
2488                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2489                 .rc_query         = dib0700_rc_query
2490         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2491                 .num_adapters = 1,
2492                 .adapter = {
2493                         {
2494                                 .frontend_attach  = s5h1411_frontend_attach,
2495                                 .tuner_attach     = xc5000_tuner_attach,
2496
2497                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2498
2499                                 .size_of_priv = sizeof(struct
2500                                                 dib0700_adapter_state),
2501                         },
2502                 },
2503
2504                 .num_device_descs = 2,
2505                 .devices = {
2506                         {   "Pinnacle PCTV HD Pro USB Stick",
2507                                 { &dib0700_usb_id_table[40], NULL },
2508                                 { NULL },
2509                         },
2510                         {   "Pinnacle PCTV HD USB Stick",
2511                                 { &dib0700_usb_id_table[41], NULL },
2512                                 { NULL },
2513                         },
2514                 },
2515                 .rc_interval      = DEFAULT_RC_INTERVAL,
2516                 .rc_key_map       = dib0700_rc_keys,
2517                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2518                 .rc_query         = dib0700_rc_query
2519         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2520                 .num_adapters = 1,
2521                 .adapter = {
2522                         {
2523                                 .frontend_attach  = lgdt3305_frontend_attach,
2524                                 .tuner_attach     = mxl5007t_tuner_attach,
2525
2526                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2527
2528                                 .size_of_priv = sizeof(struct
2529                                                 dib0700_adapter_state),
2530                         },
2531                 },
2532
2533                 .num_device_descs = 2,
2534                 .devices = {
2535                         {   "Hauppauge ATSC MiniCard (B200)",
2536                                 { &dib0700_usb_id_table[46], NULL },
2537                                 { NULL },
2538                         },
2539                         {   "Hauppauge ATSC MiniCard (B210)",
2540                                 { &dib0700_usb_id_table[47], NULL },
2541                                 { NULL },
2542                         },
2543                 },
2544         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2545
2546                 .num_adapters = 1,
2547                 .adapter = {
2548                         {
2549                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2550                                 .pid_filter_count = 32,
2551                                 .pid_filter       = stk70x0p_pid_filter,
2552                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2553                                 .frontend_attach  = stk7070p_frontend_attach,
2554                                 .tuner_attach     = dib7770p_tuner_attach,
2555
2556                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2557
2558                                 .size_of_priv =
2559                                         sizeof(struct dib0700_adapter_state),
2560                         },
2561                 },
2562
2563                 .num_device_descs = 2,
2564                 .devices = {
2565                         {   "DiBcom STK7770P reference design",
2566                                 { &dib0700_usb_id_table[59], NULL },
2567                                 { NULL },
2568                         },
2569                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
2570                                 { &dib0700_usb_id_table[33],
2571                                         &dib0700_usb_id_table[52],
2572                                         &dib0700_usb_id_table[60], NULL},
2573                                 { NULL },
2574                         },
2575                 },
2576                 .rc_interval      = DEFAULT_RC_INTERVAL,
2577                 .rc_key_map       = dib0700_rc_keys,
2578                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2579                 .rc_query         = dib0700_rc_query
2580         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2581                 .num_adapters = 1,
2582                 .adapter = {
2583                         {
2584                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2585                                 .pid_filter_count = 32,
2586                                 .pid_filter = stk80xx_pid_filter,
2587                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2588                                 .frontend_attach  = stk807x_frontend_attach,
2589                                 .tuner_attach     = dib807x_tuner_attach,
2590
2591                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2592
2593                                 .size_of_priv =
2594                                         sizeof(struct dib0700_adapter_state),
2595                         },
2596                 },
2597
2598                 .num_device_descs = 3,
2599                 .devices = {
2600                         {   "DiBcom STK807xP reference design",
2601                                 { &dib0700_usb_id_table[62], NULL },
2602                                 { NULL },
2603                         },
2604                         {   "Prolink Pixelview SBTVD",
2605                                 { &dib0700_usb_id_table[63], NULL },
2606                                 { NULL },
2607                         },
2608                         {   "EvolutePC TVWay+",
2609                                 { &dib0700_usb_id_table[64], NULL },
2610                                 { NULL },
2611                         },
2612                 },
2613
2614                 .rc_interval      = DEFAULT_RC_INTERVAL,
2615                 .rc_key_map       = dib0700_rc_keys,
2616                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2617                 .rc_query         = dib0700_rc_query
2618
2619         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2620                 .num_adapters = 2,
2621                 .adapter = {
2622                         {
2623                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2624                                 .pid_filter_count = 32,
2625                                 .pid_filter = stk80xx_pid_filter,
2626                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2627                                 .frontend_attach  = stk807xpvr_frontend_attach0,
2628                                 .tuner_attach     = dib807x_tuner_attach,
2629
2630                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2631
2632                                 .size_of_priv =
2633                                         sizeof(struct dib0700_adapter_state),
2634                         },
2635                         {
2636                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2637                                 .pid_filter_count = 32,
2638                                 .pid_filter = stk80xx_pid_filter,
2639                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2640                                 .frontend_attach  = stk807xpvr_frontend_attach1,
2641                                 .tuner_attach     = dib807x_tuner_attach,
2642
2643                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2644
2645                                 .size_of_priv =
2646                                         sizeof(struct dib0700_adapter_state),
2647                         },
2648                 },
2649
2650                 .num_device_descs = 1,
2651                 .devices = {
2652                         {   "DiBcom STK807xPVR reference design",
2653                                 { &dib0700_usb_id_table[61], NULL },
2654                                 { NULL },
2655                         },
2656                 },
2657
2658                 .rc_interval      = DEFAULT_RC_INTERVAL,
2659                 .rc_key_map       = dib0700_rc_keys,
2660                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2661                 .rc_query         = dib0700_rc_query
2662         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2663                 .num_adapters = 1,
2664                 .adapter = {
2665                         {
2666                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
2667                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2668                                 .pid_filter_count = 32,
2669                                 .pid_filter = stk80xx_pid_filter,
2670                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2671                                 .frontend_attach  = stk809x_frontend_attach,
2672                                 .tuner_attach     = dib809x_tuner_attach,
2673
2674                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2675
2676                                 .size_of_priv =
2677                                         sizeof(struct dib0700_adapter_state),
2678                         },
2679                 },
2680
2681                 .num_device_descs = 1,
2682                 .devices = {
2683                         {   "DiBcom STK8096GP reference design",
2684                                 { &dib0700_usb_id_table[67], NULL },
2685                                 { NULL },
2686                         },
2687                 },
2688
2689                 .rc_interval      = DEFAULT_RC_INTERVAL,
2690                 .rc_key_map       = dib0700_rc_keys,
2691                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2692                 .rc_query         = dib0700_rc_query
2693         },
2694 };
2695
2696 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);