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 "dib0090.h"
  22 #include "lgdt3305.h"
  23 #include "mxl5007t.h"
  24
  25 static int force_lna_activation;
  26 module_param(force_lna_activation, int, 0644);
  27 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
  28                 "if applicable for the device (default: 0=automatic/off).");
  29
  30 struct dib0700_adapter_state {
  31         int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
  32 };
  33
  34 /* Hauppauge Nova-T 500 (aka Bristol)
  35  *  has a LNA on GPIO0 which is enabled by setting 1 */
  36 static struct mt2060_config bristol_mt2060_config[2] = {
  37         {
  38                 .i2c_address = 0x60,
  39                 .clock_out   = 3,
  40         }, {
  41                 .i2c_address = 0x61,
  42         }
  43 };
  44
  45
  46 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  47         .band_caps = BAND_VHF | BAND_UHF,
  48         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  49
  50         .agc1_max = 42598,
  51         .agc1_min = 17694,
  52         .agc2_max = 45875,
  53         .agc2_min = 0,
  54
  55         .agc1_pt1 = 0,
  56         .agc1_pt2 = 59,
  57
  58         .agc1_slope1 = 0,
  59         .agc1_slope2 = 69,
  60
  61         .agc2_pt1 = 0,
  62         .agc2_pt2 = 59,
  63
  64         .agc2_slope1 = 111,
  65         .agc2_slope2 = 28,
  66 };
  67
  68 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  69         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  70                 .max_time     = 0x196,
  71                 .ln_adc_level = 0x1cc7,
  72                 .output_mpeg2_in_188_bytes = 1,
  73         },
  74         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  75                 .max_time     = 0x196,
  76                 .ln_adc_level = 0x1cc7,
  77                 .output_mpeg2_in_188_bytes = 1,
  78         }
  79 };
  80
  81 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  82 {
  83         struct dib0700_state *st = adap->dev->priv;
  84         if (adap->id == 0) {
  85                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  86                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  87                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  88                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  89
  90                 if (force_lna_activation)
  91                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  92                 else
  93                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  94
  95                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
  96                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
  97                         return -ENODEV;
  98                 }
  99         }
 100         st->mt2060_if1[adap->id] = 1220;
 101         return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 102                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 103 }
 104
 105 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 106 {
 107         struct i2c_msg msg[2] = {
 108                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 109                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 110         };
 111         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 112         return 0;
 113 }
 114
 115 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 116 {
 117         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 118         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
 119         s8 a;
 120         int if1=1220;
 121         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 122                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 123                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 124         }
 125         return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
 126                 if1) == NULL ? -ENODEV : 0;
 127 }
 128
 129 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 130
 131 /* MT226x */
 132 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 133         {
 134                 BAND_UHF, // band_caps
 135
 136                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
 137                 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 138                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
 139
 140                 1130,  // inv_gain
 141                 21,  // time_stabiliz
 142
 143                 0,  // alpha_level
 144                 118,  // thlock
 145
 146                 0,     // wbd_inv
 147                 3530,  // wbd_ref
 148                 1,     // wbd_sel
 149                 0,     // wbd_alpha
 150
 151                 65535,  // agc1_max
 152                 33770,  // agc1_min
 153                 65535,  // agc2_max
 154                 23592,  // agc2_min
 155
 156                 0,    // agc1_pt1
 157                 62,   // agc1_pt2
 158                 255,  // agc1_pt3
 159                 64,   // agc1_slope1
 160                 64,   // agc1_slope2
 161                 132,  // agc2_pt1
 162                 192,  // agc2_pt2
 163                 80,   // agc2_slope1
 164                 80,   // agc2_slope2
 165
 166                 17,  // alpha_mant
 167                 27,  // alpha_exp
 168                 23,  // beta_mant
 169                 51,  // beta_exp
 170
 171                 1,  // perform_agc_softsplit
 172         }, {
 173                 BAND_VHF | BAND_LBAND, // band_caps
 174
 175                 /* 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,
 176                 * 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 */
 177                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
 178
 179                 2372, // inv_gain
 180                 21,   // time_stabiliz
 181
 182                 0,    // alpha_level
 183                 118,  // thlock
 184
 185                 0,    // wbd_inv
 186                 3530, // wbd_ref
 187                 1,     // wbd_sel
 188                 0,    // wbd_alpha
 189
 190                 65535, // agc1_max
 191                 0,     // agc1_min
 192                 65535, // agc2_max
 193                 23592, // agc2_min
 194
 195                 0,    // agc1_pt1
 196                 128,  // agc1_pt2
 197                 128,  // agc1_pt3
 198                 128,  // agc1_slope1
 199                 0,    // agc1_slope2
 200                 128,  // agc2_pt1
 201                 253,  // agc2_pt2
 202                 81,   // agc2_slope1
 203                 0,    // agc2_slope2
 204
 205                 17,  // alpha_mant
 206                 27,  // alpha_exp
 207                 23,  // beta_mant
 208                 51,  // beta_exp
 209
 210                 1,  // perform_agc_softsplit
 211         }
 212 };
 213
 214 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 215         60000, 30000, // internal, sampling
 216         1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
 217         0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
 218         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
 219         0, // ifreq
 220         20452225, // timf
 221 };
 222
 223 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 224         {       .output_mpeg2_in_188_bytes = 1,
 225                 .hostbus_diversity = 1,
 226                 .tuner_is_baseband = 1,
 227
 228                 .agc_config_count = 2,
 229                 .agc = stk7700d_7000p_mt2266_agc_config,
 230                 .bw  = &stk7700d_mt2266_pll_config,
 231
 232                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 233                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 234                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 235         },
 236         {       .output_mpeg2_in_188_bytes = 1,
 237                 .hostbus_diversity = 1,
 238                 .tuner_is_baseband = 1,
 239
 240                 .agc_config_count = 2,
 241                 .agc = stk7700d_7000p_mt2266_agc_config,
 242                 .bw  = &stk7700d_mt2266_pll_config,
 243
 244                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 245                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 246                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 247         }
 248 };
 249
 250 static struct mt2266_config stk7700d_mt2266_config[2] = {
 251         {       .i2c_address = 0x60
 252         },
 253         {       .i2c_address = 0x60
 254         }
 255 };
 256
 257 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 258 {
 259         if (adap->id == 0) {
 260                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 261                 msleep(10);
 262                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 263                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 264                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 265                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 266                 msleep(10);
 267                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 268                 msleep(10);
 269                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 270                                              stk7700d_dib7000p_mt2266_config)
 271                     != 0) {
 272                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 273                         return -ENODEV;
 274                 }
 275         }
 276
 277         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 278                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 279
 280         return adap->fe == NULL ? -ENODEV : 0;
 281 }
 282
 283 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 284 {
 285         if (adap->id == 0) {
 286                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 287                 msleep(10);
 288                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 289                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 290                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 291                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 292                 msleep(10);
 293                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 294                 msleep(10);
 295                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 296                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 297                                              stk7700d_dib7000p_mt2266_config)
 298                     != 0) {
 299                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 300                         return -ENODEV;
 301                 }
 302         }
 303
 304         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 305                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 306
 307         return adap->fe == NULL ? -ENODEV : 0;
 308 }
 309
 310 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 311 {
 312         struct i2c_adapter *tun_i2c;
 313         tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 314         return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
 315                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 316 }
 317
 318 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 319 static struct dibx000_agc_config xc3028_agc_config = {
 320         BAND_VHF | BAND_UHF,       /* band_caps */
 321
 322         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 323          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 324          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 325         (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
 326         (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
 327
 328         712,    /* inv_gain */
 329         21,     /* time_stabiliz */
 330
 331         0,      /* alpha_level */
 332         118,    /* thlock */
 333
 334         0,      /* wbd_inv */
 335         2867,   /* wbd_ref */
 336         0,      /* wbd_sel */
 337         2,      /* wbd_alpha */
 338
 339         0,      /* agc1_max */
 340         0,      /* agc1_min */
 341         39718,  /* agc2_max */
 342         9930,   /* agc2_min */
 343         0,      /* agc1_pt1 */
 344         0,      /* agc1_pt2 */
 345         0,      /* agc1_pt3 */
 346         0,      /* agc1_slope1 */
 347         0,      /* agc1_slope2 */
 348         0,      /* agc2_pt1 */
 349         128,    /* agc2_pt2 */
 350         29,     /* agc2_slope1 */
 351         29,     /* agc2_slope2 */
 352
 353         17,     /* alpha_mant */
 354         27,     /* alpha_exp */
 355         23,     /* beta_mant */
 356         51,     /* beta_exp */
 357
 358         1,      /* perform_agc_softsplit */
 359 };
 360
 361 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 362 static struct dibx000_bandwidth_config xc3028_bw_config = {
 363         60000, 30000, /* internal, sampling */
 364         1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
 365         0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
 366                           modulo */
 367         (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 368         (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
 369         20452225, /* timf */
 370         30000000, /* xtal_hz */
 371 };
 372
 373 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 374         .output_mpeg2_in_188_bytes = 1,
 375         .tuner_is_baseband = 1,
 376
 377         .agc_config_count = 1,
 378         .agc = &xc3028_agc_config,
 379         .bw  = &xc3028_bw_config,
 380
 381         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 382         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 383         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 384 };
 385
 386 static int stk7700ph_xc3028_callback(void *ptr, int component,
 387                                      int command, int arg)
 388 {
 389         struct dvb_usb_adapter *adap = ptr;
 390
 391         switch (command) {
 392         case XC2028_TUNER_RESET:
 393                 /* Send the tuner in then out of reset */
 394                 dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
 395                 dib7000p_set_gpio(adap->fe, 8, 0, 1);
 396                 break;
 397         case XC2028_RESET_CLK:
 398                 break;
 399         default:
 400                 err("%s: unknown command %d, arg %d\n", __func__,
 401                         command, arg);
 402                 return -EINVAL;
 403         }
 404         return 0;
 405 }
 406
 407 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
 408         .fname = XC2028_DEFAULT_FIRMWARE,
 409         .max_len = 64,
 410         .demod = XC3028_FE_DIBCOM52,
 411 };
 412
 413 static struct xc2028_config stk7700ph_xc3028_config = {
 414         .i2c_addr = 0x61,
 415         .ctrl = &stk7700ph_xc3028_ctrl,
 416 };
 417
 418 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 419 {
 420         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 421
 422         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 423             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
 424         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 425         else
 426         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 427         msleep(20);
 428         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 429         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 430         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 431         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 432         msleep(10);
 433         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 434         msleep(20);
 435         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 436         msleep(10);
 437
 438         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 439                                      &stk7700ph_dib7700_xc3028_config) != 0) {
 440                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 441                     __func__);
 442                 return -ENODEV;
 443         }
 444
 445         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 446                 &stk7700ph_dib7700_xc3028_config);
 447
 448         return adap->fe == NULL ? -ENODEV : 0;
 449 }
 450
 451 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 452 {
 453         struct i2c_adapter *tun_i2c;
 454
 455         tun_i2c = dib7000p_get_i2c_master(adap->fe,
 456                 DIBX000_I2C_INTERFACE_TUNER, 1);
 457
 458         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
 459
 460         /* FIXME: generalize & move to common area */
 461         adap->fe->callback = stk7700ph_xc3028_callback;
 462
 463         return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
 464                 == NULL ? -ENODEV : 0;
 465 }
 466
 467 #define DEFAULT_RC_INTERVAL 50
 468
 469 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 470
 471 /* Number of keypresses to ignore before start repeating */
 472 #define RC_REPEAT_DELAY 6
 473 #define RC_REPEAT_DELAY_V1_20 10
 474
 475
 476
 477 /* Used by firmware versions < 1.20 (deprecated) */
 478 static int dib0700_rc_query_legacy(struct dvb_usb_device *d, u32 *event,
 479                                    int *state)
 480 {
 481         u8 key[4];
 482         int i;
 483         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
 484         struct dib0700_state *st = d->priv;
 485         *event = 0;
 486         *state = REMOTE_NO_KEY_PRESSED;
 487         i=dib0700_ctrl_rd(d,rc_request,2,key,4);
 488         if (i<=0) {
 489                 err("RC Query Failed");
 490                 return -1;
 491         }
 492
 493         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 494         if (key[0]==0 && key[1]==0 && key[2]==0 && key[3]==0) return 0;
 495
 496         /* 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]);  */
 497
 498         dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
 499
 500         switch (dvb_usb_dib0700_ir_proto) {
 501         case 0: {
 502                 /* NEC protocol sends repeat code as 0 0 0 FF */
 503                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
 504                     (key[3] == 0xFF)) {
 505                         st->rc_counter++;
 506                         if (st->rc_counter > RC_REPEAT_DELAY) {
 507                                 *event = d->last_event;
 508                                 *state = REMOTE_KEY_PRESSED;
 509                                 st->rc_counter = RC_REPEAT_DELAY;
 510                         }
 511                         return 0;
 512                 }
 513                 for (i=0;i<d->props.rc_key_map_size; i++) {
 514                         if (rc5_custom(&keymap[i]) == key[3-2] &&
 515                             rc5_data(&keymap[i]) == key[3-3]) {
 516                                 st->rc_counter = 0;
 517                                 *event = keymap[i].event;
 518                                 *state = REMOTE_KEY_PRESSED;
 519                                 d->last_event = keymap[i].event;
 520                                 return 0;
 521                         }
 522                 }
 523                 break;
 524         }
 525         default: {
 526                 /* RC-5 protocol changes toggle bit on new keypress */
 527                 for (i = 0; i < d->props.rc_key_map_size; i++) {
 528                         if (rc5_custom(&keymap[i]) == key[3-2] &&
 529                             rc5_data(&keymap[i]) == key[3-3]) {
 530                                 if (d->last_event == keymap[i].event &&
 531                                         key[3-1] == st->rc_toggle) {
 532                                         st->rc_counter++;
 533                                         /* prevents unwanted double hits */
 534                                         if (st->rc_counter > RC_REPEAT_DELAY) {
 535                                                 *event = d->last_event;
 536                                                 *state = REMOTE_KEY_PRESSED;
 537                                                 st->rc_counter = RC_REPEAT_DELAY;
 538                                         }
 539
 540                                         return 0;
 541                                 }
 542                                 st->rc_counter = 0;
 543                                 *event = keymap[i].event;
 544                                 *state = REMOTE_KEY_PRESSED;
 545                                 st->rc_toggle = key[3-1];
 546                                 d->last_event = keymap[i].event;
 547                                 return 0;
 548                         }
 549                 }
 550                 break;
 551         }
 552         }
 553         err("Unknown remote controller key: %2X %2X %2X %2X", (int) key[3-2], (int) key[3-3], (int) key[3-1], (int) key[3]);
 554         d->last_event = 0;
 555         return 0;
 556 }
 557
 558 /* This is the structure of the RC response packet starting in firmware 1.20 */
 559 struct dib0700_rc_response {
 560         u8 report_id;
 561         u8 data_state;
 562         u16 system;
 563         u8 data;
 564         u8 not_data;
 565 };
 566
 567 /* This supports the new IR response format for firmware v1.20 */
 568 static int dib0700_rc_query_v1_20(struct dvb_usb_device *d, u32 *event,
 569                                   int *state)
 570 {
 571         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
 572         struct dib0700_state *st = d->priv;
 573         struct dib0700_rc_response poll_reply;
 574         u8 buf[6];
 575         int i;
 576         int status;
 577         int actlen;
 578         int found = 0;
 579
 580         /* Set initial results in case we exit the function early */
 581         *event = 0;
 582         *state = REMOTE_NO_KEY_PRESSED;
 583
 584         /* Firmware v1.20 provides RC data via bulk endpoint 1 */
 585         status = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev, 1), buf,
 586                               sizeof(buf), &actlen, 50);
 587         if (status < 0) {
 588                 /* No data available (meaning no key press) */
 589                 return 0;
 590         }
 591
 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         /* Key codes for the EvolutePC TVWay+ remote (proto NEC) */
 923         { 0x7a00, KEY_MENU },
 924         { 0x7a01, KEY_RECORD },
 925         { 0x7a02, KEY_PLAY },
 926         { 0x7a03, KEY_STOP },
 927         { 0x7a10, KEY_CHANNELUP },
 928         { 0x7a11, KEY_CHANNELDOWN },
 929         { 0x7a12, KEY_VOLUMEUP },
 930         { 0x7a13, KEY_VOLUMEDOWN },
 931         { 0x7a40, KEY_POWER },
 932         { 0x7a41, KEY_MUTE },
 933 };
 934
 935 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 936 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 937         BAND_UHF | BAND_VHF,       // band_caps
 938
 939         /* 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,
 940          * 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 */
 941         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
 942
 943         712,  // inv_gain
 944         41,  // time_stabiliz
 945
 946         0,  // alpha_level
 947         118,  // thlock
 948
 949         0,     // wbd_inv
 950         4095,  // wbd_ref
 951         0,     // wbd_sel
 952         0,     // wbd_alpha
 953
 954         42598,  // agc1_max
 955         17694,  // agc1_min
 956         45875,  // agc2_max
 957         2621,  // agc2_min
 958         0,  // agc1_pt1
 959         76,  // agc1_pt2
 960         139,  // agc1_pt3
 961         52,  // agc1_slope1
 962         59,  // agc1_slope2
 963         107,  // agc2_pt1
 964         172,  // agc2_pt2
 965         57,  // agc2_slope1
 966         70,  // agc2_slope2
 967
 968         21,  // alpha_mant
 969         25,  // alpha_exp
 970         28,  // beta_mant
 971         48,  // beta_exp
 972
 973         1,  // perform_agc_softsplit
 974         {  0,     // split_min
 975            107,   // split_max
 976            51800, // global_split_min
 977            24700  // global_split_max
 978         },
 979 };
 980
 981 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 982         BAND_UHF | BAND_VHF,
 983
 984         /* 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,
 985          * 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 */
 986         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
 987
 988         712, // inv_gain
 989         41,  // time_stabiliz
 990
 991         0,   // alpha_level
 992         118, // thlock
 993
 994         0,    // wbd_inv
 995         4095, // wbd_ref
 996         0,    // wbd_sel
 997         0,    // wbd_alpha
 998
 999         42598, // agc1_max
1000         16384, // agc1_min
1001         42598, // agc2_max
1002             0, // agc2_min
1003
1004           0,   // agc1_pt1
1005         137,   // agc1_pt2
1006         255,   // agc1_pt3
1007
1008           0,   // agc1_slope1
1009         255,   // agc1_slope2
1010
1011         0,     // agc2_pt1
1012         0,     // agc2_pt2
1013
1014          0,    // agc2_slope1
1015         41,    // agc2_slope2
1016
1017         15, // alpha_mant
1018         25, // alpha_exp
1019
1020         28, // beta_mant
1021         48, // beta_exp
1022
1023         0, // perform_agc_softsplit
1024 };
1025
1026 static struct dibx000_bandwidth_config stk7700p_pll_config = {
1027         60000, 30000, // internal, sampling
1028         1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
1029         0, 0, 1, 1, 0, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
1030         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
1031         60258167, // ifreq
1032         20452225, // timf
1033         30000000, // xtal
1034 };
1035
1036 static struct dib7000m_config stk7700p_dib7000m_config = {
1037         .dvbt_mode = 1,
1038         .output_mpeg2_in_188_bytes = 1,
1039         .quartz_direct = 1,
1040
1041         .agc_config_count = 1,
1042         .agc = &stk7700p_7000m_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 struct dib7000p_config stk7700p_dib7000p_config = {
1051         .output_mpeg2_in_188_bytes = 1,
1052
1053         .agc_config_count = 1,
1054         .agc = &stk7700p_7000p_mt2060_agc_config,
1055         .bw  = &stk7700p_pll_config,
1056
1057         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
1058         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
1059         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
1060 };
1061
1062 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
1063 {
1064         struct dib0700_state *st = adap->dev->priv;
1065         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
1066
1067         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1068         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
1069
1070         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
1071         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
1072
1073         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
1074         dib0700_ctrl_clock(adap->dev, 72, 1);
1075         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
1076
1077         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
1078
1079         st->mt2060_if1[0] = 1220;
1080
1081         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
1082                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
1083                 st->is_dib7000pc = 1;
1084         } else
1085                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
1086
1087         return adap->fe == NULL ? -ENODEV : 0;
1088 }
1089
1090 static struct mt2060_config stk7700p_mt2060_config = {
1091         0x60
1092 };
1093
1094 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
1095 {
1096         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
1097         struct dib0700_state *st = adap->dev->priv;
1098         struct i2c_adapter *tun_i2c;
1099         s8 a;
1100         int if1=1220;
1101         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
1102                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
1103                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
1104         }
1105         if (st->is_dib7000pc)
1106                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1107         else
1108                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1109
1110         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
1111                 if1) == NULL ? -ENODEV : 0;
1112 }
1113
1114 /* DIB7070 generic */
1115 static struct dibx000_agc_config dib7070_agc_config = {
1116         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1117         /* 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,
1118          * 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 */
1119         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
1120
1121         600, // inv_gain
1122         10,  // time_stabiliz
1123
1124         0,  // alpha_level
1125         118,  // thlock
1126
1127         0,     // wbd_inv
1128         3530,  // wbd_ref
1129         1,     // wbd_sel
1130         5,     // wbd_alpha
1131
1132         65535,  // agc1_max
1133                 0,  // agc1_min
1134
1135         65535,  // agc2_max
1136         0,      // agc2_min
1137
1138         0,      // agc1_pt1
1139         40,     // agc1_pt2
1140         183,    // agc1_pt3
1141         206,    // agc1_slope1
1142         255,    // agc1_slope2
1143         72,     // agc2_pt1
1144         152,    // agc2_pt2
1145         88,     // agc2_slope1
1146         90,     // agc2_slope2
1147
1148         17,  // alpha_mant
1149         27,  // alpha_exp
1150         23,  // beta_mant
1151         51,  // beta_exp
1152
1153         0,  // perform_agc_softsplit
1154 };
1155
1156 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1157 {
1158         deb_info("reset: %d", onoff);
1159         return dib7000p_set_gpio(fe, 8, 0, !onoff);
1160 }
1161
1162 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1163 {
1164         deb_info("sleep: %d", onoff);
1165         return dib7000p_set_gpio(fe, 9, 0, onoff);
1166 }
1167
1168 static struct dib0070_config dib7070p_dib0070_config[2] = {
1169         {
1170                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1171                 .reset = dib7070_tuner_reset,
1172                 .sleep = dib7070_tuner_sleep,
1173                 .clock_khz = 12000,
1174                 .clock_pad_drive = 4,
1175                 .charge_pump = 2,
1176         }, {
1177                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1178                 .reset = dib7070_tuner_reset,
1179                 .sleep = dib7070_tuner_sleep,
1180                 .clock_khz = 12000,
1181                 .charge_pump = 2,
1182         }
1183 };
1184
1185 static struct dib0070_config dib7770p_dib0070_config = {
1186          .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1187          .reset = dib7070_tuner_reset,
1188          .sleep = dib7070_tuner_sleep,
1189          .clock_khz = 12000,
1190          .clock_pad_drive = 0,
1191          .flip_chip = 1,
1192          .charge_pump = 2,
1193 };
1194
1195 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
1196 {
1197         struct dvb_usb_adapter *adap = fe->dvb->priv;
1198         struct dib0700_adapter_state *state = adap->priv;
1199
1200         u16 offset;
1201         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1202         switch (band) {
1203                 case BAND_VHF: offset = 950; break;
1204                 case BAND_UHF:
1205                 default: offset = 550; break;
1206         }
1207         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1208         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1209         return state->set_param_save(fe, fep);
1210 }
1211
1212 static int dib7770_set_param_override(struct dvb_frontend *fe,
1213                 struct dvb_frontend_parameters *fep)
1214 {
1215          struct dvb_usb_adapter *adap = fe->dvb->priv;
1216          struct dib0700_adapter_state *state = adap->priv;
1217
1218          u16 offset;
1219          u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1220          switch (band) {
1221          case BAND_VHF:
1222                   dib7000p_set_gpio(fe, 0, 0, 1);
1223                   offset = 850;
1224                   break;
1225          case BAND_UHF:
1226          default:
1227                   dib7000p_set_gpio(fe, 0, 0, 0);
1228                   offset = 250;
1229                   break;
1230          }
1231          deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1232          dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1233          return state->set_param_save(fe, fep);
1234 }
1235
1236 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
1237 {
1238          struct dib0700_adapter_state *st = adap->priv;
1239          struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
1240                          DIBX000_I2C_INTERFACE_TUNER, 1);
1241
1242          if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1243                                  &dib7770p_dib0070_config) == NULL)
1244                  return -ENODEV;
1245
1246          st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1247          adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
1248          return 0;
1249 }
1250
1251 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
1252 {
1253         struct dib0700_adapter_state *st = adap->priv;
1254         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1255
1256         if (adap->id == 0) {
1257                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
1258                         return -ENODEV;
1259         } else {
1260                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
1261                         return -ENODEV;
1262         }
1263
1264         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1265         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1266         return 0;
1267 }
1268
1269 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1270 {
1271     return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
1272 }
1273
1274 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1275 {
1276     return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
1277 }
1278
1279 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1280         60000, 15000, // internal, sampling
1281         1, 20, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
1282         0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
1283         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
1284         (0 << 25) | 0, // ifreq = 0.000000 MHz
1285         20452225, // timf
1286         12000000, // xtal_hz
1287 };
1288
1289 static struct dib7000p_config dib7070p_dib7000p_config = {
1290         .output_mpeg2_in_188_bytes = 1,
1291
1292         .agc_config_count = 1,
1293         .agc = &dib7070_agc_config,
1294         .bw  = &dib7070_bw_config_12_mhz,
1295         .tuner_is_baseband = 1,
1296         .spur_protect = 1,
1297
1298         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1299         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1300         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1301
1302         .hostbus_diversity = 1,
1303 };
1304
1305 /* STK7070P */
1306 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
1307 {
1308         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1309         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
1310             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1311                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1312         else
1313                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1314         msleep(10);
1315         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1316         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1317         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1318         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1319
1320         dib0700_ctrl_clock(adap->dev, 72, 1);
1321
1322         msleep(10);
1323         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1324         msleep(10);
1325         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1326
1327         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1328                                      &dib7070p_dib7000p_config) != 0) {
1329                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1330                     __func__);
1331                 return -ENODEV;
1332         }
1333
1334         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1335                 &dib7070p_dib7000p_config);
1336         return adap->fe == NULL ? -ENODEV : 0;
1337 }
1338
1339 /* DIB807x generic */
1340 static struct dibx000_agc_config dib807x_agc_config[2] = {
1341         {
1342                 BAND_VHF,
1343                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1344                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1345                  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1346                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1347                  * P_agc_write=0 */
1348                 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1349                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1350                         (0 << 0), /* setup*/
1351
1352                 600, /* inv_gain*/
1353                 10,  /* time_stabiliz*/
1354
1355                 0,  /* alpha_level*/
1356                 118,  /* thlock*/
1357
1358                 0,     /* wbd_inv*/
1359                 3530,  /* wbd_ref*/
1360                 1,     /* wbd_sel*/
1361                 5,     /* wbd_alpha*/
1362
1363                 65535,  /* agc1_max*/
1364                 0,  /* agc1_min*/
1365
1366                 65535,  /* agc2_max*/
1367                 0,      /* agc2_min*/
1368
1369                 0,      /* agc1_pt1*/
1370                 40,     /* agc1_pt2*/
1371                 183,    /* agc1_pt3*/
1372                 206,    /* agc1_slope1*/
1373                 255,    /* agc1_slope2*/
1374                 72,     /* agc2_pt1*/
1375                 152,    /* agc2_pt2*/
1376                 88,     /* agc2_slope1*/
1377                 90,     /* agc2_slope2*/
1378
1379                 17,  /* alpha_mant*/
1380                 27,  /* alpha_exp*/
1381                 23,  /* beta_mant*/
1382                 51,  /* beta_exp*/
1383
1384                 0,  /* perform_agc_softsplit*/
1385         }, {
1386                 BAND_UHF,
1387                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1388                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1389                  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1390                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1391                  * P_agc_write=0 */
1392                 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1393                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1394                         (0 << 0), /* setup */
1395
1396                 600, /* inv_gain*/
1397                 10,  /* time_stabiliz*/
1398
1399                 0,  /* alpha_level*/
1400                 118,  /* thlock*/
1401
1402                 0,     /* wbd_inv*/
1403                 3530,  /* wbd_ref*/
1404                 1,     /* wbd_sel*/
1405                 5,     /* wbd_alpha*/
1406
1407                 65535,  /* agc1_max*/
1408                 0,  /* agc1_min*/
1409
1410                 65535,  /* agc2_max*/
1411                 0,      /* agc2_min*/
1412
1413                 0,      /* agc1_pt1*/
1414                 40,     /* agc1_pt2*/
1415                 183,    /* agc1_pt3*/
1416                 206,    /* agc1_slope1*/
1417                 255,    /* agc1_slope2*/
1418                 72,     /* agc2_pt1*/
1419                 152,    /* agc2_pt2*/
1420                 88,     /* agc2_slope1*/
1421                 90,     /* agc2_slope2*/
1422
1423                 17,  /* alpha_mant*/
1424                 27,  /* alpha_exp*/
1425                 23,  /* beta_mant*/
1426                 51,  /* beta_exp*/
1427
1428                 0,  /* perform_agc_softsplit*/
1429         }
1430 };
1431
1432 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1433         60000, 15000, /* internal, sampling*/
1434         1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1435         0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1436                           ADClkSrc, modulo */
1437         (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1438         (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1439         18179755, /* timf*/
1440         12000000, /* xtal_hz*/
1441 };
1442
1443 static struct dib8000_config dib807x_dib8000_config[2] = {
1444         {
1445                 .output_mpeg2_in_188_bytes = 1,
1446
1447                 .agc_config_count = 2,
1448                 .agc = dib807x_agc_config,
1449                 .pll = &dib807x_bw_config_12_mhz,
1450                 .tuner_is_baseband = 1,
1451
1452                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1453                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1454                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1455
1456                 .hostbus_diversity = 1,
1457                 .div_cfg = 1,
1458                 .agc_control = &dib0070_ctrl_agc_filter,
1459                 .output_mode = OUTMODE_MPEG2_FIFO,
1460                 .drives = 0x2d98,
1461         }, {
1462                 .output_mpeg2_in_188_bytes = 1,
1463
1464                 .agc_config_count = 2,
1465                 .agc = dib807x_agc_config,
1466                 .pll = &dib807x_bw_config_12_mhz,
1467                 .tuner_is_baseband = 1,
1468
1469                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1470                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1471                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1472
1473                 .hostbus_diversity = 1,
1474                 .agc_control = &dib0070_ctrl_agc_filter,
1475                 .output_mode = OUTMODE_MPEG2_FIFO,
1476                 .drives = 0x2d98,
1477         }
1478 };
1479
1480 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1481 {
1482         return dib8000_set_gpio(fe, 5, 0, !onoff);
1483 }
1484
1485 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1486 {
1487         return dib8000_set_gpio(fe, 0, 0, onoff);
1488 }
1489
1490 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1491     { 240,      7},
1492     { 0xffff,   6},
1493 };
1494
1495 static struct dib0070_config dib807x_dib0070_config[2] = {
1496         {
1497                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1498                 .reset = dib80xx_tuner_reset,
1499                 .sleep = dib80xx_tuner_sleep,
1500                 .clock_khz = 12000,
1501                 .clock_pad_drive = 4,
1502                 .vga_filter = 1,
1503                 .force_crystal_mode = 1,
1504                 .enable_third_order_filter = 1,
1505                 .charge_pump = 0,
1506                 .wbd_gain = dib8070_wbd_gain_cfg,
1507                 .osc_buffer_state = 0,
1508                 .freq_offset_khz_uhf = -100,
1509                 .freq_offset_khz_vhf = -100,
1510         }, {
1511                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1512                 .reset = dib80xx_tuner_reset,
1513                 .sleep = dib80xx_tuner_sleep,
1514                 .clock_khz = 12000,
1515                 .clock_pad_drive = 2,
1516                 .vga_filter = 1,
1517                 .force_crystal_mode = 1,
1518                 .enable_third_order_filter = 1,
1519                 .charge_pump = 0,
1520                 .wbd_gain = dib8070_wbd_gain_cfg,
1521                 .osc_buffer_state = 0,
1522                 .freq_offset_khz_uhf = -25,
1523                 .freq_offset_khz_vhf = -25,
1524         }
1525 };
1526
1527 static int dib807x_set_param_override(struct dvb_frontend *fe,
1528                 struct dvb_frontend_parameters *fep)
1529 {
1530         struct dvb_usb_adapter *adap = fe->dvb->priv;
1531         struct dib0700_adapter_state *state = adap->priv;
1532
1533         u16 offset = dib0070_wbd_offset(fe);
1534         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1535         switch (band) {
1536         case BAND_VHF:
1537                 offset += 750;
1538                 break;
1539         case BAND_UHF:  /* fall-thru wanted */
1540         default:
1541                 offset += 250; break;
1542         }
1543         deb_info("WBD for DiB8000: %d\n", offset);
1544         dib8000_set_wbd_ref(fe, offset);
1545
1546         return state->set_param_save(fe, fep);
1547 }
1548
1549 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1550 {
1551         struct dib0700_adapter_state *st = adap->priv;
1552         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1553                         DIBX000_I2C_INTERFACE_TUNER, 1);
1554
1555         if (adap->id == 0) {
1556                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1557                                 &dib807x_dib0070_config[0]) == NULL)
1558                         return -ENODEV;
1559         } else {
1560                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1561                                 &dib807x_dib0070_config[1]) == NULL)
1562                         return -ENODEV;
1563         }
1564
1565         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1566         adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1567         return 0;
1568 }
1569
1570 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1571 {
1572     return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1573 }
1574
1575 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1576 {
1577     return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1578 }
1579
1580 /* STK807x */
1581 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1582 {
1583         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1584         msleep(10);
1585         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1586         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1587         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1588
1589         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1590
1591         dib0700_ctrl_clock(adap->dev, 72, 1);
1592
1593         msleep(10);
1594         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1595         msleep(10);
1596         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1597
1598         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1599                                 0x80);
1600
1601         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1602                               &dib807x_dib8000_config[0]);
1603
1604         return adap->fe == NULL ?  -ENODEV : 0;
1605 }
1606
1607 /* STK807xPVR */
1608 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1609 {
1610         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1611         msleep(30);
1612         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1613         msleep(500);
1614         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1615         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1616         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1617
1618         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1619
1620         dib0700_ctrl_clock(adap->dev, 72, 1);
1621
1622         msleep(10);
1623         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1624         msleep(10);
1625         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1626
1627         /* initialize IC 0 */
1628         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x80);
1629
1630         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1631                               &dib807x_dib8000_config[0]);
1632
1633         return adap->fe == NULL ? -ENODEV : 0;
1634 }
1635
1636 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1637 {
1638         /* initialize IC 1 */
1639         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x82);
1640
1641         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1642                               &dib807x_dib8000_config[1]);
1643
1644         return adap->fe == NULL ? -ENODEV : 0;
1645 }
1646
1647 /* STK8096GP */
1648 struct dibx000_agc_config dib8090_agc_config[2] = {
1649     {
1650         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1651         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
1652          * 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 */
1653         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
1654
1655         787,// inv_gain = 1/ 90.4dB // no boost, lower gain due to ramp quantification
1656         10,  // time_stabiliz
1657
1658         0,  // alpha_level
1659         118,  // thlock
1660
1661         0,     // wbd_inv
1662         3530,  // wbd_ref
1663         1,     // wbd_sel
1664         5,     // wbd_alpha
1665
1666         65535,  // agc1_max
1667         0,  // agc1_min
1668
1669         65535,  // agc2_max
1670         0,      // agc2_min
1671
1672         0,      // agc1_pt1
1673         32,     // agc1_pt2
1674         114,    // agc1_pt3  // 40.4dB
1675         143,    // agc1_slope1
1676         144,    // agc1_slope2
1677         114,    // agc2_pt1
1678         227,    // agc2_pt2
1679         116,    // agc2_slope1
1680         117,    // agc2_slope2
1681
1682         28,  // alpha_mant // 5Hz with 90.2dB
1683         26,  // alpha_exp
1684         31,  // beta_mant
1685         51,  // beta_exp
1686
1687         0,  // perform_agc_softsplit
1688     },
1689     {
1690         BAND_CBAND,
1691         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
1692          * 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 */
1693         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
1694
1695         787,// inv_gain = 1/ 90.4dB // no boost, lower gain due to ramp quantification
1696         10,  // time_stabiliz
1697
1698         0,  // alpha_level
1699         118,  // thlock
1700
1701         0,     // wbd_inv
1702         3530,  // wbd_ref
1703         1,     // wbd_sel
1704         5,     // wbd_alpha
1705
1706         0,  // agc1_max
1707         0,  // agc1_min
1708
1709         65535,  // agc2_max
1710         0,      // agc2_min
1711
1712         0,      // agc1_pt1
1713         32,     // agc1_pt2
1714         114,    // agc1_pt3  // 40.4dB
1715         143,    // agc1_slope1
1716         144,    // agc1_slope2
1717         114,    // agc2_pt1
1718         227,    // agc2_pt2
1719         116,    // agc2_slope1
1720         117,    // agc2_slope2
1721
1722         28,  // alpha_mant // 5Hz with 90.2dB
1723         26,  // alpha_exp
1724         31,  // beta_mant
1725         51,  // beta_exp
1726
1727         0,  // perform_agc_softsplit
1728     }
1729 };
1730
1731 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1732     54000, 13500, // internal, sampling
1733     1, 18, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
1734     0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
1735     (3 << 14) | (1 << 12) | (599 << 0), // sad_cfg: refsel, sel, freq_15k
1736     (0 << 25) | 0, // ifreq = 0 MHz
1737     20199727, // timf
1738     12000000, // xtal_hz
1739 };
1740
1741 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1742 {
1743     return dib8000_get_adc_power(fe, 1);
1744 }
1745
1746 static struct dib8000_config dib809x_dib8000_config = {
1747     .output_mpeg2_in_188_bytes = 1,
1748
1749     .agc_config_count = 2,
1750     .agc = dib8090_agc_config,
1751     .agc_control = dib0090_dcc_freq,
1752     .pll = &dib8090_pll_config_12mhz,
1753     .tuner_is_baseband = 1,
1754
1755     .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1756     .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1757     .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1758
1759     .hostbus_diversity = 1,
1760     .div_cfg = 0x31,
1761     .output_mode = OUTMODE_MPEG2_FIFO,
1762     .drives = 0x2d98,
1763     .diversity_delay = 144,
1764     .refclksel = 3,
1765 };
1766
1767 static struct dib0090_config dib809x_dib0090_config = {
1768     .io.pll_bypass = 1,
1769     .io.pll_range = 1,
1770     .io.pll_prediv = 1,
1771     .io.pll_loopdiv = 20,
1772     .io.adc_clock_ratio = 8,
1773     .io.pll_int_loop_filt = 0,
1774     .io.clock_khz = 12000,
1775     .reset = dib80xx_tuner_reset,
1776     .sleep = dib80xx_tuner_sleep,
1777     .clkouttobamse = 1,
1778     .analog_output = 1,
1779     .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1780     .wbd_vhf_offset = 100,
1781     .wbd_cband_offset = 450,
1782     .use_pwm_agc = 1,
1783     .clkoutdrive = 1,
1784     .get_adc_power = dib8090_get_adc_power,
1785         .freq_offset_khz_uhf = 0,
1786         .freq_offset_khz_vhf = -143,
1787 };
1788
1789 static int dib8096_set_param_override(struct dvb_frontend *fe,
1790                 struct dvb_frontend_parameters *fep)
1791 {
1792     struct dvb_usb_adapter *adap = fe->dvb->priv;
1793     struct dib0700_adapter_state *state = adap->priv;
1794     u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1795     u16 offset;
1796     int ret = 0;
1797     enum frontend_tune_state tune_state = CT_SHUTDOWN;
1798     u16 ltgain, rf_gain_limit;
1799
1800     ret = state->set_param_save(fe, fep);
1801     if (ret < 0)
1802         return ret;
1803
1804     switch (band) {
1805         case BAND_VHF:
1806             offset = 100;
1807             break;
1808         case BAND_UHF:
1809             offset = 550;
1810             break;
1811         default:
1812             offset = 0;
1813             break;
1814     }
1815     offset += (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1816     dib8000_set_wbd_ref(fe, offset);
1817
1818
1819     if (band == BAND_CBAND)
1820     {
1821         deb_info("tuning in CBAND - soft-AGC startup\n");
1822         /* TODO specific wbd target for dib0090 - needed for startup ? */
1823         dib0090_set_tune_state(fe, CT_AGC_START);
1824         do
1825         {
1826             ret = dib0090_gain_control(fe);
1827             msleep(ret);
1828             tune_state = dib0090_get_tune_state(fe);
1829             if (tune_state == CT_AGC_STEP_0)
1830                 dib8000_set_gpio(fe, 6, 0, 1);
1831             else if (tune_state == CT_AGC_STEP_1)
1832             {
1833                 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1834                 if (rf_gain_limit == 0)
1835                     dib8000_set_gpio(fe, 6, 0, 0);
1836             }
1837         }
1838         while(tune_state<CT_AGC_STOP);
1839         dib0090_pwm_gain_reset(fe);
1840         dib8000_pwm_agc_reset(fe);
1841         dib8000_set_tune_state(fe, CT_DEMOD_START);
1842     }
1843     else {
1844         deb_info("not tuning in CBAND - standard AGC startup\n");
1845         dib0090_pwm_gain_reset(fe);
1846     }
1847
1848     return 0;
1849 }
1850
1851 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1852 {
1853     struct dib0700_adapter_state *st = adap->priv;
1854     struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1855
1856     if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1857         return -ENODEV;
1858
1859     st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1860     adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1861     return 0;
1862 }
1863
1864 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1865 {
1866         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1867         msleep(10);
1868         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1869         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1870         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1871
1872         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1873
1874         dib0700_ctrl_clock(adap->dev, 72, 1);
1875
1876         msleep(10);
1877         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1878         msleep(10);
1879         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1880
1881         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1882
1883         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config);
1884
1885         return adap->fe == NULL ?  -ENODEV : 0;
1886 }
1887
1888 /* STK7070PD */
1889 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1890         {
1891                 .output_mpeg2_in_188_bytes = 1,
1892
1893                 .agc_config_count = 1,
1894                 .agc = &dib7070_agc_config,
1895                 .bw  = &dib7070_bw_config_12_mhz,
1896                 .tuner_is_baseband = 1,
1897                 .spur_protect = 1,
1898
1899                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1900                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1901                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1902
1903                 .hostbus_diversity = 1,
1904         }, {
1905                 .output_mpeg2_in_188_bytes = 1,
1906
1907                 .agc_config_count = 1,
1908                 .agc = &dib7070_agc_config,
1909                 .bw  = &dib7070_bw_config_12_mhz,
1910                 .tuner_is_baseband = 1,
1911                 .spur_protect = 1,
1912
1913                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1914                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1915                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1916
1917                 .hostbus_diversity = 1,
1918         }
1919 };
1920
1921 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1922 {
1923         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1924         msleep(10);
1925         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1926         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1927         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1928         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1929
1930         dib0700_ctrl_clock(adap->dev, 72, 1);
1931
1932         msleep(10);
1933         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1934         msleep(10);
1935         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1936
1937         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
1938                                      stk7070pd_dib7000p_config) != 0) {
1939                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1940                     __func__);
1941                 return -ENODEV;
1942         }
1943
1944         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1945         return adap->fe == NULL ? -ENODEV : 0;
1946 }
1947
1948 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1949 {
1950         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1951         return adap->fe == NULL ? -ENODEV : 0;
1952 }
1953
1954 /* S5H1411 */
1955 static struct s5h1411_config pinnacle_801e_config = {
1956         .output_mode   = S5H1411_PARALLEL_OUTPUT,
1957         .gpio          = S5H1411_GPIO_OFF,
1958         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1959         .qam_if        = S5H1411_IF_44000,
1960         .vsb_if        = S5H1411_IF_44000,
1961         .inversion     = S5H1411_INVERSION_OFF,
1962         .status_mode   = S5H1411_DEMODLOCKING
1963 };
1964
1965 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1966    GPIO0  - currently unknown
1967    GPIO1  - xc5000 tuner reset
1968    GPIO2  - CX25843 sleep
1969    GPIO3  - currently unknown
1970    GPIO4  - currently unknown
1971    GPIO6  - currently unknown
1972    GPIO7  - currently unknown
1973    GPIO9  - currently unknown
1974    GPIO10 - CX25843 reset
1975  */
1976 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1977 {
1978         struct dib0700_state *st = adap->dev->priv;
1979
1980         /* Make use of the new i2c functions from FW 1.20 */
1981         st->fw_use_new_i2c_api = 1;
1982
1983         /* The s5h1411 requires the dib0700 to not be in master mode */
1984         st->disable_streaming_master_mode = 1;
1985
1986         /* All msleep values taken from Windows USB trace */
1987         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1988         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1989         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1990         msleep(400);
1991         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1992         msleep(60);
1993         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1994         msleep(30);
1995         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1996         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1997         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1998         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1999         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
2000         msleep(30);
2001
2002         /* Put the CX25843 to sleep for now since we're in digital mode */
2003         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
2004
2005         /* GPIOs are initialized, do the attach */
2006         adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
2007                               &adap->dev->i2c_adap);
2008         return adap->fe == NULL ? -ENODEV : 0;
2009 }
2010
2011 static int dib0700_xc5000_tuner_callback(void *priv, int component,
2012                                          int command, int arg)
2013 {
2014         struct dvb_usb_adapter *adap = priv;
2015
2016         if (command == XC5000_TUNER_RESET) {
2017                 /* Reset the tuner */
2018                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
2019                 msleep(10);
2020                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
2021                 msleep(10);
2022         } else {
2023                 err("xc5000: unknown tuner callback command: %d\n", command);
2024                 return -EINVAL;
2025         }
2026
2027         return 0;
2028 }
2029
2030 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
2031         .i2c_address      = 0x64,
2032         .if_khz           = 5380,
2033 };
2034
2035 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
2036 {
2037         /* FIXME: generalize & move to common area */
2038         adap->fe->callback = dib0700_xc5000_tuner_callback;
2039
2040         return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
2041                           &s5h1411_xc5000_tunerconfig)
2042                 == NULL ? -ENODEV : 0;
2043 }
2044
2045 static struct lgdt3305_config hcw_lgdt3305_config = {
2046         .i2c_addr           = 0x0e,
2047         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
2048         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
2049         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
2050         .deny_i2c_rptr      = 0,
2051         .spectral_inversion = 1,
2052         .qam_if_khz         = 6000,
2053         .vsb_if_khz         = 6000,
2054         .usref_8vsb         = 0x0500,
2055 };
2056
2057 static struct mxl5007t_config hcw_mxl5007t_config = {
2058         .xtal_freq_hz = MxL_XTAL_25_MHZ,
2059         .if_freq_hz = MxL_IF_6_MHZ,
2060         .invert_if = 1,
2061 };
2062
2063 /* TIGER-ATSC map:
2064    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
2065    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
2066    GPIO4  - SCL2
2067    GPIO6  - EN_TUNER
2068    GPIO7  - SDA2
2069    GPIO10 - DEM_RST
2070
2071    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
2072  */
2073 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
2074 {
2075         struct dib0700_state *st = adap->dev->priv;
2076
2077         /* Make use of the new i2c functions from FW 1.20 */
2078         st->fw_use_new_i2c_api = 1;
2079
2080         st->disable_streaming_master_mode = 1;
2081
2082         /* fe power enable */
2083         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
2084         msleep(30);
2085         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2086         msleep(30);
2087
2088         /* demod reset */
2089         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2090         msleep(30);
2091         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2092         msleep(30);
2093         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2094         msleep(30);
2095
2096         adap->fe = dvb_attach(lgdt3305_attach,
2097                               &hcw_lgdt3305_config,
2098                               &adap->dev->i2c_adap);
2099
2100         return adap->fe == NULL ? -ENODEV : 0;
2101 }
2102
2103 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
2104 {
2105         return dvb_attach(mxl5007t_attach, adap->fe,
2106                           &adap->dev->i2c_adap, 0x60,
2107                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
2108 }
2109
2110
2111 /* DVB-USB and USB stuff follows */
2112 struct usb_device_id dib0700_usb_id_table[] = {
2113 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
2114         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
2115         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
2116         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
2117         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
2118 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
2119         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
2120         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
2121         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
2122         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
2123 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
2124         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
2125         { USB_DEVICE(USB_VID_TERRATEC,
2126                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
2127         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
2128         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
2129 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
2130         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
2131         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
2132         { USB_DEVICE(USB_VID_PINNACLE,
2133                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
2134         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
2135 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
2136         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
2137         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
2138         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
2139         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
2140 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
2141         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
2142         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
2143         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
2144         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
2145 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
2146         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
2147         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
2148         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
2149         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
2150 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
2151         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
2152         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
2153         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
2154         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
2155 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
2156         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
2157         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
2158         { USB_DEVICE(USB_VID_TERRATEC,
2159                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
2160         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
2161 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
2162         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
2163         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
2164         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
2165         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
2166 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
2167         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
2168         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
2169         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
2170         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
2171 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
2172         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
2173         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
2174         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
2175         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
2176 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
2177         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
2178         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
2179         { USB_DEVICE(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD) },
2180         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
2181 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
2182         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
2183         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
2184         { 0 }           /* Terminating entry */
2185 };
2186 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
2187
2188 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
2189         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
2190         .usb_ctrl          = DEVICE_SPECIFIC, \
2191         .firmware          = "dvb-usb-dib0700-1.20.fw", \
2192         .download_firmware = dib0700_download_firmware, \
2193         .no_reconnect      = 1, \
2194         .size_of_priv      = sizeof(struct dib0700_state), \
2195         .i2c_algo          = &dib0700_i2c_algo, \
2196         .identify_state    = dib0700_identify_state
2197
2198 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
2199         .streaming_ctrl   = dib0700_streaming_ctrl, \
2200         .stream = { \
2201                 .type = USB_BULK, \
2202                 .count = 4, \
2203                 .endpoint = ep, \
2204                 .u = { \
2205                         .bulk = { \
2206                                 .buffersize = 39480, \
2207                         } \
2208                 } \
2209         }
2210
2211 struct dvb_usb_device_properties dib0700_devices[] = {
2212         {
2213                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
2214
2215                 .num_adapters = 1,
2216                 .adapter = {
2217                         {
2218                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2219                                 .pid_filter_count = 32,
2220                                 .pid_filter       = stk70x0p_pid_filter,
2221                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2222                                 .frontend_attach  = stk7700p_frontend_attach,
2223                                 .tuner_attach     = stk7700p_tuner_attach,
2224
2225                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2226                         },
2227                 },
2228
2229                 .num_device_descs = 8,
2230                 .devices = {
2231                         {   "DiBcom STK7700P reference design",
2232                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
2233                                 { NULL },
2234                         },
2235                         {   "Hauppauge Nova-T Stick",
2236                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
2237                                 { NULL },
2238                         },
2239                         {   "AVerMedia AVerTV DVB-T Volar",
2240                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
2241                                 { NULL },
2242                         },
2243                         {   "Compro Videomate U500",
2244                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
2245                                 { NULL },
2246                         },
2247                         {   "Uniwill STK7700P based (Hama and others)",
2248                                 { &dib0700_usb_id_table[7], NULL },
2249                                 { NULL },
2250                         },
2251                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
2252                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
2253                                 { NULL },
2254                         },
2255                         {   "AVerMedia AVerTV DVB-T Express",
2256                                 { &dib0700_usb_id_table[20] },
2257                                 { NULL },
2258                         },
2259                         {   "Gigabyte U7000",
2260                                 { &dib0700_usb_id_table[21], NULL },
2261                                 { NULL },
2262                         }
2263                 },
2264
2265                 .rc_interval      = DEFAULT_RC_INTERVAL,
2266                 .rc_key_map       = dib0700_rc_keys,
2267                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2268                 .rc_query         = dib0700_rc_query
2269         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2270
2271                 .num_adapters = 2,
2272                 .adapter = {
2273                         {
2274                                 .frontend_attach  = bristol_frontend_attach,
2275                                 .tuner_attach     = bristol_tuner_attach,
2276
2277                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2278                         }, {
2279                                 .frontend_attach  = bristol_frontend_attach,
2280                                 .tuner_attach     = bristol_tuner_attach,
2281
2282                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2283                         }
2284                 },
2285
2286                 .num_device_descs = 1,
2287                 .devices = {
2288                         {   "Hauppauge Nova-T 500 Dual DVB-T",
2289                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
2290                                 { NULL },
2291                         },
2292                 },
2293
2294                 .rc_interval      = DEFAULT_RC_INTERVAL,
2295                 .rc_key_map       = dib0700_rc_keys,
2296                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2297                 .rc_query         = dib0700_rc_query
2298         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2299
2300                 .num_adapters = 2,
2301                 .adapter = {
2302                         {
2303                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2304                                 .pid_filter_count = 32,
2305                                 .pid_filter       = stk70x0p_pid_filter,
2306                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2307                                 .frontend_attach  = stk7700d_frontend_attach,
2308                                 .tuner_attach     = stk7700d_tuner_attach,
2309
2310                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2311                         }, {
2312                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2313                                 .pid_filter_count = 32,
2314                                 .pid_filter       = stk70x0p_pid_filter,
2315                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2316                                 .frontend_attach  = stk7700d_frontend_attach,
2317                                 .tuner_attach     = stk7700d_tuner_attach,
2318
2319                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2320                         }
2321                 },
2322
2323                 .num_device_descs = 5,
2324                 .devices = {
2325                         {   "Pinnacle PCTV 2000e",
2326                                 { &dib0700_usb_id_table[11], NULL },
2327                                 { NULL },
2328                         },
2329                         {   "Terratec Cinergy DT XS Diversity",
2330                                 { &dib0700_usb_id_table[12], NULL },
2331                                 { NULL },
2332                         },
2333                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
2334                                 { &dib0700_usb_id_table[13], NULL },
2335                                 { NULL },
2336                         },
2337                         {   "DiBcom STK7700D reference design",
2338                                 { &dib0700_usb_id_table[14], NULL },
2339                                 { NULL },
2340                         },
2341                         {   "YUAN High-Tech DiBcom STK7700D",
2342                                 { &dib0700_usb_id_table[55], NULL },
2343                                 { NULL },
2344                         },
2345
2346                 },
2347
2348                 .rc_interval      = DEFAULT_RC_INTERVAL,
2349                 .rc_key_map       = dib0700_rc_keys,
2350                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2351                 .rc_query         = dib0700_rc_query
2352
2353         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2354
2355                 .num_adapters = 1,
2356                 .adapter = {
2357                         {
2358                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2359                                 .pid_filter_count = 32,
2360                                 .pid_filter       = stk70x0p_pid_filter,
2361                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2362                                 .frontend_attach  = stk7700P2_frontend_attach,
2363                                 .tuner_attach     = stk7700d_tuner_attach,
2364
2365                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2366                         },
2367                 },
2368
2369                 .num_device_descs = 3,
2370                 .devices = {
2371                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
2372                                 { &dib0700_usb_id_table[23], NULL },
2373                                 { NULL },
2374                         },
2375                         {   "Yuan EC372S",
2376                                 { &dib0700_usb_id_table[31], NULL },
2377                                 { NULL },
2378                         },
2379                         {   "Terratec Cinergy T Express",
2380                                 { &dib0700_usb_id_table[42], NULL },
2381                                 { NULL },
2382                         }
2383                 },
2384
2385                 .rc_interval      = DEFAULT_RC_INTERVAL,
2386                 .rc_key_map       = dib0700_rc_keys,
2387                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2388                 .rc_query         = dib0700_rc_query
2389         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2390
2391                 .num_adapters = 1,
2392                 .adapter = {
2393                         {
2394                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2395                                 .pid_filter_count = 32,
2396                                 .pid_filter       = stk70x0p_pid_filter,
2397                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2398                                 .frontend_attach  = stk7070p_frontend_attach,
2399                                 .tuner_attach     = dib7070p_tuner_attach,
2400
2401                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2402
2403                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2404                         },
2405                 },
2406
2407                 .num_device_descs = 11,
2408                 .devices = {
2409                         {   "DiBcom STK7070P reference design",
2410                                 { &dib0700_usb_id_table[15], NULL },
2411                                 { NULL },
2412                         },
2413                         {   "Pinnacle PCTV DVB-T Flash Stick",
2414                                 { &dib0700_usb_id_table[16], NULL },
2415                                 { NULL },
2416                         },
2417                         {   "Artec T14BR DVB-T",
2418                                 { &dib0700_usb_id_table[22], NULL },
2419                                 { NULL },
2420                         },
2421                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
2422                                 { &dib0700_usb_id_table[24], NULL },
2423                                 { NULL },
2424                         },
2425                         {   "Hauppauge Nova-T Stick",
2426                                 { &dib0700_usb_id_table[25], NULL },
2427                                 { NULL },
2428                         },
2429                         {   "Hauppauge Nova-T MyTV.t",
2430                                 { &dib0700_usb_id_table[26], NULL },
2431                                 { NULL },
2432                         },
2433                         {   "Pinnacle PCTV 72e",
2434                                 { &dib0700_usb_id_table[29], NULL },
2435                                 { NULL },
2436                         },
2437                         {   "Pinnacle PCTV 73e",
2438                                 { &dib0700_usb_id_table[30], NULL },
2439                                 { NULL },
2440                         },
2441                         {   "Elgato EyeTV DTT",
2442                                 { &dib0700_usb_id_table[49], NULL },
2443                                 { NULL },
2444                         },
2445                         {   "Yuan PD378S",
2446                                 { &dib0700_usb_id_table[45], NULL },
2447                                 { NULL },
2448                         },
2449                         {   "Elgato EyeTV Dtt Dlx PD378S",
2450                                 { &dib0700_usb_id_table[50], NULL },
2451                                 { NULL },
2452                         },
2453                 },
2454
2455                 .rc_interval      = DEFAULT_RC_INTERVAL,
2456                 .rc_key_map       = dib0700_rc_keys,
2457                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2458                 .rc_query         = dib0700_rc_query
2459
2460         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2461
2462                 .num_adapters = 1,
2463                 .adapter = {
2464                         {
2465                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2466                                 .pid_filter_count = 32,
2467                                 .pid_filter       = stk70x0p_pid_filter,
2468                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2469                                 .frontend_attach  = stk7070p_frontend_attach,
2470                                 .tuner_attach     = dib7070p_tuner_attach,
2471
2472                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2473
2474                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2475                         },
2476                 },
2477
2478                 .num_device_descs = 3,
2479                 .devices = {
2480                         {   "Pinnacle PCTV 73A",
2481                                 { &dib0700_usb_id_table[56], NULL },
2482                                 { NULL },
2483                         },
2484                         {   "Pinnacle PCTV 73e SE",
2485                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
2486                                 { NULL },
2487                         },
2488                         {   "Pinnacle PCTV 282e",
2489                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
2490                                 { NULL },
2491                         },
2492                 },
2493
2494                 .rc_interval      = DEFAULT_RC_INTERVAL,
2495                 .rc_key_map       = dib0700_rc_keys,
2496                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2497                 .rc_query         = dib0700_rc_query
2498
2499         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2500
2501                 .num_adapters = 2,
2502                 .adapter = {
2503                         {
2504                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2505                                 .pid_filter_count = 32,
2506                                 .pid_filter       = stk70x0p_pid_filter,
2507                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2508                                 .frontend_attach  = stk7070pd_frontend_attach0,
2509                                 .tuner_attach     = dib7070p_tuner_attach,
2510
2511                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2512
2513                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2514                         }, {
2515                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2516                                 .pid_filter_count = 32,
2517                                 .pid_filter       = stk70x0p_pid_filter,
2518                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2519                                 .frontend_attach  = stk7070pd_frontend_attach1,
2520                                 .tuner_attach     = dib7070p_tuner_attach,
2521
2522                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2523
2524                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
2525                         }
2526                 },
2527
2528                 .num_device_descs = 6,
2529                 .devices = {
2530                         {   "DiBcom STK7070PD reference design",
2531                                 { &dib0700_usb_id_table[17], NULL },
2532                                 { NULL },
2533                         },
2534                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
2535                                 { &dib0700_usb_id_table[18], NULL },
2536                                 { NULL },
2537                         },
2538                         {   "Hauppauge Nova-TD Stick (52009)",
2539                                 { &dib0700_usb_id_table[35], NULL },
2540                                 { NULL },
2541                         },
2542                         {   "Hauppauge Nova-TD-500 (84xxx)",
2543                                 { &dib0700_usb_id_table[36], NULL },
2544                                 { NULL },
2545                         },
2546                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
2547                                 { &dib0700_usb_id_table[43],
2548                                         &dib0700_usb_id_table[53], NULL},
2549                                 { NULL },
2550                         },
2551                         {  "Sony PlayTV",
2552                                 { &dib0700_usb_id_table[44], NULL },
2553                                 { NULL },
2554                         }
2555                 },
2556                 .rc_interval      = DEFAULT_RC_INTERVAL,
2557                 .rc_key_map       = dib0700_rc_keys,
2558                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2559                 .rc_query         = dib0700_rc_query
2560         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2561
2562                 .num_adapters = 1,
2563                 .adapter = {
2564                         {
2565                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2566                                 .pid_filter_count = 32,
2567                                 .pid_filter       = stk70x0p_pid_filter,
2568                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2569                                 .frontend_attach  = stk7700ph_frontend_attach,
2570                                 .tuner_attach     = stk7700ph_tuner_attach,
2571
2572                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2573
2574                                 .size_of_priv = sizeof(struct
2575                                                 dib0700_adapter_state),
2576                         },
2577                 },
2578
2579                 .num_device_descs = 9,
2580                 .devices = {
2581                         {   "Terratec Cinergy HT USB XE",
2582                                 { &dib0700_usb_id_table[27], NULL },
2583                                 { NULL },
2584                         },
2585                         {   "Pinnacle Expresscard 320cx",
2586                                 { &dib0700_usb_id_table[28], NULL },
2587                                 { NULL },
2588                         },
2589                         {   "Terratec Cinergy HT Express",
2590                                 { &dib0700_usb_id_table[32], NULL },
2591                                 { NULL },
2592                         },
2593                         {   "Gigabyte U8000-RH",
2594                                 { &dib0700_usb_id_table[37], NULL },
2595                                 { NULL },
2596                         },
2597                         {   "YUAN High-Tech STK7700PH",
2598                                 { &dib0700_usb_id_table[38], NULL },
2599                                 { NULL },
2600                         },
2601                         {   "Asus My Cinema-U3000Hybrid",
2602                                 { &dib0700_usb_id_table[39], NULL },
2603                                 { NULL },
2604                         },
2605                         {   "YUAN High-Tech MC770",
2606                                 { &dib0700_usb_id_table[48], NULL },
2607                                 { NULL },
2608                         },
2609                         {   "Leadtek WinFast DTV Dongle H",
2610                                 { &dib0700_usb_id_table[51], NULL },
2611                                 { NULL },
2612                         },
2613                         {   "YUAN High-Tech STK7700D",
2614                                 { &dib0700_usb_id_table[54], NULL },
2615                                 { NULL },
2616                         },
2617                 },
2618                 .rc_interval      = DEFAULT_RC_INTERVAL,
2619                 .rc_key_map       = dib0700_rc_keys,
2620                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2621                 .rc_query         = dib0700_rc_query
2622         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2623                 .num_adapters = 1,
2624                 .adapter = {
2625                         {
2626                                 .frontend_attach  = s5h1411_frontend_attach,
2627                                 .tuner_attach     = xc5000_tuner_attach,
2628
2629                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2630
2631                                 .size_of_priv = sizeof(struct
2632                                                 dib0700_adapter_state),
2633                         },
2634                 },
2635
2636                 .num_device_descs = 2,
2637                 .devices = {
2638                         {   "Pinnacle PCTV HD Pro USB Stick",
2639                                 { &dib0700_usb_id_table[40], NULL },
2640                                 { NULL },
2641                         },
2642                         {   "Pinnacle PCTV HD USB Stick",
2643                                 { &dib0700_usb_id_table[41], NULL },
2644                                 { NULL },
2645                         },
2646                 },
2647                 .rc_interval      = DEFAULT_RC_INTERVAL,
2648                 .rc_key_map       = dib0700_rc_keys,
2649                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2650                 .rc_query         = dib0700_rc_query
2651         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2652                 .num_adapters = 1,
2653                 .adapter = {
2654                         {
2655                                 .frontend_attach  = lgdt3305_frontend_attach,
2656                                 .tuner_attach     = mxl5007t_tuner_attach,
2657
2658                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2659
2660                                 .size_of_priv = sizeof(struct
2661                                                 dib0700_adapter_state),
2662                         },
2663                 },
2664
2665                 .num_device_descs = 2,
2666                 .devices = {
2667                         {   "Hauppauge ATSC MiniCard (B200)",
2668                                 { &dib0700_usb_id_table[46], NULL },
2669                                 { NULL },
2670                         },
2671                         {   "Hauppauge ATSC MiniCard (B210)",
2672                                 { &dib0700_usb_id_table[47], NULL },
2673                                 { NULL },
2674                         },
2675                 },
2676         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2677
2678                 .num_adapters = 1,
2679                 .adapter = {
2680                         {
2681                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2682                                 .pid_filter_count = 32,
2683                                 .pid_filter       = stk70x0p_pid_filter,
2684                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
2685                                 .frontend_attach  = stk7070p_frontend_attach,
2686                                 .tuner_attach     = dib7770p_tuner_attach,
2687
2688                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2689
2690                                 .size_of_priv =
2691                                         sizeof(struct dib0700_adapter_state),
2692                         },
2693                 },
2694
2695                 .num_device_descs = 2,
2696                 .devices = {
2697                         {   "DiBcom STK7770P reference design",
2698                                 { &dib0700_usb_id_table[59], NULL },
2699                                 { NULL },
2700                         },
2701                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
2702                                 { &dib0700_usb_id_table[33],
2703                                         &dib0700_usb_id_table[52],
2704                                         &dib0700_usb_id_table[60], NULL},
2705                                 { NULL },
2706                         },
2707                 },
2708                 .rc_interval      = DEFAULT_RC_INTERVAL,
2709                 .rc_key_map       = dib0700_rc_keys,
2710                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2711                 .rc_query         = dib0700_rc_query
2712         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2713                 .num_adapters = 1,
2714                 .adapter = {
2715                         {
2716                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2717                                 .pid_filter_count = 32,
2718                                 .pid_filter = stk80xx_pid_filter,
2719                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2720                                 .frontend_attach  = stk807x_frontend_attach,
2721                                 .tuner_attach     = dib807x_tuner_attach,
2722
2723                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2724
2725                                 .size_of_priv =
2726                                         sizeof(struct dib0700_adapter_state),
2727                         },
2728                 },
2729
2730                 .num_device_descs = 3,
2731                 .devices = {
2732                         {   "DiBcom STK807xP reference design",
2733                                 { &dib0700_usb_id_table[62], NULL },
2734                                 { NULL },
2735                         },
2736                         {   "Prolink Pixelview SBTVD",
2737                                 { &dib0700_usb_id_table[63], NULL },
2738                                 { NULL },
2739                         },
2740                         {   "EvolutePC TVWay+",
2741                                 { &dib0700_usb_id_table[64], NULL },
2742                                 { NULL },
2743                         },
2744                 },
2745
2746                 .rc_interval      = DEFAULT_RC_INTERVAL,
2747                 .rc_key_map       = dib0700_rc_keys,
2748                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2749                 .rc_query         = dib0700_rc_query
2750
2751         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2752                 .num_adapters = 2,
2753                 .adapter = {
2754                         {
2755                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2756                                 .pid_filter_count = 32,
2757                                 .pid_filter = stk80xx_pid_filter,
2758                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2759                                 .frontend_attach  = stk807xpvr_frontend_attach0,
2760                                 .tuner_attach     = dib807x_tuner_attach,
2761
2762                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2763
2764                                 .size_of_priv =
2765                                         sizeof(struct dib0700_adapter_state),
2766                         },
2767                         {
2768                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2769                                 .pid_filter_count = 32,
2770                                 .pid_filter = stk80xx_pid_filter,
2771                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2772                                 .frontend_attach  = stk807xpvr_frontend_attach1,
2773                                 .tuner_attach     = dib807x_tuner_attach,
2774
2775                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2776
2777                                 .size_of_priv =
2778                                         sizeof(struct dib0700_adapter_state),
2779                         },
2780                 },
2781
2782                 .num_device_descs = 1,
2783                 .devices = {
2784                         {   "DiBcom STK807xPVR reference design",
2785                                 { &dib0700_usb_id_table[61], NULL },
2786                                 { NULL },
2787                         },
2788                 },
2789
2790                 .rc_interval      = DEFAULT_RC_INTERVAL,
2791                 .rc_key_map       = dib0700_rc_keys,
2792                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2793                 .rc_query         = dib0700_rc_query
2794         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2795                 .num_adapters = 1,
2796                 .adapter = {
2797                         {
2798                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
2799                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2800                                 .pid_filter_count = 32,
2801                                 .pid_filter = stk80xx_pid_filter,
2802                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2803                                 .frontend_attach  = stk809x_frontend_attach,
2804                                 .tuner_attach     = dib809x_tuner_attach,
2805
2806                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2807
2808                                 .size_of_priv =
2809                                         sizeof(struct dib0700_adapter_state),
2810                         },
2811                 },
2812
2813                 .num_device_descs = 1,
2814                 .devices = {
2815                         {   "DiBcom STK8096GP reference design",
2816                                 { &dib0700_usb_id_table[67], NULL },
2817                                 { NULL },
2818                         },
2819                 },
2820
2821                 .rc_interval      = DEFAULT_RC_INTERVAL,
2822                 .rc_key_map       = dib0700_rc_keys,
2823                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
2824                 .rc_query         = dib0700_rc_query
2825         },
2826 };
2827
2828 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);