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