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 /*
 477  * This function is used only when firmware is < 1.20 version. Newer
 478  * firmwares use bulk mode, with functions implemented at dib0700_core,
 479  * at dib0700_rc_urb_completion()
 480  */
 481 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 482 {
 483         u8 key[4];
 484         u32 keycode;
 485         u8 toggle;
 486         int i;
 487         struct dib0700_state *st = d->priv;
 488
 489         if (st->fw_version >= 0x10200) {
 490                 /* For 1.20 firmware , We need to keep the RC polling
 491                    callback so we can reuse the input device setup in
 492                    dvb-usb-remote.c.  However, the actual work is being done
 493                    in the bulk URB completion handler. */
 494                 return 0;
 495         }
 496
 497         i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
 498         if (i <= 0) {
 499                 err("RC Query Failed");
 500                 return -1;
 501         }
 502
 503         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 504         if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
 505                 return 0;
 506
 507         /* 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]);  */
 508
 509         dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
 510
 511         d->last_event = 0;
 512         switch (d->props.rc.core.protocol) {
 513         case IR_TYPE_NEC:
 514                 /* NEC protocol sends repeat code as 0 0 0 FF */
 515                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
 516                     (key[3] == 0xff))
 517                         keycode = d->last_event;
 518                 else {
 519                         keycode = key[3-2] << 8 | key[3-3];
 520                         d->last_event = keycode;
 521                 }
 522
 523                 ir_keydown(d->rc_input_dev, keycode, 0);
 524                 break;
 525         default:
 526                 /* RC-5 protocol changes toggle bit on new keypress */
 527                 keycode = key[3-2] << 8 | key[3-3];
 528                 toggle = key[3-1];
 529                 ir_keydown(d->rc_input_dev, keycode, toggle);
 530
 531                 break;
 532         }
 533         return 0;
 534 }
 535
 536 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 537 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 538         BAND_UHF | BAND_VHF,
 539
 540         /* 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,
 541          * 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 */
 542         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 543         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 544
 545         712,
 546         41,
 547
 548         0,
 549         118,
 550
 551         0,
 552         4095,
 553         0,
 554         0,
 555
 556         42598,
 557         17694,
 558         45875,
 559         2621,
 560         0,
 561         76,
 562         139,
 563         52,
 564         59,
 565         107,
 566         172,
 567         57,
 568         70,
 569
 570         21,
 571         25,
 572         28,
 573         48,
 574
 575         1,
 576         {  0,
 577            107,
 578            51800,
 579            24700
 580         },
 581 };
 582
 583 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 584         BAND_UHF | BAND_VHF,
 585
 586         /* 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,
 587          * 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 */
 588         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 589         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 590
 591         712,
 592         41,
 593
 594         0,
 595         118,
 596
 597         0,
 598         4095,
 599         0,
 600         0,
 601
 602         42598,
 603         16384,
 604         42598,
 605             0,
 606
 607           0,
 608         137,
 609         255,
 610
 611           0,
 612         255,
 613
 614         0,
 615         0,
 616
 617          0,
 618         41,
 619
 620         15,
 621         25,
 622
 623         28,
 624         48,
 625
 626         0,
 627 };
 628
 629 static struct dibx000_bandwidth_config stk7700p_pll_config = {
 630         60000, 30000,
 631         1, 8, 3, 1, 0,
 632         0, 0, 1, 1, 0,
 633         (3 << 14) | (1 << 12) | (524 << 0),
 634         60258167,
 635         20452225,
 636         30000000,
 637 };
 638
 639 static struct dib7000m_config stk7700p_dib7000m_config = {
 640         .dvbt_mode = 1,
 641         .output_mpeg2_in_188_bytes = 1,
 642         .quartz_direct = 1,
 643
 644         .agc_config_count = 1,
 645         .agc = &stk7700p_7000m_mt2060_agc_config,
 646         .bw  = &stk7700p_pll_config,
 647
 648         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 649         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 650         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 651 };
 652
 653 static struct dib7000p_config stk7700p_dib7000p_config = {
 654         .output_mpeg2_in_188_bytes = 1,
 655
 656         .agc_config_count = 1,
 657         .agc = &stk7700p_7000p_mt2060_agc_config,
 658         .bw  = &stk7700p_pll_config,
 659
 660         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 661         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 662         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 663 };
 664
 665 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 666 {
 667         struct dib0700_state *st = adap->dev->priv;
 668         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 669
 670         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 671         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 672
 673         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 674         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 675
 676         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 677         dib0700_ctrl_clock(adap->dev, 72, 1);
 678         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 679
 680         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 681
 682         st->mt2060_if1[0] = 1220;
 683
 684         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
 685                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 686                 st->is_dib7000pc = 1;
 687         } else
 688                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 689
 690         return adap->fe == NULL ? -ENODEV : 0;
 691 }
 692
 693 static struct mt2060_config stk7700p_mt2060_config = {
 694         0x60
 695 };
 696
 697 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 698 {
 699         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 700         struct dib0700_state *st = adap->dev->priv;
 701         struct i2c_adapter *tun_i2c;
 702         s8 a;
 703         int if1=1220;
 704         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 705                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
 706                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
 707         }
 708         if (st->is_dib7000pc)
 709                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 710         else
 711                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 712
 713         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
 714                 if1) == NULL ? -ENODEV : 0;
 715 }
 716
 717 /* DIB7070 generic */
 718 static struct dibx000_agc_config dib7070_agc_config = {
 719         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 720         /* 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,
 721          * 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 */
 722         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 723         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 724
 725         600,
 726         10,
 727
 728         0,
 729         118,
 730
 731         0,
 732         3530,
 733         1,
 734         5,
 735
 736         65535,
 737                 0,
 738
 739         65535,
 740         0,
 741
 742         0,
 743         40,
 744         183,
 745         206,
 746         255,
 747         72,
 748         152,
 749         88,
 750         90,
 751
 752         17,
 753         27,
 754         23,
 755         51,
 756
 757         0,
 758 };
 759
 760 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 761 {
 762         deb_info("reset: %d", onoff);
 763         return dib7000p_set_gpio(fe, 8, 0, !onoff);
 764 }
 765
 766 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 767 {
 768         deb_info("sleep: %d", onoff);
 769         return dib7000p_set_gpio(fe, 9, 0, onoff);
 770 }
 771
 772 static struct dib0070_config dib7070p_dib0070_config[2] = {
 773         {
 774                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 775                 .reset = dib7070_tuner_reset,
 776                 .sleep = dib7070_tuner_sleep,
 777                 .clock_khz = 12000,
 778                 .clock_pad_drive = 4,
 779                 .charge_pump = 2,
 780         }, {
 781                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 782                 .reset = dib7070_tuner_reset,
 783                 .sleep = dib7070_tuner_sleep,
 784                 .clock_khz = 12000,
 785                 .charge_pump = 2,
 786         }
 787 };
 788
 789 static struct dib0070_config dib7770p_dib0070_config = {
 790          .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 791          .reset = dib7070_tuner_reset,
 792          .sleep = dib7070_tuner_sleep,
 793          .clock_khz = 12000,
 794          .clock_pad_drive = 0,
 795          .flip_chip = 1,
 796          .charge_pump = 2,
 797 };
 798
 799 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
 800 {
 801         struct dvb_usb_adapter *adap = fe->dvb->priv;
 802         struct dib0700_adapter_state *state = adap->priv;
 803
 804         u16 offset;
 805         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 806         switch (band) {
 807                 case BAND_VHF: offset = 950; break;
 808                 case BAND_UHF:
 809                 default: offset = 550; break;
 810         }
 811         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 812         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 813         return state->set_param_save(fe, fep);
 814 }
 815
 816 static int dib7770_set_param_override(struct dvb_frontend *fe,
 817                 struct dvb_frontend_parameters *fep)
 818 {
 819          struct dvb_usb_adapter *adap = fe->dvb->priv;
 820          struct dib0700_adapter_state *state = adap->priv;
 821
 822          u16 offset;
 823          u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 824          switch (band) {
 825          case BAND_VHF:
 826                   dib7000p_set_gpio(fe, 0, 0, 1);
 827                   offset = 850;
 828                   break;
 829          case BAND_UHF:
 830          default:
 831                   dib7000p_set_gpio(fe, 0, 0, 0);
 832                   offset = 250;
 833                   break;
 834          }
 835          deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 836          dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 837          return state->set_param_save(fe, fep);
 838 }
 839
 840 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
 841 {
 842          struct dib0700_adapter_state *st = adap->priv;
 843          struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
 844                          DIBX000_I2C_INTERFACE_TUNER, 1);
 845
 846          if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
 847                                  &dib7770p_dib0070_config) == NULL)
 848                  return -ENODEV;
 849
 850          st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 851          adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
 852          return 0;
 853 }
 854
 855 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 856 {
 857         struct dib0700_adapter_state *st = adap->priv;
 858         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 859
 860         if (adap->id == 0) {
 861                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
 862                         return -ENODEV;
 863         } else {
 864                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
 865                         return -ENODEV;
 866         }
 867
 868         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 869         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
 870         return 0;
 871 }
 872
 873 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
 874 {
 875     return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
 876 }
 877
 878 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 879 {
 880     return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
 881 }
 882
 883 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
 884         60000, 15000,
 885         1, 20, 3, 1, 0,
 886         0, 0, 1, 1, 2,
 887         (3 << 14) | (1 << 12) | (524 << 0),
 888         (0 << 25) | 0,
 889         20452225,
 890         12000000,
 891 };
 892
 893 static struct dib7000p_config dib7070p_dib7000p_config = {
 894         .output_mpeg2_in_188_bytes = 1,
 895
 896         .agc_config_count = 1,
 897         .agc = &dib7070_agc_config,
 898         .bw  = &dib7070_bw_config_12_mhz,
 899         .tuner_is_baseband = 1,
 900         .spur_protect = 1,
 901
 902         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 903         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 904         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 905
 906         .hostbus_diversity = 1,
 907 };
 908
 909 /* STK7070P */
 910 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 911 {
 912         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 913         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 914             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 915                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 916         else
 917                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 918         msleep(10);
 919         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 920         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 921         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 922         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 923
 924         dib0700_ctrl_clock(adap->dev, 72, 1);
 925
 926         msleep(10);
 927         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 928         msleep(10);
 929         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 930
 931         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 932                                      &dib7070p_dib7000p_config) != 0) {
 933                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 934                     __func__);
 935                 return -ENODEV;
 936         }
 937
 938         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 939                 &dib7070p_dib7000p_config);
 940         return adap->fe == NULL ? -ENODEV : 0;
 941 }
 942
 943 /* STK7770P */
 944 static struct dib7000p_config dib7770p_dib7000p_config = {
 945         .output_mpeg2_in_188_bytes = 1,
 946
 947         .agc_config_count = 1,
 948         .agc = &dib7070_agc_config,
 949         .bw  = &dib7070_bw_config_12_mhz,
 950         .tuner_is_baseband = 1,
 951         .spur_protect = 1,
 952
 953         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 954         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 955         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 956
 957         .hostbus_diversity = 1,
 958         .enable_current_mirror = 1,
 959         .disable_sample_and_hold = 0,
 960 };
 961
 962 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
 963 {
 964         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 965         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 966             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 967                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 968         else
 969                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 970         msleep(10);
 971         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 972         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 973         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 974         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 975
 976         dib0700_ctrl_clock(adap->dev, 72, 1);
 977
 978         msleep(10);
 979         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 980         msleep(10);
 981         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 982
 983         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 984                                      &dib7770p_dib7000p_config) != 0) {
 985                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 986                     __func__);
 987                 return -ENODEV;
 988         }
 989
 990         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 991                 &dib7770p_dib7000p_config);
 992         return adap->fe == NULL ? -ENODEV : 0;
 993 }
 994
 995 /* DIB807x generic */
 996 static struct dibx000_agc_config dib807x_agc_config[2] = {
 997         {
 998                 BAND_VHF,
 999                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1000                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1001                  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1002                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1003                  * P_agc_write=0 */
1004                 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1005                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1006                         (0 << 0), /* setup*/
1007
1008                 600, /* inv_gain*/
1009                 10,  /* time_stabiliz*/
1010
1011                 0,  /* alpha_level*/
1012                 118,  /* thlock*/
1013
1014                 0,     /* wbd_inv*/
1015                 3530,  /* wbd_ref*/
1016                 1,     /* wbd_sel*/
1017                 5,     /* wbd_alpha*/
1018
1019                 65535,  /* agc1_max*/
1020                 0,  /* agc1_min*/
1021
1022                 65535,  /* agc2_max*/
1023                 0,      /* agc2_min*/
1024
1025                 0,      /* agc1_pt1*/
1026                 40,     /* agc1_pt2*/
1027                 183,    /* agc1_pt3*/
1028                 206,    /* agc1_slope1*/
1029                 255,    /* agc1_slope2*/
1030                 72,     /* agc2_pt1*/
1031                 152,    /* agc2_pt2*/
1032                 88,     /* agc2_slope1*/
1033                 90,     /* agc2_slope2*/
1034
1035                 17,  /* alpha_mant*/
1036                 27,  /* alpha_exp*/
1037                 23,  /* beta_mant*/
1038                 51,  /* beta_exp*/
1039
1040                 0,  /* perform_agc_softsplit*/
1041         }, {
1042                 BAND_UHF,
1043                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1044                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1045                  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1046                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1047                  * P_agc_write=0 */
1048                 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1049                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1050                         (0 << 0), /* setup */
1051
1052                 600, /* inv_gain*/
1053                 10,  /* time_stabiliz*/
1054
1055                 0,  /* alpha_level*/
1056                 118,  /* thlock*/
1057
1058                 0,     /* wbd_inv*/
1059                 3530,  /* wbd_ref*/
1060                 1,     /* wbd_sel*/
1061                 5,     /* wbd_alpha*/
1062
1063                 65535,  /* agc1_max*/
1064                 0,  /* agc1_min*/
1065
1066                 65535,  /* agc2_max*/
1067                 0,      /* agc2_min*/
1068
1069                 0,      /* agc1_pt1*/
1070                 40,     /* agc1_pt2*/
1071                 183,    /* agc1_pt3*/
1072                 206,    /* agc1_slope1*/
1073                 255,    /* agc1_slope2*/
1074                 72,     /* agc2_pt1*/
1075                 152,    /* agc2_pt2*/
1076                 88,     /* agc2_slope1*/
1077                 90,     /* agc2_slope2*/
1078
1079                 17,  /* alpha_mant*/
1080                 27,  /* alpha_exp*/
1081                 23,  /* beta_mant*/
1082                 51,  /* beta_exp*/
1083
1084                 0,  /* perform_agc_softsplit*/
1085         }
1086 };
1087
1088 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1089         60000, 15000, /* internal, sampling*/
1090         1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1091         0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1092                           ADClkSrc, modulo */
1093         (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1094         (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1095         18179755, /* timf*/
1096         12000000, /* xtal_hz*/
1097 };
1098
1099 static struct dib8000_config dib807x_dib8000_config[2] = {
1100         {
1101                 .output_mpeg2_in_188_bytes = 1,
1102
1103                 .agc_config_count = 2,
1104                 .agc = dib807x_agc_config,
1105                 .pll = &dib807x_bw_config_12_mhz,
1106                 .tuner_is_baseband = 1,
1107
1108                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1109                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1110                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1111
1112                 .hostbus_diversity = 1,
1113                 .div_cfg = 1,
1114                 .agc_control = &dib0070_ctrl_agc_filter,
1115                 .output_mode = OUTMODE_MPEG2_FIFO,
1116                 .drives = 0x2d98,
1117         }, {
1118                 .output_mpeg2_in_188_bytes = 1,
1119
1120                 .agc_config_count = 2,
1121                 .agc = dib807x_agc_config,
1122                 .pll = &dib807x_bw_config_12_mhz,
1123                 .tuner_is_baseband = 1,
1124
1125                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1126                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1127                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1128
1129                 .hostbus_diversity = 1,
1130                 .agc_control = &dib0070_ctrl_agc_filter,
1131                 .output_mode = OUTMODE_MPEG2_FIFO,
1132                 .drives = 0x2d98,
1133         }
1134 };
1135
1136 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1137 {
1138         return dib8000_set_gpio(fe, 5, 0, !onoff);
1139 }
1140
1141 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1142 {
1143         return dib8000_set_gpio(fe, 0, 0, onoff);
1144 }
1145
1146 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1147     { 240,      7},
1148     { 0xffff,   6},
1149 };
1150
1151 static struct dib0070_config dib807x_dib0070_config[2] = {
1152         {
1153                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1154                 .reset = dib80xx_tuner_reset,
1155                 .sleep = dib80xx_tuner_sleep,
1156                 .clock_khz = 12000,
1157                 .clock_pad_drive = 4,
1158                 .vga_filter = 1,
1159                 .force_crystal_mode = 1,
1160                 .enable_third_order_filter = 1,
1161                 .charge_pump = 0,
1162                 .wbd_gain = dib8070_wbd_gain_cfg,
1163                 .osc_buffer_state = 0,
1164                 .freq_offset_khz_uhf = -100,
1165                 .freq_offset_khz_vhf = -100,
1166         }, {
1167                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1168                 .reset = dib80xx_tuner_reset,
1169                 .sleep = dib80xx_tuner_sleep,
1170                 .clock_khz = 12000,
1171                 .clock_pad_drive = 2,
1172                 .vga_filter = 1,
1173                 .force_crystal_mode = 1,
1174                 .enable_third_order_filter = 1,
1175                 .charge_pump = 0,
1176                 .wbd_gain = dib8070_wbd_gain_cfg,
1177                 .osc_buffer_state = 0,
1178                 .freq_offset_khz_uhf = -25,
1179                 .freq_offset_khz_vhf = -25,
1180         }
1181 };
1182
1183 static int dib807x_set_param_override(struct dvb_frontend *fe,
1184                 struct dvb_frontend_parameters *fep)
1185 {
1186         struct dvb_usb_adapter *adap = fe->dvb->priv;
1187         struct dib0700_adapter_state *state = adap->priv;
1188
1189         u16 offset = dib0070_wbd_offset(fe);
1190         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1191         switch (band) {
1192         case BAND_VHF:
1193                 offset += 750;
1194                 break;
1195         case BAND_UHF:  /* fall-thru wanted */
1196         default:
1197                 offset += 250; break;
1198         }
1199         deb_info("WBD for DiB8000: %d\n", offset);
1200         dib8000_set_wbd_ref(fe, offset);
1201
1202         return state->set_param_save(fe, fep);
1203 }
1204
1205 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1206 {
1207         struct dib0700_adapter_state *st = adap->priv;
1208         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1209                         DIBX000_I2C_INTERFACE_TUNER, 1);
1210
1211         if (adap->id == 0) {
1212                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1213                                 &dib807x_dib0070_config[0]) == NULL)
1214                         return -ENODEV;
1215         } else {
1216                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1217                                 &dib807x_dib0070_config[1]) == NULL)
1218                         return -ENODEV;
1219         }
1220
1221         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1222         adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1223         return 0;
1224 }
1225
1226 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1227         u16 pid, int onoff)
1228 {
1229     return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1230 }
1231
1232 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1233         int onoff)
1234 {
1235     return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1236 }
1237
1238 /* STK807x */
1239 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1240 {
1241         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1242         msleep(10);
1243         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1244         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1245         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1246
1247         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1248
1249         dib0700_ctrl_clock(adap->dev, 72, 1);
1250
1251         msleep(10);
1252         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1253         msleep(10);
1254         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1255
1256         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1257                                 0x80);
1258
1259         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1260                               &dib807x_dib8000_config[0]);
1261
1262         return adap->fe == NULL ?  -ENODEV : 0;
1263 }
1264
1265 /* STK807xPVR */
1266 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1267 {
1268         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1269         msleep(30);
1270         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1271         msleep(500);
1272         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1273         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1274         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1275
1276         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1277
1278         dib0700_ctrl_clock(adap->dev, 72, 1);
1279
1280         msleep(10);
1281         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1282         msleep(10);
1283         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1284
1285         /* initialize IC 0 */
1286         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1287
1288         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1289                               &dib807x_dib8000_config[0]);
1290
1291         return adap->fe == NULL ? -ENODEV : 0;
1292 }
1293
1294 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1295 {
1296         /* initialize IC 1 */
1297         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1298
1299         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1300                               &dib807x_dib8000_config[1]);
1301
1302         return adap->fe == NULL ? -ENODEV : 0;
1303 }
1304
1305 /* STK8096GP */
1306 struct dibx000_agc_config dib8090_agc_config[2] = {
1307     {
1308         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1309         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1310      * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1311      * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1312         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1313         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1314
1315         787,
1316         10,
1317
1318         0,
1319         118,
1320
1321         0,
1322         3530,
1323         1,
1324         5,
1325
1326         65535,
1327         0,
1328
1329         65535,
1330         0,
1331
1332         0,
1333         32,
1334         114,
1335         143,
1336         144,
1337         114,
1338         227,
1339         116,
1340         117,
1341
1342         28,
1343         26,
1344         31,
1345         51,
1346
1347         0,
1348     },
1349     {
1350         BAND_CBAND,
1351         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1352      * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1353      * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1354         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1355         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1356
1357         787,
1358         10,
1359
1360         0,
1361         118,
1362
1363         0,
1364         3530,
1365         1,
1366         5,
1367
1368         0,
1369         0,
1370
1371         65535,
1372         0,
1373
1374         0,
1375         32,
1376         114,
1377         143,
1378         144,
1379         114,
1380         227,
1381         116,
1382         117,
1383
1384         28,
1385         26,
1386         31,
1387         51,
1388
1389         0,
1390     }
1391 };
1392
1393 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1394     54000, 13500,
1395     1, 18, 3, 1, 0,
1396     0, 0, 1, 1, 2,
1397     (3 << 14) | (1 << 12) | (599 << 0),
1398     (0 << 25) | 0,
1399     20199727,
1400     12000000,
1401 };
1402
1403 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1404 {
1405     return dib8000_get_adc_power(fe, 1);
1406 }
1407
1408 static struct dib8000_config dib809x_dib8000_config = {
1409     .output_mpeg2_in_188_bytes = 1,
1410
1411     .agc_config_count = 2,
1412     .agc = dib8090_agc_config,
1413     .agc_control = dib0090_dcc_freq,
1414     .pll = &dib8090_pll_config_12mhz,
1415     .tuner_is_baseband = 1,
1416
1417     .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1418     .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1419     .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1420
1421     .hostbus_diversity = 1,
1422     .div_cfg = 0x31,
1423     .output_mode = OUTMODE_MPEG2_FIFO,
1424     .drives = 0x2d98,
1425     .diversity_delay = 144,
1426     .refclksel = 3,
1427 };
1428
1429 static struct dib0090_config dib809x_dib0090_config = {
1430     .io.pll_bypass = 1,
1431     .io.pll_range = 1,
1432     .io.pll_prediv = 1,
1433     .io.pll_loopdiv = 20,
1434     .io.adc_clock_ratio = 8,
1435     .io.pll_int_loop_filt = 0,
1436     .io.clock_khz = 12000,
1437     .reset = dib80xx_tuner_reset,
1438     .sleep = dib80xx_tuner_sleep,
1439     .clkouttobamse = 1,
1440     .analog_output = 1,
1441     .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1442     .wbd_vhf_offset = 100,
1443     .wbd_cband_offset = 450,
1444     .use_pwm_agc = 1,
1445     .clkoutdrive = 1,
1446     .get_adc_power = dib8090_get_adc_power,
1447         .freq_offset_khz_uhf = 0,
1448         .freq_offset_khz_vhf = -143,
1449 };
1450
1451 static int dib8096_set_param_override(struct dvb_frontend *fe,
1452                 struct dvb_frontend_parameters *fep)
1453 {
1454     struct dvb_usb_adapter *adap = fe->dvb->priv;
1455     struct dib0700_adapter_state *state = adap->priv;
1456     u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1457     u16 offset;
1458     int ret = 0;
1459     enum frontend_tune_state tune_state = CT_SHUTDOWN;
1460     u16 ltgain, rf_gain_limit;
1461
1462     ret = state->set_param_save(fe, fep);
1463     if (ret < 0)
1464         return ret;
1465
1466     switch (band) {
1467     case BAND_VHF:
1468             offset = 100;
1469             break;
1470     case BAND_UHF:
1471             offset = 550;
1472             break;
1473     default:
1474             offset = 0;
1475             break;
1476     }
1477     offset += (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1478     dib8000_set_wbd_ref(fe, offset);
1479
1480
1481     if (band == BAND_CBAND) {
1482         deb_info("tuning in CBAND - soft-AGC startup\n");
1483         /* TODO specific wbd target for dib0090 - needed for startup ? */
1484         dib0090_set_tune_state(fe, CT_AGC_START);
1485         do {
1486                 ret = dib0090_gain_control(fe);
1487                 msleep(ret);
1488                 tune_state = dib0090_get_tune_state(fe);
1489                 if (tune_state == CT_AGC_STEP_0)
1490                         dib8000_set_gpio(fe, 6, 0, 1);
1491                 else if (tune_state == CT_AGC_STEP_1) {
1492                         dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1493                         if (rf_gain_limit == 0)
1494                                 dib8000_set_gpio(fe, 6, 0, 0);
1495                 }
1496         } while (tune_state < CT_AGC_STOP);
1497         dib0090_pwm_gain_reset(fe);
1498         dib8000_pwm_agc_reset(fe);
1499         dib8000_set_tune_state(fe, CT_DEMOD_START);
1500     } else {
1501         deb_info("not tuning in CBAND - standard AGC startup\n");
1502         dib0090_pwm_gain_reset(fe);
1503     }
1504
1505     return 0;
1506 }
1507
1508 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1509 {
1510     struct dib0700_adapter_state *st = adap->priv;
1511     struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1512
1513     if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1514         return -ENODEV;
1515
1516     st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1517     adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1518     return 0;
1519 }
1520
1521 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1522 {
1523         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1524         msleep(10);
1525         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1526         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1527         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1528
1529         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1530
1531         dib0700_ctrl_clock(adap->dev, 72, 1);
1532
1533         msleep(10);
1534         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1535         msleep(10);
1536         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1537
1538         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1539
1540         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config);
1541
1542         return adap->fe == NULL ?  -ENODEV : 0;
1543 }
1544
1545 /* STK7070PD */
1546 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1547         {
1548                 .output_mpeg2_in_188_bytes = 1,
1549
1550                 .agc_config_count = 1,
1551                 .agc = &dib7070_agc_config,
1552                 .bw  = &dib7070_bw_config_12_mhz,
1553                 .tuner_is_baseband = 1,
1554                 .spur_protect = 1,
1555
1556                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1557                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1558                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1559
1560                 .hostbus_diversity = 1,
1561         }, {
1562                 .output_mpeg2_in_188_bytes = 1,
1563
1564                 .agc_config_count = 1,
1565                 .agc = &dib7070_agc_config,
1566                 .bw  = &dib7070_bw_config_12_mhz,
1567                 .tuner_is_baseband = 1,
1568                 .spur_protect = 1,
1569
1570                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1571                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1572                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1573
1574                 .hostbus_diversity = 1,
1575         }
1576 };
1577
1578 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1579 {
1580         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1581         msleep(10);
1582         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1583         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1584         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1585         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1586
1587         dib0700_ctrl_clock(adap->dev, 72, 1);
1588
1589         msleep(10);
1590         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1591         msleep(10);
1592         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1593
1594         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
1595                                      stk7070pd_dib7000p_config) != 0) {
1596                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1597                     __func__);
1598                 return -ENODEV;
1599         }
1600
1601         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1602         return adap->fe == NULL ? -ENODEV : 0;
1603 }
1604
1605 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1606 {
1607         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1608         return adap->fe == NULL ? -ENODEV : 0;
1609 }
1610
1611 /* S5H1411 */
1612 static struct s5h1411_config pinnacle_801e_config = {
1613         .output_mode   = S5H1411_PARALLEL_OUTPUT,
1614         .gpio          = S5H1411_GPIO_OFF,
1615         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1616         .qam_if        = S5H1411_IF_44000,
1617         .vsb_if        = S5H1411_IF_44000,
1618         .inversion     = S5H1411_INVERSION_OFF,
1619         .status_mode   = S5H1411_DEMODLOCKING
1620 };
1621
1622 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1623    GPIO0  - currently unknown
1624    GPIO1  - xc5000 tuner reset
1625    GPIO2  - CX25843 sleep
1626    GPIO3  - currently unknown
1627    GPIO4  - currently unknown
1628    GPIO6  - currently unknown
1629    GPIO7  - currently unknown
1630    GPIO9  - currently unknown
1631    GPIO10 - CX25843 reset
1632  */
1633 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1634 {
1635         struct dib0700_state *st = adap->dev->priv;
1636
1637         /* Make use of the new i2c functions from FW 1.20 */
1638         st->fw_use_new_i2c_api = 1;
1639
1640         /* The s5h1411 requires the dib0700 to not be in master mode */
1641         st->disable_streaming_master_mode = 1;
1642
1643         /* All msleep values taken from Windows USB trace */
1644         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1645         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1646         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1647         msleep(400);
1648         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1649         msleep(60);
1650         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1651         msleep(30);
1652         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1653         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1654         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1655         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1656         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
1657         msleep(30);
1658
1659         /* Put the CX25843 to sleep for now since we're in digital mode */
1660         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
1661
1662         /* GPIOs are initialized, do the attach */
1663         adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
1664                               &adap->dev->i2c_adap);
1665         return adap->fe == NULL ? -ENODEV : 0;
1666 }
1667
1668 static int dib0700_xc5000_tuner_callback(void *priv, int component,
1669                                          int command, int arg)
1670 {
1671         struct dvb_usb_adapter *adap = priv;
1672
1673         if (command == XC5000_TUNER_RESET) {
1674                 /* Reset the tuner */
1675                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
1676                 msleep(10);
1677                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
1678                 msleep(10);
1679         } else {
1680                 err("xc5000: unknown tuner callback command: %d\n", command);
1681                 return -EINVAL;
1682         }
1683
1684         return 0;
1685 }
1686
1687 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
1688         .i2c_address      = 0x64,
1689         .if_khz           = 5380,
1690 };
1691
1692 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
1693 {
1694         /* FIXME: generalize & move to common area */
1695         adap->fe->callback = dib0700_xc5000_tuner_callback;
1696
1697         return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
1698                           &s5h1411_xc5000_tunerconfig)
1699                 == NULL ? -ENODEV : 0;
1700 }
1701
1702 static struct lgdt3305_config hcw_lgdt3305_config = {
1703         .i2c_addr           = 0x0e,
1704         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
1705         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
1706         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
1707         .deny_i2c_rptr      = 0,
1708         .spectral_inversion = 1,
1709         .qam_if_khz         = 6000,
1710         .vsb_if_khz         = 6000,
1711         .usref_8vsb         = 0x0500,
1712 };
1713
1714 static struct mxl5007t_config hcw_mxl5007t_config = {
1715         .xtal_freq_hz = MxL_XTAL_25_MHZ,
1716         .if_freq_hz = MxL_IF_6_MHZ,
1717         .invert_if = 1,
1718 };
1719
1720 /* TIGER-ATSC map:
1721    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
1722    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
1723    GPIO4  - SCL2
1724    GPIO6  - EN_TUNER
1725    GPIO7  - SDA2
1726    GPIO10 - DEM_RST
1727
1728    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
1729  */
1730 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
1731 {
1732         struct dib0700_state *st = adap->dev->priv;
1733
1734         /* Make use of the new i2c functions from FW 1.20 */
1735         st->fw_use_new_i2c_api = 1;
1736
1737         st->disable_streaming_master_mode = 1;
1738
1739         /* fe power enable */
1740         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1741         msleep(30);
1742         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1743         msleep(30);
1744
1745         /* demod reset */
1746         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1747         msleep(30);
1748         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1749         msleep(30);
1750         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1751         msleep(30);
1752
1753         adap->fe = dvb_attach(lgdt3305_attach,
1754                               &hcw_lgdt3305_config,
1755                               &adap->dev->i2c_adap);
1756
1757         return adap->fe == NULL ? -ENODEV : 0;
1758 }
1759
1760 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
1761 {
1762         return dvb_attach(mxl5007t_attach, adap->fe,
1763                           &adap->dev->i2c_adap, 0x60,
1764                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
1765 }
1766
1767
1768 /* DVB-USB and USB stuff follows */
1769 struct usb_device_id dib0700_usb_id_table[] = {
1770 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
1771         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
1772         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
1773         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
1774         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
1775 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
1776         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
1777         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
1778         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
1779         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
1780 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
1781         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
1782         { USB_DEVICE(USB_VID_TERRATEC,
1783                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
1784         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
1785         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
1786 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
1787         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
1788         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
1789         { USB_DEVICE(USB_VID_PINNACLE,
1790                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
1791         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
1792 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
1793         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
1794         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
1795         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
1796         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
1797 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
1798         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
1799         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
1800         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
1801         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
1802 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
1803         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
1804         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
1805         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
1806         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
1807 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
1808         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
1809         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
1810         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
1811         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
1812 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
1813         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
1814         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
1815         { USB_DEVICE(USB_VID_TERRATEC,
1816                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
1817         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
1818 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
1819         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
1820         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
1821         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
1822         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
1823 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
1824         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
1825         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
1826         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
1827         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
1828 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
1829         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
1830         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
1831         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
1832         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
1833 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
1834         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
1835         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
1836         { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
1837         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
1838 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
1839         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
1840         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
1841         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
1842         { 0 }           /* Terminating entry */
1843 };
1844 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
1845
1846 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
1847         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
1848         .usb_ctrl          = DEVICE_SPECIFIC, \
1849         .firmware          = "dvb-usb-dib0700-1.20.fw", \
1850         .download_firmware = dib0700_download_firmware, \
1851         .no_reconnect      = 1, \
1852         .size_of_priv      = sizeof(struct dib0700_state), \
1853         .i2c_algo          = &dib0700_i2c_algo, \
1854         .identify_state    = dib0700_identify_state
1855
1856 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
1857         .streaming_ctrl   = dib0700_streaming_ctrl, \
1858         .stream = { \
1859                 .type = USB_BULK, \
1860                 .count = 4, \
1861                 .endpoint = ep, \
1862                 .u = { \
1863                         .bulk = { \
1864                                 .buffersize = 39480, \
1865                         } \
1866                 } \
1867         }
1868
1869 struct dvb_usb_device_properties dib0700_devices[] = {
1870         {
1871                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
1872
1873                 .num_adapters = 1,
1874                 .adapter = {
1875                         {
1876                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1877                                 .pid_filter_count = 32,
1878                                 .pid_filter       = stk70x0p_pid_filter,
1879                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
1880                                 .frontend_attach  = stk7700p_frontend_attach,
1881                                 .tuner_attach     = stk7700p_tuner_attach,
1882
1883                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1884                         },
1885                 },
1886
1887                 .num_device_descs = 8,
1888                 .devices = {
1889                         {   "DiBcom STK7700P reference design",
1890                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
1891                                 { NULL },
1892                         },
1893                         {   "Hauppauge Nova-T Stick",
1894                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
1895                                 { NULL },
1896                         },
1897                         {   "AVerMedia AVerTV DVB-T Volar",
1898                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
1899                                 { NULL },
1900                         },
1901                         {   "Compro Videomate U500",
1902                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
1903                                 { NULL },
1904                         },
1905                         {   "Uniwill STK7700P based (Hama and others)",
1906                                 { &dib0700_usb_id_table[7], NULL },
1907                                 { NULL },
1908                         },
1909                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
1910                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
1911                                 { NULL },
1912                         },
1913                         {   "AVerMedia AVerTV DVB-T Express",
1914                                 { &dib0700_usb_id_table[20] },
1915                                 { NULL },
1916                         },
1917                         {   "Gigabyte U7000",
1918                                 { &dib0700_usb_id_table[21], NULL },
1919                                 { NULL },
1920                         }
1921                 },
1922
1923                 .rc.core = {
1924                         .rc_interval      = DEFAULT_RC_INTERVAL,
1925                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
1926                         .rc_query         = dib0700_rc_query_old_firmware,
1927                         .rc_props = {
1928                                 .allowed_protos = IR_TYPE_RC5 |
1929                                                   IR_TYPE_RC6 |
1930                                                   IR_TYPE_NEC,
1931                                 .change_protocol = dib0700_change_protocol,
1932                         },
1933                 },
1934         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1935
1936                 .num_adapters = 2,
1937                 .adapter = {
1938                         {
1939                                 .frontend_attach  = bristol_frontend_attach,
1940                                 .tuner_attach     = bristol_tuner_attach,
1941
1942                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1943                         }, {
1944                                 .frontend_attach  = bristol_frontend_attach,
1945                                 .tuner_attach     = bristol_tuner_attach,
1946
1947                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1948                         }
1949                 },
1950
1951                 .num_device_descs = 1,
1952                 .devices = {
1953                         {   "Hauppauge Nova-T 500 Dual DVB-T",
1954                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
1955                                 { NULL },
1956                         },
1957                 },
1958
1959                 .rc.core = {
1960                         .rc_interval      = DEFAULT_RC_INTERVAL,
1961                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
1962                         .rc_query         = dib0700_rc_query_old_firmware,
1963                         .rc_props = {
1964                                 .allowed_protos = IR_TYPE_RC5 |
1965                                                   IR_TYPE_RC6 |
1966                                                   IR_TYPE_NEC,
1967                                 .change_protocol = dib0700_change_protocol,
1968                         },
1969                 },
1970         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1971
1972                 .num_adapters = 2,
1973                 .adapter = {
1974                         {
1975                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1976                                 .pid_filter_count = 32,
1977                                 .pid_filter       = stk70x0p_pid_filter,
1978                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
1979                                 .frontend_attach  = stk7700d_frontend_attach,
1980                                 .tuner_attach     = stk7700d_tuner_attach,
1981
1982                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1983                         }, {
1984                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1985                                 .pid_filter_count = 32,
1986                                 .pid_filter       = stk70x0p_pid_filter,
1987                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
1988                                 .frontend_attach  = stk7700d_frontend_attach,
1989                                 .tuner_attach     = stk7700d_tuner_attach,
1990
1991                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1992                         }
1993                 },
1994
1995                 .num_device_descs = 5,
1996                 .devices = {
1997                         {   "Pinnacle PCTV 2000e",
1998                                 { &dib0700_usb_id_table[11], NULL },
1999                                 { NULL },
2000                         },
2001                         {   "Terratec Cinergy DT XS Diversity",
2002                                 { &dib0700_usb_id_table[12], NULL },
2003                                 { NULL },
2004                         },
2005                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
2006                                 { &dib0700_usb_id_table[13], NULL },
2007                                 { NULL },
2008                         },
2009                         {   "DiBcom STK7700D reference design",
2010                                 { &dib0700_usb_id_table[14], NULL },
2011                                 { NULL },
2012                         },
2013                         {   "YUAN High-Tech DiBcom STK7700D",
2014                                 { &dib0700_usb_id_table[55], NULL },
2015                                 { NULL },
2016                         },
2017
2018                 },
2019
2020                 .rc.core = {
2021                         .rc_interval      = DEFAULT_RC_INTERVAL,
2022                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2023                         .rc_query         = dib0700_rc_query_old_firmware,
2024                         .rc_props = {
2025                                 .allowed_protos = IR_TYPE_RC5 |
2026                                                   IR_TYPE_RC6 |
2027                                                   IR_TYPE_NEC,
2028                                 .change_protocol = dib0700_change_protocol,
2029                         },
2030                 },
2031         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2032
2033                 .num_adapters = 1,
2034                 .adapter = {
2035                         {
2036                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2037                                 .pid_filter_count = 32,
2038                                 .pid_filter       = stk70x0p_pid_filter,
2039                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2040                                 .frontend_attach  = stk7700P2_frontend_attach,
2041                                 .tuner_attach     = stk7700d_tuner_attach,
2042
2043                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2044                         },
2045                 },
2046
2047                 .num_device_descs = 3,
2048                 .devices = {
2049                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
2050                                 { &dib0700_usb_id_table[23], NULL },
2051                                 { NULL },
2052                         },
2053                         {   "Yuan EC372S",
2054                                 { &dib0700_usb_id_table[31], NULL },
2055                                 { NULL },
2056                         },
2057                         {   "Terratec Cinergy T Express",
2058                                 { &dib0700_usb_id_table[42], NULL },
2059                                 { NULL },
2060                         }
2061                 },
2062
2063                 .rc.core = {
2064                         .rc_interval      = DEFAULT_RC_INTERVAL,
2065                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2066                         .module_name      = "dib0700",
2067                         .rc_query         = dib0700_rc_query_old_firmware,
2068                         .rc_props = {
2069                                 .allowed_protos = IR_TYPE_RC5 |
2070                                                   IR_TYPE_RC6 |
2071                                                   IR_TYPE_NEC,
2072                                 .change_protocol = dib0700_change_protocol,
2073                         },
2074                 },
2075         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2076
2077                 .num_adapters = 1,
2078                 .adapter = {
2079                         {
2080                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2081                                 .pid_filter_count = 32,
2082                                 .pid_filter       = stk70x0p_pid_filter,
2083                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2084                                 .frontend_attach  = stk7070p_frontend_attach,
2085                                 .tuner_attach     = dib7070p_tuner_attach,
2086
2087                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2088
2089                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2090                         },
2091                 },
2092
2093                 .num_device_descs = 11,
2094                 .devices = {
2095                         {   "DiBcom STK7070P reference design",
2096                                 { &dib0700_usb_id_table[15], NULL },
2097                                 { NULL },
2098                         },
2099                         {   "Pinnacle PCTV DVB-T Flash Stick",
2100                                 { &dib0700_usb_id_table[16], NULL },
2101                                 { NULL },
2102                         },
2103                         {   "Artec T14BR DVB-T",
2104                                 { &dib0700_usb_id_table[22], NULL },
2105                                 { NULL },
2106                         },
2107                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
2108                                 { &dib0700_usb_id_table[24], NULL },
2109                                 { NULL },
2110                         },
2111                         {   "Hauppauge Nova-T Stick",
2112                                 { &dib0700_usb_id_table[25], NULL },
2113                                 { NULL },
2114                         },
2115                         {   "Hauppauge Nova-T MyTV.t",
2116                                 { &dib0700_usb_id_table[26], NULL },
2117                                 { NULL },
2118                         },
2119                         {   "Pinnacle PCTV 72e",
2120                                 { &dib0700_usb_id_table[29], NULL },
2121                                 { NULL },
2122                         },
2123                         {   "Pinnacle PCTV 73e",
2124                                 { &dib0700_usb_id_table[30], NULL },
2125                                 { NULL },
2126                         },
2127                         {   "Elgato EyeTV DTT",
2128                                 { &dib0700_usb_id_table[49], NULL },
2129                                 { NULL },
2130                         },
2131                         {   "Yuan PD378S",
2132                                 { &dib0700_usb_id_table[45], NULL },
2133                                 { NULL },
2134                         },
2135                         {   "Elgato EyeTV Dtt Dlx PD378S",
2136                                 { &dib0700_usb_id_table[50], NULL },
2137                                 { NULL },
2138                         },
2139                 },
2140
2141                 .rc.core = {
2142                         .rc_interval      = DEFAULT_RC_INTERVAL,
2143                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2144                         .module_name      = "dib0700",
2145                         .rc_query         = dib0700_rc_query_old_firmware,
2146                         .rc_props = {
2147                                 .allowed_protos = IR_TYPE_RC5 |
2148                                                   IR_TYPE_RC6 |
2149                                                   IR_TYPE_NEC,
2150                                 .change_protocol = dib0700_change_protocol,
2151                         },
2152                 },
2153         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2154
2155                 .num_adapters = 1,
2156                 .adapter = {
2157                         {
2158                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2159                                 .pid_filter_count = 32,
2160                                 .pid_filter       = stk70x0p_pid_filter,
2161                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2162                                 .frontend_attach  = stk7070p_frontend_attach,
2163                                 .tuner_attach     = dib7070p_tuner_attach,
2164
2165                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2166
2167                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2168                         },
2169                 },
2170
2171                 .num_device_descs = 3,
2172                 .devices = {
2173                         {   "Pinnacle PCTV 73A",
2174                                 { &dib0700_usb_id_table[56], NULL },
2175                                 { NULL },
2176                         },
2177                         {   "Pinnacle PCTV 73e SE",
2178                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
2179                                 { NULL },
2180                         },
2181                         {   "Pinnacle PCTV 282e",
2182                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
2183                                 { NULL },
2184                         },
2185                 },
2186
2187                 .rc.core = {
2188                         .rc_interval      = DEFAULT_RC_INTERVAL,
2189                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2190                         .module_name      = "dib0700",
2191                         .rc_query         = dib0700_rc_query_old_firmware,
2192                         .rc_props = {
2193                                 .allowed_protos = IR_TYPE_RC5 |
2194                                                   IR_TYPE_RC6 |
2195                                                   IR_TYPE_NEC,
2196                                 .change_protocol = dib0700_change_protocol,
2197                         },
2198                 },
2199         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2200
2201                 .num_adapters = 2,
2202                 .adapter = {
2203                         {
2204                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2205                                 .pid_filter_count = 32,
2206                                 .pid_filter       = stk70x0p_pid_filter,
2207                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2208                                 .frontend_attach  = stk7070pd_frontend_attach0,
2209                                 .tuner_attach     = dib7070p_tuner_attach,
2210
2211                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2212
2213                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2214                         }, {
2215                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2216                                 .pid_filter_count = 32,
2217                                 .pid_filter       = stk70x0p_pid_filter,
2218                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2219                                 .frontend_attach  = stk7070pd_frontend_attach1,
2220                                 .tuner_attach     = dib7070p_tuner_attach,
2221
2222                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2223
2224                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2225                         }
2226                 },
2227
2228                 .num_device_descs = 6,
2229                 .devices = {
2230                         {   "DiBcom STK7070PD reference design",
2231                                 { &dib0700_usb_id_table[17], NULL },
2232                                 { NULL },
2233                         },
2234                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
2235                                 { &dib0700_usb_id_table[18], NULL },
2236                                 { NULL },
2237                         },
2238                         {   "Hauppauge Nova-TD Stick (52009)",
2239                                 { &dib0700_usb_id_table[35], NULL },
2240                                 { NULL },
2241                         },
2242                         {   "Hauppauge Nova-TD-500 (84xxx)",
2243                                 { &dib0700_usb_id_table[36], NULL },
2244                                 { NULL },
2245                         },
2246                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
2247                                 { &dib0700_usb_id_table[43],
2248                                         &dib0700_usb_id_table[53], NULL},
2249                                 { NULL },
2250                         },
2251                         {  "Sony PlayTV",
2252                                 { &dib0700_usb_id_table[44], NULL },
2253                                 { NULL },
2254                         },
2255                 },
2256
2257                 .rc.core = {
2258                         .rc_interval      = DEFAULT_RC_INTERVAL,
2259                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2260                         .module_name      = "dib0700",
2261                         .rc_query         = dib0700_rc_query_old_firmware,
2262                         .rc_props = {
2263                                 .allowed_protos = IR_TYPE_RC5 |
2264                                                   IR_TYPE_RC6 |
2265                                                   IR_TYPE_NEC,
2266                                 .change_protocol = dib0700_change_protocol,
2267                         },
2268                 },
2269         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2270
2271                 .num_adapters = 2,
2272                 .adapter = {
2273                         {
2274                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2275                                 .pid_filter_count = 32,
2276                                 .pid_filter       = stk70x0p_pid_filter,
2277                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2278                                 .frontend_attach  = stk7070pd_frontend_attach0,
2279                                 .tuner_attach     = dib7070p_tuner_attach,
2280
2281                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2282
2283                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2284                         }, {
2285                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2286                                 .pid_filter_count = 32,
2287                                 .pid_filter       = stk70x0p_pid_filter,
2288                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2289                                 .frontend_attach  = stk7070pd_frontend_attach1,
2290                                 .tuner_attach     = dib7070p_tuner_attach,
2291
2292                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2293
2294                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2295                         }
2296                 },
2297
2298                 .num_device_descs = 1,
2299                 .devices = {
2300                         {   "Elgato EyeTV Diversity",
2301                                 { &dib0700_usb_id_table[68], NULL },
2302                                 { NULL },
2303                         },
2304                 },
2305
2306                 .rc.core = {
2307                         .rc_interval      = DEFAULT_RC_INTERVAL,
2308                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
2309                         .module_name      = "dib0700",
2310                         .rc_query         = dib0700_rc_query_old_firmware,
2311                         .rc_props = {
2312                                 .allowed_protos = IR_TYPE_RC5 |
2313                                                   IR_TYPE_RC6 |
2314                                                   IR_TYPE_NEC,
2315                                 .change_protocol = dib0700_change_protocol,
2316                         },
2317                 },
2318         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2319
2320                 .num_adapters = 1,
2321                 .adapter = {
2322                         {
2323                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2324                                 .pid_filter_count = 32,
2325                                 .pid_filter       = stk70x0p_pid_filter,
2326                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2327                                 .frontend_attach  = stk7700ph_frontend_attach,
2328                                 .tuner_attach     = stk7700ph_tuner_attach,
2329
2330                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2331
2332                                 .size_of_priv = sizeof(struct
2333                                                 dib0700_adapter_state),
2334                         },
2335                 },
2336
2337                 .num_device_descs = 9,
2338                 .devices = {
2339                         {   "Terratec Cinergy HT USB XE",
2340                                 { &dib0700_usb_id_table[27], NULL },
2341                                 { NULL },
2342                         },
2343                         {   "Pinnacle Expresscard 320cx",
2344                                 { &dib0700_usb_id_table[28], NULL },
2345                                 { NULL },
2346                         },
2347                         {   "Terratec Cinergy HT Express",
2348                                 { &dib0700_usb_id_table[32], NULL },
2349                                 { NULL },
2350                         },
2351                         {   "Gigabyte U8000-RH",
2352                                 { &dib0700_usb_id_table[37], NULL },
2353                                 { NULL },
2354                         },
2355                         {   "YUAN High-Tech STK7700PH",
2356                                 { &dib0700_usb_id_table[38], NULL },
2357                                 { NULL },
2358                         },
2359                         {   "Asus My Cinema-U3000Hybrid",
2360                                 { &dib0700_usb_id_table[39], NULL },
2361                                 { NULL },
2362                         },
2363                         {   "YUAN High-Tech MC770",
2364                                 { &dib0700_usb_id_table[48], NULL },
2365                                 { NULL },
2366                         },
2367                         {   "Leadtek WinFast DTV Dongle H",
2368                                 { &dib0700_usb_id_table[51], NULL },
2369                                 { NULL },
2370                         },
2371                         {   "YUAN High-Tech STK7700D",
2372                                 { &dib0700_usb_id_table[54], NULL },
2373                                 { NULL },
2374                         },
2375                 },
2376
2377                 .rc.core = {
2378                         .rc_interval      = DEFAULT_RC_INTERVAL,
2379                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2380                         .module_name      = "dib0700",
2381                         .rc_query         = dib0700_rc_query_old_firmware,
2382                         .rc_props = {
2383                                 .allowed_protos = IR_TYPE_RC5 |
2384                                                   IR_TYPE_RC6 |
2385                                                   IR_TYPE_NEC,
2386                                 .change_protocol = dib0700_change_protocol,
2387                         },
2388                 },
2389         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2390                 .num_adapters = 1,
2391                 .adapter = {
2392                         {
2393                                 .frontend_attach  = s5h1411_frontend_attach,
2394                                 .tuner_attach     = xc5000_tuner_attach,
2395
2396                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2397
2398                                 .size_of_priv = sizeof(struct
2399                                                 dib0700_adapter_state),
2400                         },
2401                 },
2402
2403                 .num_device_descs = 2,
2404                 .devices = {
2405                         {   "Pinnacle PCTV HD Pro USB Stick",
2406                                 { &dib0700_usb_id_table[40], NULL },
2407                                 { NULL },
2408                         },
2409                         {   "Pinnacle PCTV HD USB Stick",
2410                                 { &dib0700_usb_id_table[41], NULL },
2411                                 { NULL },
2412                         },
2413                 },
2414
2415                 .rc.core = {
2416                         .rc_interval      = DEFAULT_RC_INTERVAL,
2417                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2418                         .module_name      = "dib0700",
2419                         .rc_query         = dib0700_rc_query_old_firmware,
2420                         .rc_props = {
2421                                 .allowed_protos = IR_TYPE_RC5 |
2422                                                   IR_TYPE_RC6 |
2423                                                   IR_TYPE_NEC,
2424                                 .change_protocol = dib0700_change_protocol,
2425                         },
2426                 },
2427         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2428                 .num_adapters = 1,
2429                 .adapter = {
2430                         {
2431                                 .frontend_attach  = lgdt3305_frontend_attach,
2432                                 .tuner_attach     = mxl5007t_tuner_attach,
2433
2434                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2435
2436                                 .size_of_priv = sizeof(struct
2437                                                 dib0700_adapter_state),
2438                         },
2439                 },
2440
2441                 .num_device_descs = 2,
2442                 .devices = {
2443                         {   "Hauppauge ATSC MiniCard (B200)",
2444                                 { &dib0700_usb_id_table[46], NULL },
2445                                 { NULL },
2446                         },
2447                         {   "Hauppauge ATSC MiniCard (B210)",
2448                                 { &dib0700_usb_id_table[47], NULL },
2449                                 { NULL },
2450                         },
2451                 },
2452         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2453
2454                 .num_adapters = 1,
2455                 .adapter = {
2456                         {
2457                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2458                                 .pid_filter_count = 32,
2459                                 .pid_filter       = stk70x0p_pid_filter,
2460                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2461                                 .frontend_attach  = stk7770p_frontend_attach,
2462                                 .tuner_attach     = dib7770p_tuner_attach,
2463
2464                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2465
2466                                 .size_of_priv =
2467                                         sizeof(struct dib0700_adapter_state),
2468                         },
2469                 },
2470
2471                 .num_device_descs = 2,
2472                 .devices = {
2473                         {   "DiBcom STK7770P reference design",
2474                                 { &dib0700_usb_id_table[59], NULL },
2475                                 { NULL },
2476                         },
2477                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
2478                                 { &dib0700_usb_id_table[33],
2479                                         &dib0700_usb_id_table[52],
2480                                         &dib0700_usb_id_table[60], NULL},
2481                                 { NULL },
2482                         },
2483                 },
2484
2485                 .rc.core = {
2486                         .rc_interval      = DEFAULT_RC_INTERVAL,
2487                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2488                         .module_name      = "dib0700",
2489                         .rc_query         = dib0700_rc_query_old_firmware,
2490                         .rc_props = {
2491                                 .allowed_protos = IR_TYPE_RC5 |
2492                                                   IR_TYPE_RC6 |
2493                                                   IR_TYPE_NEC,
2494                                 .change_protocol = dib0700_change_protocol,
2495                         },
2496                 },
2497         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2498                 .num_adapters = 1,
2499                 .adapter = {
2500                         {
2501                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2502                                 .pid_filter_count = 32,
2503                                 .pid_filter = stk80xx_pid_filter,
2504                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2505                                 .frontend_attach  = stk807x_frontend_attach,
2506                                 .tuner_attach     = dib807x_tuner_attach,
2507
2508                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2509
2510                                 .size_of_priv =
2511                                         sizeof(struct dib0700_adapter_state),
2512                         },
2513                 },
2514
2515                 .num_device_descs = 3,
2516                 .devices = {
2517                         {   "DiBcom STK807xP reference design",
2518                                 { &dib0700_usb_id_table[62], NULL },
2519                                 { NULL },
2520                         },
2521                         {   "Prolink Pixelview SBTVD",
2522                                 { &dib0700_usb_id_table[63], NULL },
2523                                 { NULL },
2524                         },
2525                         {   "EvolutePC TVWay+",
2526                                 { &dib0700_usb_id_table[64], NULL },
2527                                 { NULL },
2528                         },
2529                 },
2530
2531                 .rc.core = {
2532                         .rc_interval      = DEFAULT_RC_INTERVAL,
2533                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
2534                         .module_name      = "dib0700",
2535                         .rc_query         = dib0700_rc_query_old_firmware,
2536                         .rc_props = {
2537                                 .allowed_protos = IR_TYPE_RC5 |
2538                                                   IR_TYPE_RC6 |
2539                                                   IR_TYPE_NEC,
2540                                 .change_protocol = dib0700_change_protocol,
2541                         },
2542                 },
2543         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2544                 .num_adapters = 2,
2545                 .adapter = {
2546                         {
2547                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2548                                 .pid_filter_count = 32,
2549                                 .pid_filter = stk80xx_pid_filter,
2550                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2551                                 .frontend_attach  = stk807xpvr_frontend_attach0,
2552                                 .tuner_attach     = dib807x_tuner_attach,
2553
2554                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2555
2556                                 .size_of_priv =
2557                                         sizeof(struct dib0700_adapter_state),
2558                         },
2559                         {
2560                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2561                                 .pid_filter_count = 32,
2562                                 .pid_filter = stk80xx_pid_filter,
2563                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2564                                 .frontend_attach  = stk807xpvr_frontend_attach1,
2565                                 .tuner_attach     = dib807x_tuner_attach,
2566
2567                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2568
2569                                 .size_of_priv =
2570                                         sizeof(struct dib0700_adapter_state),
2571                         },
2572                 },
2573
2574                 .num_device_descs = 1,
2575                 .devices = {
2576                         {   "DiBcom STK807xPVR reference design",
2577                                 { &dib0700_usb_id_table[61], NULL },
2578                                 { NULL },
2579                         },
2580                 },
2581
2582                 .rc.core = {
2583                         .rc_interval      = DEFAULT_RC_INTERVAL,
2584                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2585                         .module_name      = "dib0700",
2586                         .rc_query         = dib0700_rc_query_old_firmware,
2587                         .rc_props = {
2588                                 .allowed_protos = IR_TYPE_RC5 |
2589                                                   IR_TYPE_RC6 |
2590                                                   IR_TYPE_NEC,
2591                                 .change_protocol = dib0700_change_protocol,
2592                         },
2593                 },
2594         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2595                 .num_adapters = 1,
2596                 .adapter = {
2597                         {
2598                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
2599                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2600                                 .pid_filter_count = 32,
2601                                 .pid_filter = stk80xx_pid_filter,
2602                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2603                                 .frontend_attach  = stk809x_frontend_attach,
2604                                 .tuner_attach     = dib809x_tuner_attach,
2605
2606                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2607
2608                                 .size_of_priv =
2609                                         sizeof(struct dib0700_adapter_state),
2610                         },
2611                 },
2612
2613                 .num_device_descs = 1,
2614                 .devices = {
2615                         {   "DiBcom STK8096GP reference design",
2616                                 { &dib0700_usb_id_table[67], NULL },
2617                                 { NULL },
2618                         },
2619                 },
2620
2621                 .rc.core = {
2622                         .rc_interval      = DEFAULT_RC_INTERVAL,
2623                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
2624                         .module_name      = "dib0700",
2625                         .rc_query         = dib0700_rc_query_old_firmware,
2626                         .rc_props = {
2627                                 .allowed_protos = IR_TYPE_RC5 |
2628                                                   IR_TYPE_RC6 |
2629                                                   IR_TYPE_NEC,
2630                                 .change_protocol = dib0700_change_protocol,
2631                         },
2632                 },
2633         },
2634 };
2635
2636 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);