drivers/media/dvb/dvb-usb/dib0700_devices.c

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