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