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