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 "dib9000.h"
  16 #include "mt2060.h"
  17 #include "mt2266.h"
  18 #include "tuner-xc2028.h"
  19 #include "xc5000.h"
  20 #include "xc4000.h"
  21 #include "s5h1411.h"
  22 #include "dib0070.h"
  23 #include "dib0090.h"
  24 #include "lgdt3305.h"
  25 #include "mxl5007t.h"
  26
  27 static int force_lna_activation;
  28 module_param(force_lna_activation, int, 0644);
  29 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
  30                 "if applicable for the device (default: 0=automatic/off).");
  31
  32 struct dib0700_adapter_state {
  33         int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
  34         const struct firmware *frontend_firmware;
  35 };
  36
  37 /* Hauppauge Nova-T 500 (aka Bristol)
  38  *  has a LNA on GPIO0 which is enabled by setting 1 */
  39 static struct mt2060_config bristol_mt2060_config[2] = {
  40         {
  41                 .i2c_address = 0x60,
  42                 .clock_out   = 3,
  43         }, {
  44                 .i2c_address = 0x61,
  45         }
  46 };
  47
  48
  49 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  50         .band_caps = BAND_VHF | BAND_UHF,
  51         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  52
  53         .agc1_max = 42598,
  54         .agc1_min = 17694,
  55         .agc2_max = 45875,
  56         .agc2_min = 0,
  57
  58         .agc1_pt1 = 0,
  59         .agc1_pt2 = 59,
  60
  61         .agc1_slope1 = 0,
  62         .agc1_slope2 = 69,
  63
  64         .agc2_pt1 = 0,
  65         .agc2_pt2 = 59,
  66
  67         .agc2_slope1 = 111,
  68         .agc2_slope2 = 28,
  69 };
  70
  71 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  72         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  73                 .max_time     = 0x196,
  74                 .ln_adc_level = 0x1cc7,
  75                 .output_mpeg2_in_188_bytes = 1,
  76         },
  77         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  78                 .max_time     = 0x196,
  79                 .ln_adc_level = 0x1cc7,
  80                 .output_mpeg2_in_188_bytes = 1,
  81         }
  82 };
  83
  84 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  85 {
  86         struct dib0700_state *st = adap->dev->priv;
  87         if (adap->id == 0) {
  88                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  89                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  90                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  91                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  92
  93                 if (force_lna_activation)
  94                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  95                 else
  96                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  97
  98                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
  99                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
 100                         return -ENODEV;
 101                 }
 102         }
 103         st->mt2060_if1[adap->id] = 1220;
 104         return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 105                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 106 }
 107
 108 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 109 {
 110         struct i2c_msg msg[2] = {
 111                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 112                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 113         };
 114         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 115         return 0;
 116 }
 117
 118 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 119 {
 120         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 121         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
 122         s8 a;
 123         int if1=1220;
 124         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 125                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 126                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 127         }
 128         return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
 129                 if1) == NULL ? -ENODEV : 0;
 130 }
 131
 132 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 133
 134 /* MT226x */
 135 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 136         {
 137                 BAND_UHF,
 138
 139                 /* 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,
 140                 * 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 */
 141                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 142             | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 143
 144                 1130,
 145                 21,
 146
 147                 0,
 148                 118,
 149
 150                 0,
 151                 3530,
 152                 1,
 153                 0,
 154
 155                 65535,
 156                 33770,
 157                 65535,
 158                 23592,
 159
 160                 0,
 161                 62,
 162                 255,
 163                 64,
 164                 64,
 165                 132,
 166                 192,
 167                 80,
 168                 80,
 169
 170                 17,
 171                 27,
 172                 23,
 173                 51,
 174
 175                 1,
 176         }, {
 177                 BAND_VHF | BAND_LBAND,
 178
 179                 /* 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,
 180                 * 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 */
 181                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 182             | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 183
 184                 2372,
 185                 21,
 186
 187                 0,
 188                 118,
 189
 190                 0,
 191                 3530,
 192                 1,
 193                 0,
 194
 195                 65535,
 196                 0,
 197                 65535,
 198                 23592,
 199
 200                 0,
 201                 128,
 202                 128,
 203                 128,
 204                 0,
 205                 128,
 206                 253,
 207                 81,
 208                 0,
 209
 210                 17,
 211                 27,
 212                 23,
 213                 51,
 214
 215                 1,
 216         }
 217 };
 218
 219 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 220         60000, 30000,
 221         1, 8, 3, 1, 0,
 222         0, 0, 1, 1, 2,
 223         (3 << 14) | (1 << 12) | (524 << 0),
 224         0,
 225         20452225,
 226 };
 227
 228 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 229         {       .output_mpeg2_in_188_bytes = 1,
 230                 .hostbus_diversity = 1,
 231                 .tuner_is_baseband = 1,
 232
 233                 .agc_config_count = 2,
 234                 .agc = stk7700d_7000p_mt2266_agc_config,
 235                 .bw  = &stk7700d_mt2266_pll_config,
 236
 237                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 238                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 239                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 240         },
 241         {       .output_mpeg2_in_188_bytes = 1,
 242                 .hostbus_diversity = 1,
 243                 .tuner_is_baseband = 1,
 244
 245                 .agc_config_count = 2,
 246                 .agc = stk7700d_7000p_mt2266_agc_config,
 247                 .bw  = &stk7700d_mt2266_pll_config,
 248
 249                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 250                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 251                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 252         }
 253 };
 254
 255 static struct mt2266_config stk7700d_mt2266_config[2] = {
 256         {       .i2c_address = 0x60
 257         },
 258         {       .i2c_address = 0x60
 259         }
 260 };
 261
 262 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 263 {
 264         if (adap->id == 0) {
 265                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 266                 msleep(10);
 267                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 268                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 269                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 270                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 271                 msleep(10);
 272                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 273                 msleep(10);
 274                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 275                                              stk7700d_dib7000p_mt2266_config)
 276                     != 0) {
 277                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 278                         return -ENODEV;
 279                 }
 280         }
 281
 282         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 283                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 284
 285         return adap->fe == NULL ? -ENODEV : 0;
 286 }
 287
 288 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 289 {
 290         if (adap->id == 0) {
 291                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 292                 msleep(10);
 293                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 294                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 295                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 296                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 297                 msleep(10);
 298                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 299                 msleep(10);
 300                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 301                 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 302                                              stk7700d_dib7000p_mt2266_config)
 303                     != 0) {
 304                         err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
 305                         return -ENODEV;
 306                 }
 307         }
 308
 309         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 310                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 311
 312         return adap->fe == NULL ? -ENODEV : 0;
 313 }
 314
 315 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 316 {
 317         struct i2c_adapter *tun_i2c;
 318         tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 319         return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
 320                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 321 }
 322
 323 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 324 static struct dibx000_agc_config xc3028_agc_config = {
 325         BAND_VHF | BAND_UHF,       /* band_caps */
 326
 327         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 328          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 329          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 330         (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
 331         (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
 332
 333         712,    /* inv_gain */
 334         21,     /* time_stabiliz */
 335
 336         0,      /* alpha_level */
 337         118,    /* thlock */
 338
 339         0,      /* wbd_inv */
 340         2867,   /* wbd_ref */
 341         0,      /* wbd_sel */
 342         2,      /* wbd_alpha */
 343
 344         0,      /* agc1_max */
 345         0,      /* agc1_min */
 346         39718,  /* agc2_max */
 347         9930,   /* agc2_min */
 348         0,      /* agc1_pt1 */
 349         0,      /* agc1_pt2 */
 350         0,      /* agc1_pt3 */
 351         0,      /* agc1_slope1 */
 352         0,      /* agc1_slope2 */
 353         0,      /* agc2_pt1 */
 354         128,    /* agc2_pt2 */
 355         29,     /* agc2_slope1 */
 356         29,     /* agc2_slope2 */
 357
 358         17,     /* alpha_mant */
 359         27,     /* alpha_exp */
 360         23,     /* beta_mant */
 361         51,     /* beta_exp */
 362
 363         1,      /* perform_agc_softsplit */
 364 };
 365
 366 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 367 static struct dibx000_bandwidth_config xc3028_bw_config = {
 368         60000, 30000, /* internal, sampling */
 369         1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
 370         0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
 371                           modulo */
 372         (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 373         (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
 374         20452225, /* timf */
 375         30000000, /* xtal_hz */
 376 };
 377
 378 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 379         .output_mpeg2_in_188_bytes = 1,
 380         .tuner_is_baseband = 1,
 381
 382         .agc_config_count = 1,
 383         .agc = &xc3028_agc_config,
 384         .bw  = &xc3028_bw_config,
 385
 386         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 387         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 388         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 389 };
 390
 391 static int stk7700ph_xc3028_callback(void *ptr, int component,
 392                                      int command, int arg)
 393 {
 394         struct dvb_usb_adapter *adap = ptr;
 395
 396         switch (command) {
 397         case XC2028_TUNER_RESET:
 398                 /* Send the tuner in then out of reset */
 399                 dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
 400                 dib7000p_set_gpio(adap->fe, 8, 0, 1);
 401                 break;
 402         case XC2028_RESET_CLK:
 403                 break;
 404         default:
 405                 err("%s: unknown command %d, arg %d\n", __func__,
 406                         command, arg);
 407                 return -EINVAL;
 408         }
 409         return 0;
 410 }
 411
 412 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
 413         .fname = XC2028_DEFAULT_FIRMWARE,
 414         .max_len = 64,
 415         .demod = XC3028_FE_DIBCOM52,
 416 };
 417
 418 static struct xc2028_config stk7700ph_xc3028_config = {
 419         .i2c_addr = 0x61,
 420         .ctrl = &stk7700ph_xc3028_ctrl,
 421 };
 422
 423 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 424 {
 425         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 426
 427         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 428             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
 429         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 430         else
 431         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 432         msleep(20);
 433         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 434         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 435         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 436         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 437         msleep(10);
 438         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 439         msleep(20);
 440         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 441         msleep(10);
 442
 443         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 444                                      &stk7700ph_dib7700_xc3028_config) != 0) {
 445                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 446                     __func__);
 447                 return -ENODEV;
 448         }
 449
 450         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 451                 &stk7700ph_dib7700_xc3028_config);
 452
 453         return adap->fe == NULL ? -ENODEV : 0;
 454 }
 455
 456 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 457 {
 458         struct i2c_adapter *tun_i2c;
 459
 460         tun_i2c = dib7000p_get_i2c_master(adap->fe,
 461                 DIBX000_I2C_INTERFACE_TUNER, 1);
 462
 463         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
 464
 465         /* FIXME: generalize & move to common area */
 466         adap->fe->callback = stk7700ph_xc3028_callback;
 467
 468         return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
 469                 == NULL ? -ENODEV : 0;
 470 }
 471
 472 #define DEFAULT_RC_INTERVAL 50
 473
 474 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 475
 476 /* Number of keypresses to ignore before start repeating */
 477 #define RC_REPEAT_DELAY 6
 478
 479 /*
 480  * This function is used only when firmware is < 1.20 version. Newer
 481  * firmwares use bulk mode, with functions implemented at dib0700_core,
 482  * at dib0700_rc_urb_completion()
 483  */
 484 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 485 {
 486         u8 key[4];
 487         u32 keycode;
 488         u8 toggle;
 489         int i;
 490         struct dib0700_state *st = d->priv;
 491
 492         if (st->fw_version >= 0x10200) {
 493                 /* For 1.20 firmware , We need to keep the RC polling
 494                    callback so we can reuse the input device setup in
 495                    dvb-usb-remote.c.  However, the actual work is being done
 496                    in the bulk URB completion handler. */
 497                 return 0;
 498         }
 499
 500         i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
 501         if (i <= 0) {
 502                 err("RC Query Failed");
 503                 return -1;
 504         }
 505
 506         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 507         if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
 508                 return 0;
 509
 510         /* 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]);  */
 511
 512         dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
 513
 514         d->last_event = 0;
 515         switch (d->props.rc.core.protocol) {
 516         case RC_TYPE_NEC:
 517                 /* NEC protocol sends repeat code as 0 0 0 FF */
 518                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
 519                     (key[3] == 0xff))
 520                         keycode = d->last_event;
 521                 else {
 522                         keycode = key[3-2] << 8 | key[3-3];
 523                         d->last_event = keycode;
 524                 }
 525
 526                 rc_keydown(d->rc_dev, keycode, 0);
 527                 break;
 528         default:
 529                 /* RC-5 protocol changes toggle bit on new keypress */
 530                 keycode = key[3-2] << 8 | key[3-3];
 531                 toggle = key[3-1];
 532                 rc_keydown(d->rc_dev, keycode, toggle);
 533
 534                 break;
 535         }
 536         return 0;
 537 }
 538
 539 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 540 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 541         BAND_UHF | BAND_VHF,
 542
 543         /* 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,
 544          * 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 */
 545         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 546         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 547
 548         712,
 549         41,
 550
 551         0,
 552         118,
 553
 554         0,
 555         4095,
 556         0,
 557         0,
 558
 559         42598,
 560         17694,
 561         45875,
 562         2621,
 563         0,
 564         76,
 565         139,
 566         52,
 567         59,
 568         107,
 569         172,
 570         57,
 571         70,
 572
 573         21,
 574         25,
 575         28,
 576         48,
 577
 578         1,
 579         {  0,
 580            107,
 581            51800,
 582            24700
 583         },
 584 };
 585
 586 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 587         BAND_UHF | BAND_VHF,
 588
 589         /* 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,
 590          * 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 */
 591         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 592         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 593
 594         712,
 595         41,
 596
 597         0,
 598         118,
 599
 600         0,
 601         4095,
 602         0,
 603         0,
 604
 605         42598,
 606         16384,
 607         42598,
 608             0,
 609
 610           0,
 611         137,
 612         255,
 613
 614           0,
 615         255,
 616
 617         0,
 618         0,
 619
 620          0,
 621         41,
 622
 623         15,
 624         25,
 625
 626         28,
 627         48,
 628
 629         0,
 630 };
 631
 632 static struct dibx000_bandwidth_config stk7700p_pll_config = {
 633         60000, 30000,
 634         1, 8, 3, 1, 0,
 635         0, 0, 1, 1, 0,
 636         (3 << 14) | (1 << 12) | (524 << 0),
 637         60258167,
 638         20452225,
 639         30000000,
 640 };
 641
 642 static struct dib7000m_config stk7700p_dib7000m_config = {
 643         .dvbt_mode = 1,
 644         .output_mpeg2_in_188_bytes = 1,
 645         .quartz_direct = 1,
 646
 647         .agc_config_count = 1,
 648         .agc = &stk7700p_7000m_mt2060_agc_config,
 649         .bw  = &stk7700p_pll_config,
 650
 651         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 652         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 653         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 654 };
 655
 656 static struct dib7000p_config stk7700p_dib7000p_config = {
 657         .output_mpeg2_in_188_bytes = 1,
 658
 659         .agc_config_count = 1,
 660         .agc = &stk7700p_7000p_mt2060_agc_config,
 661         .bw  = &stk7700p_pll_config,
 662
 663         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 664         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 665         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 666 };
 667
 668 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 669 {
 670         struct dib0700_state *st = adap->dev->priv;
 671         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 672
 673         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 674         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 675
 676         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 677         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 678
 679         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 680         dib0700_ctrl_clock(adap->dev, 72, 1);
 681         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 682
 683         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 684
 685         st->mt2060_if1[0] = 1220;
 686
 687         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
 688                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 689                 st->is_dib7000pc = 1;
 690         } else
 691                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 692
 693         return adap->fe == NULL ? -ENODEV : 0;
 694 }
 695
 696 static struct mt2060_config stk7700p_mt2060_config = {
 697         0x60
 698 };
 699
 700 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 701 {
 702         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 703         struct dib0700_state *st = adap->dev->priv;
 704         struct i2c_adapter *tun_i2c;
 705         s8 a;
 706         int if1=1220;
 707         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 708                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
 709                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
 710         }
 711         if (st->is_dib7000pc)
 712                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 713         else
 714                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 715
 716         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
 717                 if1) == NULL ? -ENODEV : 0;
 718 }
 719
 720 /* DIB7070 generic */
 721 static struct dibx000_agc_config dib7070_agc_config = {
 722         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 723         /* 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,
 724          * 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 */
 725         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 726         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 727
 728         600,
 729         10,
 730
 731         0,
 732         118,
 733
 734         0,
 735         3530,
 736         1,
 737         5,
 738
 739         65535,
 740                 0,
 741
 742         65535,
 743         0,
 744
 745         0,
 746         40,
 747         183,
 748         206,
 749         255,
 750         72,
 751         152,
 752         88,
 753         90,
 754
 755         17,
 756         27,
 757         23,
 758         51,
 759
 760         0,
 761 };
 762
 763 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 764 {
 765         deb_info("reset: %d", onoff);
 766         return dib7000p_set_gpio(fe, 8, 0, !onoff);
 767 }
 768
 769 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 770 {
 771         deb_info("sleep: %d", onoff);
 772         return dib7000p_set_gpio(fe, 9, 0, onoff);
 773 }
 774
 775 static struct dib0070_config dib7070p_dib0070_config[2] = {
 776         {
 777                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 778                 .reset = dib7070_tuner_reset,
 779                 .sleep = dib7070_tuner_sleep,
 780                 .clock_khz = 12000,
 781                 .clock_pad_drive = 4,
 782                 .charge_pump = 2,
 783         }, {
 784                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 785                 .reset = dib7070_tuner_reset,
 786                 .sleep = dib7070_tuner_sleep,
 787                 .clock_khz = 12000,
 788                 .charge_pump = 2,
 789         }
 790 };
 791
 792 static struct dib0070_config dib7770p_dib0070_config = {
 793          .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 794          .reset = dib7070_tuner_reset,
 795          .sleep = dib7070_tuner_sleep,
 796          .clock_khz = 12000,
 797          .clock_pad_drive = 0,
 798          .flip_chip = 1,
 799          .charge_pump = 2,
 800 };
 801
 802 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
 803 {
 804         struct dvb_usb_adapter *adap = fe->dvb->priv;
 805         struct dib0700_adapter_state *state = adap->priv;
 806
 807         u16 offset;
 808         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 809         switch (band) {
 810                 case BAND_VHF: offset = 950; break;
 811                 case BAND_UHF:
 812                 default: offset = 550; break;
 813         }
 814         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 815         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 816         return state->set_param_save(fe, fep);
 817 }
 818
 819 static int dib7770_set_param_override(struct dvb_frontend *fe,
 820                 struct dvb_frontend_parameters *fep)
 821 {
 822          struct dvb_usb_adapter *adap = fe->dvb->priv;
 823          struct dib0700_adapter_state *state = adap->priv;
 824
 825          u16 offset;
 826          u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 827          switch (band) {
 828          case BAND_VHF:
 829                   dib7000p_set_gpio(fe, 0, 0, 1);
 830                   offset = 850;
 831                   break;
 832          case BAND_UHF:
 833          default:
 834                   dib7000p_set_gpio(fe, 0, 0, 0);
 835                   offset = 250;
 836                   break;
 837          }
 838          deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 839          dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 840          return state->set_param_save(fe, fep);
 841 }
 842
 843 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
 844 {
 845          struct dib0700_adapter_state *st = adap->priv;
 846          struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
 847                          DIBX000_I2C_INTERFACE_TUNER, 1);
 848
 849          if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
 850                                  &dib7770p_dib0070_config) == NULL)
 851                  return -ENODEV;
 852
 853          st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 854          adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
 855          return 0;
 856 }
 857
 858 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 859 {
 860         struct dib0700_adapter_state *st = adap->priv;
 861         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 862
 863         if (adap->id == 0) {
 864                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
 865                         return -ENODEV;
 866         } else {
 867                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
 868                         return -ENODEV;
 869         }
 870
 871         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 872         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
 873         return 0;
 874 }
 875
 876 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
 877                 u16 pid, int onoff)
 878 {
 879         struct dib0700_state *st = adapter->dev->priv;
 880         if (st->is_dib7000pc)
 881                 return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
 882         return dib7000m_pid_filter(adapter->fe, index, pid, onoff);
 883 }
 884
 885 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 886 {
 887         struct dib0700_state *st = adapter->dev->priv;
 888         if (st->is_dib7000pc)
 889                 return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
 890         return dib7000m_pid_filter_ctrl(adapter->fe, onoff);
 891 }
 892
 893 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
 894 {
 895     return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
 896 }
 897
 898 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 899 {
 900     return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
 901 }
 902
 903 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
 904         60000, 15000,
 905         1, 20, 3, 1, 0,
 906         0, 0, 1, 1, 2,
 907         (3 << 14) | (1 << 12) | (524 << 0),
 908         (0 << 25) | 0,
 909         20452225,
 910         12000000,
 911 };
 912
 913 static struct dib7000p_config dib7070p_dib7000p_config = {
 914         .output_mpeg2_in_188_bytes = 1,
 915
 916         .agc_config_count = 1,
 917         .agc = &dib7070_agc_config,
 918         .bw  = &dib7070_bw_config_12_mhz,
 919         .tuner_is_baseband = 1,
 920         .spur_protect = 1,
 921
 922         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 923         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 924         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 925
 926         .hostbus_diversity = 1,
 927 };
 928
 929 /* STK7070P */
 930 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 931 {
 932         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 933         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 934             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 935                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 936         else
 937                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 938         msleep(10);
 939         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 940         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 941         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 942         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 943
 944         dib0700_ctrl_clock(adap->dev, 72, 1);
 945
 946         msleep(10);
 947         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 948         msleep(10);
 949         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 950
 951         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 952                                      &dib7070p_dib7000p_config) != 0) {
 953                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
 954                     __func__);
 955                 return -ENODEV;
 956         }
 957
 958         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
 959                 &dib7070p_dib7000p_config);
 960         return adap->fe == NULL ? -ENODEV : 0;
 961 }
 962
 963 /* STK7770P */
 964 static struct dib7000p_config dib7770p_dib7000p_config = {
 965         .output_mpeg2_in_188_bytes = 1,
 966
 967         .agc_config_count = 1,
 968         .agc = &dib7070_agc_config,
 969         .bw  = &dib7070_bw_config_12_mhz,
 970         .tuner_is_baseband = 1,
 971         .spur_protect = 1,
 972
 973         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 974         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 975         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 976
 977         .hostbus_diversity = 1,
 978         .enable_current_mirror = 1,
 979         .disable_sample_and_hold = 0,
 980 };
 981
 982 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
 983 {
 984         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 985         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 986             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 987                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 988         else
 989                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 990         msleep(10);
 991         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 992         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 993         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 994         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 995
 996         dib0700_ctrl_clock(adap->dev, 72, 1);
 997
 998         msleep(10);
 999         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1000         msleep(10);
1001         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1002
1003         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1004                                      &dib7770p_dib7000p_config) != 0) {
1005                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
1006                     __func__);
1007                 return -ENODEV;
1008         }
1009
1010         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1011                 &dib7770p_dib7000p_config);
1012         return adap->fe == NULL ? -ENODEV : 0;
1013 }
1014
1015 /* DIB807x generic */
1016 static struct dibx000_agc_config dib807x_agc_config[2] = {
1017         {
1018                 BAND_VHF,
1019                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1020                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1021                  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1022                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1023                  * P_agc_write=0 */
1024                 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1025                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1026                         (0 << 0), /* setup*/
1027
1028                 600, /* inv_gain*/
1029                 10,  /* time_stabiliz*/
1030
1031                 0,  /* alpha_level*/
1032                 118,  /* thlock*/
1033
1034                 0,     /* wbd_inv*/
1035                 3530,  /* wbd_ref*/
1036                 1,     /* wbd_sel*/
1037                 5,     /* wbd_alpha*/
1038
1039                 65535,  /* agc1_max*/
1040                 0,  /* agc1_min*/
1041
1042                 65535,  /* agc2_max*/
1043                 0,      /* agc2_min*/
1044
1045                 0,      /* agc1_pt1*/
1046                 40,     /* agc1_pt2*/
1047                 183,    /* agc1_pt3*/
1048                 206,    /* agc1_slope1*/
1049                 255,    /* agc1_slope2*/
1050                 72,     /* agc2_pt1*/
1051                 152,    /* agc2_pt2*/
1052                 88,     /* agc2_slope1*/
1053                 90,     /* agc2_slope2*/
1054
1055                 17,  /* alpha_mant*/
1056                 27,  /* alpha_exp*/
1057                 23,  /* beta_mant*/
1058                 51,  /* beta_exp*/
1059
1060                 0,  /* perform_agc_softsplit*/
1061         }, {
1062                 BAND_UHF,
1063                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1064                  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1065                  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1066                  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1067                  * P_agc_write=0 */
1068                 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1069                         (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1070                         (0 << 0), /* setup */
1071
1072                 600, /* inv_gain*/
1073                 10,  /* time_stabiliz*/
1074
1075                 0,  /* alpha_level*/
1076                 118,  /* thlock*/
1077
1078                 0,     /* wbd_inv*/
1079                 3530,  /* wbd_ref*/
1080                 1,     /* wbd_sel*/
1081                 5,     /* wbd_alpha*/
1082
1083                 65535,  /* agc1_max*/
1084                 0,  /* agc1_min*/
1085
1086                 65535,  /* agc2_max*/
1087                 0,      /* agc2_min*/
1088
1089                 0,      /* agc1_pt1*/
1090                 40,     /* agc1_pt2*/
1091                 183,    /* agc1_pt3*/
1092                 206,    /* agc1_slope1*/
1093                 255,    /* agc1_slope2*/
1094                 72,     /* agc2_pt1*/
1095                 152,    /* agc2_pt2*/
1096                 88,     /* agc2_slope1*/
1097                 90,     /* agc2_slope2*/
1098
1099                 17,  /* alpha_mant*/
1100                 27,  /* alpha_exp*/
1101                 23,  /* beta_mant*/
1102                 51,  /* beta_exp*/
1103
1104                 0,  /* perform_agc_softsplit*/
1105         }
1106 };
1107
1108 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1109         60000, 15000, /* internal, sampling*/
1110         1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1111         0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1112                           ADClkSrc, modulo */
1113         (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1114         (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1115         18179755, /* timf*/
1116         12000000, /* xtal_hz*/
1117 };
1118
1119 static struct dib8000_config dib807x_dib8000_config[2] = {
1120         {
1121                 .output_mpeg2_in_188_bytes = 1,
1122
1123                 .agc_config_count = 2,
1124                 .agc = dib807x_agc_config,
1125                 .pll = &dib807x_bw_config_12_mhz,
1126                 .tuner_is_baseband = 1,
1127
1128                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1129                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1130                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1131
1132                 .hostbus_diversity = 1,
1133                 .div_cfg = 1,
1134                 .agc_control = &dib0070_ctrl_agc_filter,
1135                 .output_mode = OUTMODE_MPEG2_FIFO,
1136                 .drives = 0x2d98,
1137         }, {
1138                 .output_mpeg2_in_188_bytes = 1,
1139
1140                 .agc_config_count = 2,
1141                 .agc = dib807x_agc_config,
1142                 .pll = &dib807x_bw_config_12_mhz,
1143                 .tuner_is_baseband = 1,
1144
1145                 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1146                 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1147                 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1148
1149                 .hostbus_diversity = 1,
1150                 .agc_control = &dib0070_ctrl_agc_filter,
1151                 .output_mode = OUTMODE_MPEG2_FIFO,
1152                 .drives = 0x2d98,
1153         }
1154 };
1155
1156 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1157 {
1158         return dib8000_set_gpio(fe, 5, 0, !onoff);
1159 }
1160
1161 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1162 {
1163         return dib8000_set_gpio(fe, 0, 0, onoff);
1164 }
1165
1166 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1167     { 240,      7},
1168     { 0xffff,   6},
1169 };
1170
1171 static struct dib0070_config dib807x_dib0070_config[2] = {
1172         {
1173                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1174                 .reset = dib80xx_tuner_reset,
1175                 .sleep = dib80xx_tuner_sleep,
1176                 .clock_khz = 12000,
1177                 .clock_pad_drive = 4,
1178                 .vga_filter = 1,
1179                 .force_crystal_mode = 1,
1180                 .enable_third_order_filter = 1,
1181                 .charge_pump = 0,
1182                 .wbd_gain = dib8070_wbd_gain_cfg,
1183                 .osc_buffer_state = 0,
1184                 .freq_offset_khz_uhf = -100,
1185                 .freq_offset_khz_vhf = -100,
1186         }, {
1187                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1188                 .reset = dib80xx_tuner_reset,
1189                 .sleep = dib80xx_tuner_sleep,
1190                 .clock_khz = 12000,
1191                 .clock_pad_drive = 2,
1192                 .vga_filter = 1,
1193                 .force_crystal_mode = 1,
1194                 .enable_third_order_filter = 1,
1195                 .charge_pump = 0,
1196                 .wbd_gain = dib8070_wbd_gain_cfg,
1197                 .osc_buffer_state = 0,
1198                 .freq_offset_khz_uhf = -25,
1199                 .freq_offset_khz_vhf = -25,
1200         }
1201 };
1202
1203 static int dib807x_set_param_override(struct dvb_frontend *fe,
1204                 struct dvb_frontend_parameters *fep)
1205 {
1206         struct dvb_usb_adapter *adap = fe->dvb->priv;
1207         struct dib0700_adapter_state *state = adap->priv;
1208
1209         u16 offset = dib0070_wbd_offset(fe);
1210         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1211         switch (band) {
1212         case BAND_VHF:
1213                 offset += 750;
1214                 break;
1215         case BAND_UHF:  /* fall-thru wanted */
1216         default:
1217                 offset += 250; break;
1218         }
1219         deb_info("WBD for DiB8000: %d\n", offset);
1220         dib8000_set_wbd_ref(fe, offset);
1221
1222         return state->set_param_save(fe, fep);
1223 }
1224
1225 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1226 {
1227         struct dib0700_adapter_state *st = adap->priv;
1228         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1229                         DIBX000_I2C_INTERFACE_TUNER, 1);
1230
1231         if (adap->id == 0) {
1232                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1233                                 &dib807x_dib0070_config[0]) == NULL)
1234                         return -ENODEV;
1235         } else {
1236                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1237                                 &dib807x_dib0070_config[1]) == NULL)
1238                         return -ENODEV;
1239         }
1240
1241         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1242         adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1243         return 0;
1244 }
1245
1246 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1247         u16 pid, int onoff)
1248 {
1249         return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1250 }
1251
1252 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1253                 int onoff)
1254 {
1255         return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1256 }
1257
1258 /* STK807x */
1259 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1260 {
1261         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1262         msleep(10);
1263         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1264         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1265         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1266
1267         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1268
1269         dib0700_ctrl_clock(adap->dev, 72, 1);
1270
1271         msleep(10);
1272         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1273         msleep(10);
1274         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1275
1276         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1277                                 0x80);
1278
1279         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1280                               &dib807x_dib8000_config[0]);
1281
1282         return adap->fe == NULL ?  -ENODEV : 0;
1283 }
1284
1285 /* STK807xPVR */
1286 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1287 {
1288         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1289         msleep(30);
1290         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1291         msleep(500);
1292         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1293         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1294         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1295
1296         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1297
1298         dib0700_ctrl_clock(adap->dev, 72, 1);
1299
1300         msleep(10);
1301         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1302         msleep(10);
1303         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1304
1305         /* initialize IC 0 */
1306         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1307
1308         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1309                               &dib807x_dib8000_config[0]);
1310
1311         return adap->fe == NULL ? -ENODEV : 0;
1312 }
1313
1314 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1315 {
1316         /* initialize IC 1 */
1317         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1318
1319         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1320                               &dib807x_dib8000_config[1]);
1321
1322         return adap->fe == NULL ? -ENODEV : 0;
1323 }
1324
1325 /* STK8096GP */
1326 struct dibx000_agc_config dib8090_agc_config[2] = {
1327         {
1328         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1329         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1330          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1331          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1332         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1333         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1334
1335         787,
1336         10,
1337
1338         0,
1339         118,
1340
1341         0,
1342         3530,
1343         1,
1344         5,
1345
1346         65535,
1347         0,
1348
1349         65535,
1350         0,
1351
1352         0,
1353         32,
1354         114,
1355         143,
1356         144,
1357         114,
1358         227,
1359         116,
1360         117,
1361
1362         28,
1363         26,
1364         31,
1365         51,
1366
1367         0,
1368         },
1369         {
1370         BAND_CBAND,
1371         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1372          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1373          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1374         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1375         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1376
1377         787,
1378         10,
1379
1380         0,
1381         118,
1382
1383         0,
1384         3530,
1385         1,
1386         5,
1387
1388         0,
1389         0,
1390
1391         65535,
1392         0,
1393
1394         0,
1395         32,
1396         114,
1397         143,
1398         144,
1399         114,
1400         227,
1401         116,
1402         117,
1403
1404         28,
1405         26,
1406         31,
1407         51,
1408
1409         0,
1410         }
1411 };
1412
1413 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1414         54000, 13500,
1415         1, 18, 3, 1, 0,
1416         0, 0, 1, 1, 2,
1417         (3 << 14) | (1 << 12) | (599 << 0),
1418         (0 << 25) | 0,
1419         20199727,
1420         12000000,
1421 };
1422
1423 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1424 {
1425         return dib8000_get_adc_power(fe, 1);
1426 }
1427
1428 static struct dib8000_config dib809x_dib8000_config[2] = {
1429         {
1430         .output_mpeg2_in_188_bytes = 1,
1431
1432         .agc_config_count = 2,
1433         .agc = dib8090_agc_config,
1434         .agc_control = dib0090_dcc_freq,
1435         .pll = &dib8090_pll_config_12mhz,
1436         .tuner_is_baseband = 1,
1437
1438         .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1439         .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1440         .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1441
1442         .hostbus_diversity = 1,
1443         .div_cfg = 0x31,
1444         .output_mode = OUTMODE_MPEG2_FIFO,
1445         .drives = 0x2d98,
1446         .diversity_delay = 48,
1447         .refclksel = 3,
1448         }, {
1449         .output_mpeg2_in_188_bytes = 1,
1450
1451         .agc_config_count = 2,
1452         .agc = dib8090_agc_config,
1453         .agc_control = dib0090_dcc_freq,
1454         .pll = &dib8090_pll_config_12mhz,
1455         .tuner_is_baseband = 1,
1456
1457         .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1458         .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1459         .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1460
1461         .hostbus_diversity = 1,
1462         .div_cfg = 0x31,
1463         .output_mode = OUTMODE_DIVERSITY,
1464         .drives = 0x2d08,
1465         .diversity_delay = 1,
1466         .refclksel = 3,
1467         }
1468 };
1469
1470 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1471         /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1472         { 120,     0, 500,  0,   500, 4 }, /* CBAND */
1473         { 170,     0, 450,  0,   450, 4 }, /* CBAND */
1474         { 380,    48, 373, 28,   259, 6 }, /* VHF */
1475         { 860,    34, 700, 36,   616, 6 }, /* high UHF */
1476         { 0xFFFF, 34, 700, 36,   616, 6 }, /* default */
1477 };
1478
1479 static struct dib0090_config dib809x_dib0090_config = {
1480         .io.pll_bypass = 1,
1481         .io.pll_range = 1,
1482         .io.pll_prediv = 1,
1483         .io.pll_loopdiv = 20,
1484         .io.adc_clock_ratio = 8,
1485         .io.pll_int_loop_filt = 0,
1486         .io.clock_khz = 12000,
1487         .reset = dib80xx_tuner_reset,
1488         .sleep = dib80xx_tuner_sleep,
1489         .clkouttobamse = 1,
1490         .analog_output = 1,
1491         .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1492         .use_pwm_agc = 1,
1493         .clkoutdrive = 1,
1494         .get_adc_power = dib8090_get_adc_power,
1495         .freq_offset_khz_uhf = -63,
1496         .freq_offset_khz_vhf = -143,
1497         .wbd = dib8090_wbd_table,
1498         .fref_clock_ratio = 6,
1499 };
1500
1501 static int dib8096_set_param_override(struct dvb_frontend *fe,
1502                 struct dvb_frontend_parameters *fep)
1503 {
1504         struct dvb_usb_adapter *adap = fe->dvb->priv;
1505         struct dib0700_adapter_state *state = adap->priv;
1506         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1507         u16 target;
1508         int ret = 0;
1509         enum frontend_tune_state tune_state = CT_SHUTDOWN;
1510         u16 ltgain, rf_gain_limit;
1511
1512         ret = state->set_param_save(fe, fep);
1513         if (ret < 0)
1514                 return ret;
1515
1516         target = (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1517         dib8000_set_wbd_ref(fe, target);
1518
1519
1520         if (band == BAND_CBAND) {
1521                 deb_info("tuning in CBAND - soft-AGC startup\n");
1522                 dib0090_set_tune_state(fe, CT_AGC_START);
1523                 do {
1524                         ret = dib0090_gain_control(fe);
1525                         msleep(ret);
1526                         tune_state = dib0090_get_tune_state(fe);
1527                         if (tune_state == CT_AGC_STEP_0)
1528                                 dib8000_set_gpio(fe, 6, 0, 1);
1529                         else if (tune_state == CT_AGC_STEP_1) {
1530                                 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1531                                 if (rf_gain_limit == 0)
1532                                         dib8000_set_gpio(fe, 6, 0, 0);
1533                         }
1534                 } while (tune_state < CT_AGC_STOP);
1535                 dib0090_pwm_gain_reset(fe);
1536                 dib8000_pwm_agc_reset(fe);
1537                 dib8000_set_tune_state(fe, CT_DEMOD_START);
1538         } else {
1539                 deb_info("not tuning in CBAND - standard AGC startup\n");
1540                 dib0090_pwm_gain_reset(fe);
1541         }
1542
1543         return 0;
1544 }
1545
1546 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1547 {
1548         struct dib0700_adapter_state *st = adap->priv;
1549         struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1550
1551         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1552                 return -ENODEV;
1553
1554         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1555         adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1556         return 0;
1557 }
1558
1559 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1560 {
1561         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1562         msleep(10);
1563         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1564         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1565         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1566
1567         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1568
1569         dib0700_ctrl_clock(adap->dev, 72, 1);
1570
1571         msleep(10);
1572         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1573         msleep(10);
1574         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1575
1576         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1577
1578         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1579
1580         return adap->fe == NULL ?  -ENODEV : 0;
1581 }
1582
1583 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1584 {
1585         struct dib0700_adapter_state *st = adap->priv;
1586         struct i2c_adapter *tun_i2c;
1587         struct dvb_frontend *fe_slave  = dib8000_get_slave_frontend(adap->fe, 1);
1588
1589         if (fe_slave) {
1590                 tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1591                 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1592                         return -ENODEV;
1593                 fe_slave->dvb = adap->fe->dvb;
1594                 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1595         }
1596         tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1597         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1598                 return -ENODEV;
1599
1600         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1601         adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1602
1603         return 0;
1604 }
1605
1606 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1607 {
1608         struct dvb_frontend *fe_slave;
1609
1610         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1611         msleep(20);
1612         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1613         msleep(1000);
1614         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1615         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1616         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1617
1618         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1619
1620         dib0700_ctrl_clock(adap->dev, 72, 1);
1621
1622         msleep(20);
1623         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1624         msleep(20);
1625         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1626
1627         dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80);
1628
1629         adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1630         if (adap->fe == NULL)
1631                 return -ENODEV;
1632
1633         fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1634         dib8000_set_slave_frontend(adap->fe, fe_slave);
1635
1636         return fe_slave == NULL ?  -ENODEV : 0;
1637 }
1638
1639 /* STK9090M */
1640 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1641 {
1642         return dib9000_fw_pid_filter(adapter->fe, index, pid, onoff);
1643 }
1644
1645 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1646 {
1647         return dib9000_fw_pid_filter_ctrl(adapter->fe, onoff);
1648 }
1649
1650 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
1651 {
1652         return dib9000_set_gpio(fe, 5, 0, !onoff);
1653 }
1654
1655 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
1656 {
1657         return dib9000_set_gpio(fe, 0, 0, onoff);
1658 }
1659
1660 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
1661 {
1662         u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
1663         u8 rb[2];
1664         struct i2c_msg msg[2] = {
1665                 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
1666                 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
1667         };
1668         u8 index_data;
1669
1670         dibx000_i2c_set_speed(i2c, 250);
1671
1672         if (i2c_transfer(i2c, msg, 2) != 2)
1673                 return -EIO;
1674
1675         switch (rb[0] << 8 | rb[1]) {
1676         case 0:
1677                         deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
1678                         return -EIO;
1679         case 1:
1680                         deb_info("Found DiB0170 rev2");
1681                         break;
1682         case 2:
1683                         deb_info("Found DiB0190 rev2");
1684                         break;
1685         default:
1686                         deb_info("DiB01x0 not found");
1687                         return -EIO;
1688         }
1689
1690         for (index_data = 0; index_data < len; index_data += 2) {
1691                 wb[2] = (data[index_data + 1] >> 8) & 0xff;
1692                 wb[3] = (data[index_data + 1]) & 0xff;
1693
1694                 if (data[index_data] == 0) {
1695                         wb[0] = (data[index_data] >> 8) & 0xff;
1696                         wb[1] = (data[index_data]) & 0xff;
1697                         msg[0].len = 2;
1698                         if (i2c_transfer(i2c, msg, 2) != 2)
1699                                 return -EIO;
1700                         wb[2] |= rb[0];
1701                         wb[3] |= rb[1] & ~(3 << 4);
1702                 }
1703
1704                 wb[0] = (data[index_data] >> 8)&0xff;
1705                 wb[1] = (data[index_data])&0xff;
1706                 msg[0].len = 4;
1707                 if (i2c_transfer(i2c, &msg[0], 1) != 1)
1708                         return -EIO;
1709         }
1710         return 0;
1711 }
1712
1713 static struct dib9000_config stk9090m_config = {
1714         .output_mpeg2_in_188_bytes = 1,
1715         .output_mode = OUTMODE_MPEG2_FIFO,
1716         .vcxo_timer = 279620,
1717         .timing_frequency = 20452225,
1718         .demod_clock_khz = 60000,
1719         .xtal_clock_khz = 30000,
1720         .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1721         .subband = {
1722                 2,
1723                 {
1724                         { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
1725                         { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
1726                         { 0 },
1727                 },
1728         },
1729         .gpio_function = {
1730                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1731                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1732         },
1733 };
1734
1735 static struct dib9000_config nim9090md_config[2] = {
1736         {
1737                 .output_mpeg2_in_188_bytes = 1,
1738                 .output_mode = OUTMODE_MPEG2_FIFO,
1739                 .vcxo_timer = 279620,
1740                 .timing_frequency = 20452225,
1741                 .demod_clock_khz = 60000,
1742                 .xtal_clock_khz = 30000,
1743                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1744         }, {
1745                 .output_mpeg2_in_188_bytes = 1,
1746                 .output_mode = OUTMODE_DIVERSITY,
1747                 .vcxo_timer = 279620,
1748                 .timing_frequency = 20452225,
1749                 .demod_clock_khz = 60000,
1750                 .xtal_clock_khz = 30000,
1751                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1752                 .subband = {
1753                         2,
1754                         {
1755                                 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
1756                                 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
1757                                 { 0 },
1758                         },
1759                 },
1760                 .gpio_function = {
1761                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1762                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1763                 },
1764         }
1765 };
1766
1767 static struct dib0090_config dib9090_dib0090_config = {
1768         .io.pll_bypass = 0,
1769         .io.pll_range = 1,
1770         .io.pll_prediv = 1,
1771         .io.pll_loopdiv = 8,
1772         .io.adc_clock_ratio = 8,
1773         .io.pll_int_loop_filt = 0,
1774         .io.clock_khz = 30000,
1775         .reset = dib90x0_tuner_reset,
1776         .sleep = dib90x0_tuner_sleep,
1777         .clkouttobamse = 0,
1778         .analog_output = 0,
1779         .use_pwm_agc = 0,
1780         .clkoutdrive = 0,
1781         .freq_offset_khz_uhf = 0,
1782         .freq_offset_khz_vhf = 0,
1783 };
1784
1785 static struct dib0090_config nim9090md_dib0090_config[2] = {
1786         {
1787                 .io.pll_bypass = 0,
1788                 .io.pll_range = 1,
1789                 .io.pll_prediv = 1,
1790                 .io.pll_loopdiv = 8,
1791                 .io.adc_clock_ratio = 8,
1792                 .io.pll_int_loop_filt = 0,
1793                 .io.clock_khz = 30000,
1794                 .reset = dib90x0_tuner_reset,
1795                 .sleep = dib90x0_tuner_sleep,
1796                 .clkouttobamse = 1,
1797                 .analog_output = 0,
1798                 .use_pwm_agc = 0,
1799                 .clkoutdrive = 0,
1800                 .freq_offset_khz_uhf = 0,
1801                 .freq_offset_khz_vhf = 0,
1802         }, {
1803                 .io.pll_bypass = 0,
1804                 .io.pll_range = 1,
1805                 .io.pll_prediv = 1,
1806                 .io.pll_loopdiv = 8,
1807                 .io.adc_clock_ratio = 8,
1808                 .io.pll_int_loop_filt = 0,
1809                 .io.clock_khz = 30000,
1810                 .reset = dib90x0_tuner_reset,
1811                 .sleep = dib90x0_tuner_sleep,
1812                 .clkouttobamse = 0,
1813                 .analog_output = 0,
1814                 .use_pwm_agc = 0,
1815                 .clkoutdrive = 0,
1816                 .freq_offset_khz_uhf = 0,
1817                 .freq_offset_khz_vhf = 0,
1818         }
1819 };
1820
1821
1822 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
1823 {
1824         struct dib0700_adapter_state *state = adap->priv;
1825         struct dib0700_state *st = adap->dev->priv;
1826         u32 fw_version;
1827
1828         /* Make use of the new i2c functions from FW 1.20 */
1829         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
1830         if (fw_version >= 0x10200)
1831                 st->fw_use_new_i2c_api = 1;
1832         dib0700_set_i2c_speed(adap->dev, 340);
1833
1834         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1835         msleep(20);
1836         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1837         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1838         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1839         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1840
1841         dib0700_ctrl_clock(adap->dev, 72, 1);
1842
1843         msleep(20);
1844         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1845         msleep(20);
1846         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1847
1848         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
1849
1850         if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
1851                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
1852                 return -ENODEV;
1853         } else {
1854                 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
1855         }
1856         stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
1857         stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
1858
1859         adap->fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
1860
1861         return adap->fe == NULL ?  -ENODEV : 0;
1862 }
1863
1864 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
1865 {
1866         struct dib0700_adapter_state *state = adap->priv;
1867         struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe);
1868         u16 data_dib190[10] = {
1869                 1, 0x1374,
1870                 2, 0x01a2,
1871                 7, 0x0020,
1872                 0, 0x00ef,
1873                 8, 0x0486,
1874         };
1875
1876         if (dvb_attach(dib0090_fw_register, adap->fe, i2c, &dib9090_dib0090_config) == NULL)
1877                 return -ENODEV;
1878         i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
1879         if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
1880                 return -ENODEV;
1881         dib0700_set_i2c_speed(adap->dev, 2000);
1882         if (dib9000_firmware_post_pll_init(adap->fe) < 0)
1883                 return -ENODEV;
1884         release_firmware(state->frontend_firmware);
1885         return 0;
1886 }
1887
1888 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
1889 {
1890         struct dib0700_adapter_state *state = adap->priv;
1891         struct dib0700_state *st = adap->dev->priv;
1892         struct i2c_adapter *i2c;
1893         struct dvb_frontend *fe_slave;
1894         u32 fw_version;
1895
1896         /* Make use of the new i2c functions from FW 1.20 */
1897         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
1898         if (fw_version >= 0x10200)
1899                 st->fw_use_new_i2c_api = 1;
1900         dib0700_set_i2c_speed(adap->dev, 340);
1901
1902         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1903         msleep(20);
1904         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1905         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1906         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1907         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1908
1909         dib0700_ctrl_clock(adap->dev, 72, 1);
1910
1911         msleep(20);
1912         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1913         msleep(20);
1914         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1915
1916         if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
1917                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
1918                 return -EIO;
1919         } else {
1920                 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
1921         }
1922         nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
1923         nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
1924         nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
1925         nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
1926
1927         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
1928         adap->fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
1929
1930         if (adap->fe == NULL)
1931                 return -ENODEV;
1932
1933         i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
1934         dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
1935
1936         fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
1937         dib9000_set_slave_frontend(adap->fe, fe_slave);
1938
1939         return fe_slave == NULL ?  -ENODEV : 0;
1940 }
1941
1942 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
1943 {
1944         struct dib0700_adapter_state *state = adap->priv;
1945         struct i2c_adapter *i2c;
1946         struct dvb_frontend *fe_slave;
1947         u16 data_dib190[10] = {
1948                 1, 0x5374,
1949                 2, 0x01ae,
1950                 7, 0x0020,
1951                 0, 0x00ef,
1952                 8, 0x0406,
1953         };
1954         i2c = dib9000_get_tuner_interface(adap->fe);
1955         if (dvb_attach(dib0090_fw_register, adap->fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
1956                 return -ENODEV;
1957         i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
1958         if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
1959                 return -ENODEV;
1960         dib0700_set_i2c_speed(adap->dev, 2000);
1961         if (dib9000_firmware_post_pll_init(adap->fe) < 0)
1962                 return -ENODEV;
1963
1964         fe_slave = dib9000_get_slave_frontend(adap->fe, 1);
1965         if (fe_slave != NULL) {
1966                 i2c = dib9000_get_component_bus_interface(adap->fe);
1967                 dib9000_set_i2c_adapter(fe_slave, i2c);
1968
1969                 i2c = dib9000_get_tuner_interface(fe_slave);
1970                 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
1971                         return -ENODEV;
1972                 fe_slave->dvb = adap->fe->dvb;
1973                 dib9000_fw_set_component_bus_speed(adap->fe, 2000);
1974                 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
1975                         return -ENODEV;
1976         }
1977         release_firmware(state->frontend_firmware);
1978
1979         return 0;
1980 }
1981
1982 /* NIM7090 */
1983 struct dib7090p_best_adc {
1984         u32 timf;
1985         u32 pll_loopdiv;
1986         u32 pll_prediv;
1987 };
1988
1989 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dib7090p_best_adc *adc)
1990 {
1991         u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
1992
1993         u16 xtal = 12000;
1994         u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
1995         u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
1996         u32 fdem_max = 76000;
1997         u32 fdem_min = 69500;
1998         u32 fcp = 0, fs = 0, fdem = 0;
1999         u32 harmonic_id = 0;
2000
2001         adc->pll_loopdiv = loopdiv;
2002         adc->pll_prediv = prediv;
2003         adc->timf = 0;
2004
2005         deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2006
2007         /* Find Min and Max prediv */
2008         while ((xtal/max_prediv) >= fcp_min)
2009                 max_prediv++;
2010
2011         max_prediv--;
2012         min_prediv = max_prediv;
2013         while ((xtal/min_prediv) <= fcp_max) {
2014                 min_prediv--;
2015                 if (min_prediv == 1)
2016                         break;
2017         }
2018         deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2019
2020         min_prediv = 2;
2021
2022         for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2023                 fcp = xtal / prediv;
2024                 if (fcp > fcp_min && fcp < fcp_max) {
2025                         for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2026                                 fdem = ((xtal/prediv) * loopdiv);
2027                                 fs   = fdem / 4;
2028                                 /* test min/max system restrictions */
2029
2030                                 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2031                                         spur = 0;
2032                                         /* test fs harmonics positions */
2033                                         for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2034                                                 if (((fs*harmonic_id) >= ((fe->dtv_property_cache.frequency/1000) - (fe->dtv_property_cache.bandwidth_hz/2000))) &&  ((fs*harmonic_id) <= ((fe->dtv_property_cache.frequency/1000) + (fe->dtv_property_cache.bandwidth_hz/2000)))) {
2035                                                         spur = 1;
2036                                                         break;
2037                                                 }
2038                                         }
2039
2040                                         if (!spur) {
2041                                                 adc->pll_loopdiv = loopdiv;
2042                                                 adc->pll_prediv = prediv;
2043                                                 adc->timf = 2396745143UL/fdem*(1 << 9);
2044                                                 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2045                                                 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2046                                                 break;
2047                                         }
2048                                 }
2049                         }
2050                 }
2051                 if (!spur)
2052                         break;
2053         }
2054
2055
2056         if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2057                 return -EINVAL;
2058         else
2059                 return 0;
2060 }
2061
2062 static int dib7090_agc_startup(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
2063 {
2064         struct dvb_usb_adapter *adap = fe->dvb->priv;
2065         struct dib0700_adapter_state *state = adap->priv;
2066         struct dibx000_bandwidth_config pll;
2067         u16 target;
2068         struct dib7090p_best_adc adc;
2069         int ret;
2070
2071         ret = state->set_param_save(fe, fep);
2072         if (ret < 0)
2073                 return ret;
2074
2075         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2076         dib0090_pwm_gain_reset(fe);
2077         target = (dib0090_get_wbd_offset(fe) * 8 + 1) / 2;
2078         dib7000p_set_wbd_ref(fe, target);
2079
2080         if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2081                 pll.pll_ratio  = adc.pll_loopdiv;
2082                 pll.pll_prediv = adc.pll_prediv;
2083
2084                 dib7000p_update_pll(fe, &pll);
2085                 dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2086         }
2087         return 0;
2088 }
2089
2090 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2091         { 380,   81, 850, 64, 540,  4},
2092         { 860,   51, 866, 21,  375, 4},
2093         {1700,    0, 250, 0,   100, 6},
2094         {2600,    0, 250, 0,   100, 6},
2095         { 0xFFFF, 0,   0, 0,   0,   0},
2096 };
2097
2098 struct dibx000_agc_config dib7090_agc_config[2] = {
2099         {
2100                 .band_caps      = BAND_UHF,
2101                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2102                 * 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 */
2103                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2104
2105                 .inv_gain       = 687,
2106                 .time_stabiliz  = 10,
2107
2108                 .alpha_level    = 0,
2109                 .thlock         = 118,
2110
2111                 .wbd_inv        = 0,
2112                 .wbd_ref        = 1200,
2113                 .wbd_sel        = 3,
2114                 .wbd_alpha      = 5,
2115
2116                 .agc1_max       = 65535,
2117                 .agc1_min       = 0,
2118
2119                 .agc2_max       = 65535,
2120                 .agc2_min       = 0,
2121
2122                 .agc1_pt1       = 0,
2123                 .agc1_pt2       = 32,
2124                 .agc1_pt3       = 114,
2125                 .agc1_slope1    = 143,
2126                 .agc1_slope2    = 144,
2127                 .agc2_pt1       = 114,
2128                 .agc2_pt2       = 227,
2129                 .agc2_slope1    = 116,
2130                 .agc2_slope2    = 117,
2131
2132                 .alpha_mant     = 18,
2133                 .alpha_exp      = 0,
2134                 .beta_mant      = 20,
2135                 .beta_exp       = 59,
2136
2137                 .perform_agc_softsplit = 0,
2138         } , {
2139                 .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
2140                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2141                 * 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 */
2142                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2143
2144                 .inv_gain       = 732,
2145                 .time_stabiliz  = 10,
2146
2147                 .alpha_level    = 0,
2148                 .thlock         = 118,
2149
2150                 .wbd_inv        = 0,
2151                 .wbd_ref        = 1200,
2152                 .wbd_sel        = 3,
2153                 .wbd_alpha      = 5,
2154
2155                 .agc1_max       = 65535,
2156                 .agc1_min       = 0,
2157
2158                 .agc2_max       = 65535,
2159                 .agc2_min       = 0,
2160
2161                 .agc1_pt1       = 0,
2162                 .agc1_pt2       = 0,
2163                 .agc1_pt3       = 98,
2164                 .agc1_slope1    = 0,
2165                 .agc1_slope2    = 167,
2166                 .agc2_pt1       = 98,
2167                 .agc2_pt2       = 255,
2168                 .agc2_slope1    = 104,
2169                 .agc2_slope2    = 0,
2170
2171                 .alpha_mant     = 18,
2172                 .alpha_exp      = 0,
2173                 .beta_mant      = 20,
2174                 .beta_exp       = 59,
2175
2176                 .perform_agc_softsplit = 0,
2177         }
2178 };
2179
2180 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2181         60000, 15000,
2182         1, 5, 0, 0, 0,
2183         0, 0, 1, 1, 2,
2184         (3 << 14) | (1 << 12) | (524 << 0),
2185         (0 << 25) | 0,
2186         20452225,
2187         15000000,
2188 };
2189
2190 static struct dib7000p_config nim7090_dib7000p_config = {
2191         .output_mpeg2_in_188_bytes  = 1,
2192         .hostbus_diversity                      = 1,
2193         .tuner_is_baseband                      = 1,
2194         .update_lna                                     = NULL,
2195
2196         .agc_config_count                       = 2,
2197         .agc                                            = dib7090_agc_config,
2198
2199         .bw                                                     = &dib7090_clock_config_12_mhz,
2200
2201         .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2202         .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2203         .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2204
2205         .pwm_freq_div                           = 0,
2206
2207         .agc_control                            = dib7090_agc_restart,
2208
2209         .spur_protect                           = 0,
2210         .disable_sample_and_hold        = 0,
2211         .enable_current_mirror          = 0,
2212         .diversity_delay                        = 0,
2213
2214         .output_mode                            = OUTMODE_MPEG2_FIFO,
2215         .enMpegOutput                           = 1,
2216 };
2217
2218 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2219         {
2220                 .output_mpeg2_in_188_bytes  = 1,
2221                 .hostbus_diversity                      = 1,
2222                 .tuner_is_baseband                      = 1,
2223                 .update_lna                                     = NULL,
2224
2225                 .agc_config_count                       = 2,
2226                 .agc                                            = dib7090_agc_config,
2227
2228                 .bw                                                     = &dib7090_clock_config_12_mhz,
2229
2230                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2231                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2232                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2233
2234                 .pwm_freq_div                           = 0,
2235
2236                 .agc_control                            = dib7090_agc_restart,
2237
2238                 .spur_protect                           = 0,
2239                 .disable_sample_and_hold        = 0,
2240                 .enable_current_mirror          = 0,
2241                 .diversity_delay                        = 0,
2242
2243                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2244                 .default_i2c_addr                       = 0x90,
2245                 .enMpegOutput                           = 1,
2246         }, {
2247                 .output_mpeg2_in_188_bytes  = 1,
2248                 .hostbus_diversity                      = 1,
2249                 .tuner_is_baseband                      = 1,
2250                 .update_lna                                     = NULL,
2251
2252                 .agc_config_count                       = 2,
2253                 .agc                                            = dib7090_agc_config,
2254
2255                 .bw                                                     = &dib7090_clock_config_12_mhz,
2256
2257                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2258                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2259                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2260
2261                 .pwm_freq_div                           = 0,
2262
2263                 .agc_control                            = dib7090_agc_restart,
2264
2265                 .spur_protect                           = 0,
2266                 .disable_sample_and_hold        = 0,
2267                 .enable_current_mirror          = 0,
2268                 .diversity_delay                        = 0,
2269
2270                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2271                 .default_i2c_addr                       = 0x92,
2272                 .enMpegOutput                           = 0,
2273         }
2274 };
2275
2276 static const struct dib0090_config nim7090_dib0090_config = {
2277         .io.clock_khz = 12000,
2278         .io.pll_bypass = 0,
2279         .io.pll_range = 0,
2280         .io.pll_prediv = 3,
2281         .io.pll_loopdiv = 6,
2282         .io.adc_clock_ratio = 0,
2283         .io.pll_int_loop_filt = 0,
2284         .reset = dib7090_tuner_sleep,
2285         .sleep = dib7090_tuner_sleep,
2286
2287         .freq_offset_khz_uhf = 0,
2288         .freq_offset_khz_vhf = 0,
2289
2290         .get_adc_power = dib7090_get_adc_power,
2291
2292         .clkouttobamse = 1,
2293         .analog_output = 0,
2294
2295         .wbd_vhf_offset = 0,
2296         .wbd_cband_offset = 0,
2297         .use_pwm_agc = 1,
2298         .clkoutdrive = 0,
2299
2300         .fref_clock_ratio = 0,
2301
2302         .wbd = dib7090_wbd_table,
2303
2304         .ls_cfg_pad_drv = 0,
2305         .data_tx_drv = 0,
2306         .low_if = NULL,
2307         .in_soc = 1,
2308 };
2309
2310 static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2311         {
2312                 .io.clock_khz = 12000,
2313                 .io.pll_bypass = 0,
2314                 .io.pll_range = 0,
2315                 .io.pll_prediv = 3,
2316                 .io.pll_loopdiv = 6,
2317                 .io.adc_clock_ratio = 0,
2318                 .io.pll_int_loop_filt = 0,
2319                 .reset = dib7090_tuner_sleep,
2320                 .sleep = dib7090_tuner_sleep,
2321
2322                 .freq_offset_khz_uhf = 50,
2323                 .freq_offset_khz_vhf = 70,
2324
2325                 .get_adc_power = dib7090_get_adc_power,
2326
2327                 .clkouttobamse = 1,
2328                 .analog_output = 0,
2329
2330                 .wbd_vhf_offset = 0,
2331                 .wbd_cband_offset = 0,
2332                 .use_pwm_agc = 1,
2333                 .clkoutdrive = 0,
2334
2335                 .fref_clock_ratio = 0,
2336
2337                 .wbd = dib7090_wbd_table,
2338
2339                 .ls_cfg_pad_drv = 0,
2340                 .data_tx_drv = 0,
2341                 .low_if = NULL,
2342                 .in_soc = 1,
2343         }, {
2344                 .io.clock_khz = 12000,
2345                 .io.pll_bypass = 0,
2346                 .io.pll_range = 0,
2347                 .io.pll_prediv = 3,
2348                 .io.pll_loopdiv = 6,
2349                 .io.adc_clock_ratio = 0,
2350                 .io.pll_int_loop_filt = 0,
2351                 .reset = dib7090_tuner_sleep,
2352                 .sleep = dib7090_tuner_sleep,
2353
2354                 .freq_offset_khz_uhf = -50,
2355                 .freq_offset_khz_vhf = -70,
2356
2357                 .get_adc_power = dib7090_get_adc_power,
2358
2359                 .clkouttobamse = 1,
2360                 .analog_output = 0,
2361
2362                 .wbd_vhf_offset = 0,
2363                 .wbd_cband_offset = 0,
2364                 .use_pwm_agc = 1,
2365                 .clkoutdrive = 0,
2366
2367                 .fref_clock_ratio = 0,
2368
2369                 .wbd = dib7090_wbd_table,
2370
2371                 .ls_cfg_pad_drv = 0,
2372                 .data_tx_drv = 0,
2373                 .low_if = NULL,
2374                 .in_soc = 1,
2375         }
2376 };
2377
2378 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
2379 {
2380         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2381         msleep(20);
2382         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2383         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2384         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2385         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2386
2387         msleep(20);
2388         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2389         msleep(20);
2390         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2391
2392         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
2393                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
2394                 return -ENODEV;
2395         }
2396         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
2397
2398         return adap->fe == NULL ?  -ENODEV : 0;
2399 }
2400
2401 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
2402 {
2403         struct dib0700_adapter_state *st = adap->priv;
2404         struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
2405
2406         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &nim7090_dib0090_config) == NULL)
2407                 return -ENODEV;
2408
2409         dib7000p_set_gpio(adap->fe, 8, 0, 1);
2410
2411         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
2412         adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2413         return 0;
2414 }
2415
2416 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
2417 {
2418         struct dib0700_state *st = adap->dev->priv;
2419
2420         /* The TFE7090 requires the dib0700 to not be in master mode */
2421         st->disable_streaming_master_mode = 1;
2422
2423         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2424         msleep(20);
2425         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2426         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2427         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2428         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2429
2430         msleep(20);
2431         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2432         msleep(20);
2433         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2434
2435         /* initialize IC 0 */
2436         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
2437                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
2438                 return -ENODEV;
2439         }
2440
2441         dib0700_set_i2c_speed(adap->dev, 340);
2442         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
2443         if (adap->fe == NULL)
2444                 return -ENODEV;
2445
2446         dib7090_slave_reset(adap->fe);
2447
2448         return 0;
2449 }
2450
2451 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
2452 {
2453         struct i2c_adapter *i2c;
2454
2455         if (adap->dev->adapter[0].fe == NULL) {
2456                 err("the master dib7090 has to be initialized first");
2457                 return -ENODEV; /* the master device has not been initialized */
2458         }
2459
2460         i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
2461         if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
2462                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
2463                 return -ENODEV;
2464         }
2465
2466         adap->fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
2467         dib0700_set_i2c_speed(adap->dev, 200);
2468
2469         return adap->fe == NULL ? -ENODEV : 0;
2470 }
2471
2472 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
2473 {
2474         struct dib0700_adapter_state *st = adap->priv;
2475         struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
2476
2477         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
2478                 return -ENODEV;
2479
2480         dib7000p_set_gpio(adap->fe, 8, 0, 1);
2481
2482         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
2483         adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2484         return 0;
2485 }
2486
2487 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
2488 {
2489         struct dib0700_adapter_state *st = adap->priv;
2490         struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
2491
2492         if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
2493                 return -ENODEV;
2494
2495         dib7000p_set_gpio(adap->fe, 8, 0, 1);
2496
2497         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
2498         adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2499         return 0;
2500 }
2501
2502 /* STK7070PD */
2503 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
2504         {
2505                 .output_mpeg2_in_188_bytes = 1,
2506
2507                 .agc_config_count = 1,
2508                 .agc = &dib7070_agc_config,
2509                 .bw  = &dib7070_bw_config_12_mhz,
2510                 .tuner_is_baseband = 1,
2511                 .spur_protect = 1,
2512
2513                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2514                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2515                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2516
2517                 .hostbus_diversity = 1,
2518         }, {
2519                 .output_mpeg2_in_188_bytes = 1,
2520
2521                 .agc_config_count = 1,
2522                 .agc = &dib7070_agc_config,
2523                 .bw  = &dib7070_bw_config_12_mhz,
2524                 .tuner_is_baseband = 1,
2525                 .spur_protect = 1,
2526
2527                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2528                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2529                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2530
2531                 .hostbus_diversity = 1,
2532         }
2533 };
2534
2535 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
2536 {
2537         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2538         msleep(10);
2539         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2540         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2541         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2542         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2543
2544         dib0700_ctrl_clock(adap->dev, 72, 1);
2545
2546         msleep(10);
2547         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2548         msleep(10);
2549         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2550
2551         if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
2552                                      stk7070pd_dib7000p_config) != 0) {
2553                 err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
2554                     __func__);
2555                 return -ENODEV;
2556         }
2557
2558         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
2559         return adap->fe == NULL ? -ENODEV : 0;
2560 }
2561
2562 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
2563 {
2564         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
2565         return adap->fe == NULL ? -ENODEV : 0;
2566 }
2567
2568 /* S5H1411 */
2569 static struct s5h1411_config pinnacle_801e_config = {
2570         .output_mode   = S5H1411_PARALLEL_OUTPUT,
2571         .gpio          = S5H1411_GPIO_OFF,
2572         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
2573         .qam_if        = S5H1411_IF_44000,
2574         .vsb_if        = S5H1411_IF_44000,
2575         .inversion     = S5H1411_INVERSION_OFF,
2576         .status_mode   = S5H1411_DEMODLOCKING
2577 };
2578
2579 /* Pinnacle PCTV HD Pro 801e GPIOs map:
2580    GPIO0  - currently unknown
2581    GPIO1  - xc5000 tuner reset
2582    GPIO2  - CX25843 sleep
2583    GPIO3  - currently unknown
2584    GPIO4  - currently unknown
2585    GPIO6  - currently unknown
2586    GPIO7  - currently unknown
2587    GPIO9  - currently unknown
2588    GPIO10 - CX25843 reset
2589  */
2590 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
2591 {
2592         struct dib0700_state *st = adap->dev->priv;
2593
2594         /* Make use of the new i2c functions from FW 1.20 */
2595         st->fw_use_new_i2c_api = 1;
2596
2597         /* The s5h1411 requires the dib0700 to not be in master mode */
2598         st->disable_streaming_master_mode = 1;
2599
2600         /* All msleep values taken from Windows USB trace */
2601         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
2602         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
2603         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2604         msleep(400);
2605         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2606         msleep(60);
2607         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2608         msleep(30);
2609         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2610         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2611         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2612         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2613         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
2614         msleep(30);
2615
2616         /* Put the CX25843 to sleep for now since we're in digital mode */
2617         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
2618
2619         /* GPIOs are initialized, do the attach */
2620         adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
2621                               &adap->dev->i2c_adap);
2622         return adap->fe == NULL ? -ENODEV : 0;
2623 }
2624
2625 static int dib0700_xc5000_tuner_callback(void *priv, int component,
2626                                          int command, int arg)
2627 {
2628         struct dvb_usb_adapter *adap = priv;
2629
2630         if (command == XC5000_TUNER_RESET) {
2631                 /* Reset the tuner */
2632                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
2633                 msleep(10);
2634                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
2635                 msleep(10);
2636         } else {
2637                 err("xc5000: unknown tuner callback command: %d\n", command);
2638                 return -EINVAL;
2639         }
2640
2641         return 0;
2642 }
2643
2644 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
2645         .i2c_address      = 0x64,
2646         .if_khz           = 5380,
2647 };
2648
2649 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
2650 {
2651         /* FIXME: generalize & move to common area */
2652         adap->fe->callback = dib0700_xc5000_tuner_callback;
2653
2654         return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
2655                           &s5h1411_xc5000_tunerconfig)
2656                 == NULL ? -ENODEV : 0;
2657 }
2658
2659 static int dib0700_xc4000_tuner_callback(void *priv, int component,
2660                                          int command, int arg)
2661 {
2662         struct dvb_usb_adapter *adap = priv;
2663
2664         if (command == XC4000_TUNER_RESET) {
2665                 /* Reset the tuner */
2666                 dib7000p_set_gpio(adap->fe, 8, 0, 0);
2667                 msleep(10);
2668                 dib7000p_set_gpio(adap->fe, 8, 0, 1);
2669         } else {
2670                 err("xc4000: unknown tuner callback command: %d\n", command);
2671                 return -EINVAL;
2672         }
2673
2674         return 0;
2675 }
2676
2677 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
2678         .band_caps = BAND_UHF | BAND_VHF,
2679         .setup = 0x64,
2680         .inv_gain = 0x02c8,
2681         .time_stabiliz = 0x15,
2682         .alpha_level = 0x00,
2683         .thlock = 0x76,
2684         .wbd_inv = 0x01,
2685         .wbd_ref = 0x0b33,
2686         .wbd_sel = 0x00,
2687         .wbd_alpha = 0x02,
2688         .agc1_max = 0x00,
2689         .agc1_min = 0x00,
2690         .agc2_max = 0x9b26,
2691         .agc2_min = 0x26ca,
2692         .agc1_pt1 = 0x00,
2693         .agc1_pt2 = 0x00,
2694         .agc1_pt3 = 0x00,
2695         .agc1_slope1 = 0x00,
2696         .agc1_slope2 = 0x00,
2697         .agc2_pt1 = 0x00,
2698         .agc2_pt2 = 0x80,
2699         .agc2_slope1 = 0x1d,
2700         .agc2_slope2 = 0x1d,
2701         .alpha_mant = 0x11,
2702         .alpha_exp = 0x1b,
2703         .beta_mant = 0x17,
2704         .beta_exp = 0x33,
2705         .perform_agc_softsplit = 0x00,
2706 };
2707
2708 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
2709         60000, 30000,   /* internal, sampling */
2710         1, 8, 3, 1, 0,  /* pll_cfg: prediv, ratio, range, reset, bypass */
2711         0, 0, 1, 1, 0,  /* misc: refdiv, bypclk_div, IO_CLK_en_core, */
2712                         /* ADClkSrc, modulo */
2713         (3 << 14) | (1 << 12) | 524,    /* sad_cfg: refsel, sel, freq_15k */
2714         39370534,       /* ifreq */
2715         20452225,       /* timf */
2716         30000000        /* xtal */
2717 };
2718
2719 /* FIXME: none of these inputs are validated yet */
2720 static struct dib7000p_config pctv_340e_config = {
2721         .output_mpeg2_in_188_bytes = 1,
2722
2723         .agc_config_count = 1,
2724         .agc = &stk7700p_7000p_xc4000_agc_config,
2725         .bw  = &stk7700p_xc4000_pll_config,
2726
2727         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
2728         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
2729         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
2730 };
2731
2732 /* PCTV 340e GPIOs map:
2733    dib0700:
2734    GPIO2  - CX25843 sleep
2735    GPIO3  - CS5340 reset
2736    GPIO5  - IRD
2737    GPIO6  - Power Supply
2738    GPIO8  - LNA (1=off 0=on)
2739    GPIO10 - CX25843 reset
2740    dib7000:
2741    GPIO8  - xc4000 reset
2742  */
2743 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
2744 {
2745         struct dib0700_state *st = adap->dev->priv;
2746
2747         /* Power Supply on */
2748         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
2749         msleep(50);
2750         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1);
2751         msleep(100); /* Allow power supply to settle before probing */
2752
2753         /* cx25843 reset */
2754         dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 0);
2755         msleep(1); /* cx25843 datasheet say 350us required */
2756         dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 1);
2757
2758         /* LNA off for now */
2759         dib0700_set_gpio(adap->dev, GPIO8,  GPIO_OUT, 1);
2760
2761         /* Put the CX25843 to sleep for now since we're in digital mode */
2762         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
2763
2764         /* FIXME: not verified yet */
2765         dib0700_ctrl_clock(adap->dev, 72, 1);
2766
2767         msleep(500);
2768
2769         if (dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
2770                 /* Demodulator not found for some reason? */
2771                 return -ENODEV;
2772         }
2773
2774         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x12,
2775                               &pctv_340e_config);
2776         st->is_dib7000pc = 1;
2777
2778         return adap->fe == NULL ? -ENODEV : 0;
2779 }
2780
2781 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
2782         .i2c_address      = 0x61,
2783         .default_pm       = 1,
2784         .dvb_amplitude    = 0,
2785         .set_smoothedcvbs = 0,
2786         .if_khz           = 5400
2787 };
2788
2789 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
2790 {
2791         struct i2c_adapter *tun_i2c;
2792
2793         /* The xc4000 is not on the main i2c bus */
2794         tun_i2c = dib7000p_get_i2c_master(adap->fe,
2795                                           DIBX000_I2C_INTERFACE_TUNER, 1);
2796         if (tun_i2c == NULL) {
2797                 printk(KERN_ERR "Could not reach tuner i2c bus\n");
2798                 return 0;
2799         }
2800
2801         /* Setup the reset callback */
2802         adap->fe->callback = dib0700_xc4000_tuner_callback;
2803
2804         return dvb_attach(xc4000_attach, adap->fe, tun_i2c,
2805                           &dib7000p_xc4000_tunerconfig)
2806                 == NULL ? -ENODEV : 0;
2807 }
2808
2809 static struct lgdt3305_config hcw_lgdt3305_config = {
2810         .i2c_addr           = 0x0e,
2811         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
2812         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
2813         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
2814         .deny_i2c_rptr      = 0,
2815         .spectral_inversion = 1,
2816         .qam_if_khz         = 6000,
2817         .vsb_if_khz         = 6000,
2818         .usref_8vsb         = 0x0500,
2819 };
2820
2821 static struct mxl5007t_config hcw_mxl5007t_config = {
2822         .xtal_freq_hz = MxL_XTAL_25_MHZ,
2823         .if_freq_hz = MxL_IF_6_MHZ,
2824         .invert_if = 1,
2825 };
2826
2827 /* TIGER-ATSC map:
2828    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
2829    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
2830    GPIO4  - SCL2
2831    GPIO6  - EN_TUNER
2832    GPIO7  - SDA2
2833    GPIO10 - DEM_RST
2834
2835    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
2836  */
2837 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
2838 {
2839         struct dib0700_state *st = adap->dev->priv;
2840
2841         /* Make use of the new i2c functions from FW 1.20 */
2842         st->fw_use_new_i2c_api = 1;
2843
2844         st->disable_streaming_master_mode = 1;
2845
2846         /* fe power enable */
2847         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
2848         msleep(30);
2849         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2850         msleep(30);
2851
2852         /* demod reset */
2853         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2854         msleep(30);
2855         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2856         msleep(30);
2857         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2858         msleep(30);
2859
2860         adap->fe = dvb_attach(lgdt3305_attach,
2861                               &hcw_lgdt3305_config,
2862                               &adap->dev->i2c_adap);
2863
2864         return adap->fe == NULL ? -ENODEV : 0;
2865 }
2866
2867 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
2868 {
2869         return dvb_attach(mxl5007t_attach, adap->fe,
2870                           &adap->dev->i2c_adap, 0x60,
2871                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
2872 }
2873
2874
2875 /* DVB-USB and USB stuff follows */
2876 struct usb_device_id dib0700_usb_id_table[] = {
2877 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
2878         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
2879         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
2880         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
2881         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
2882 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
2883         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
2884         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
2885         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
2886         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
2887 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
2888         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
2889         { USB_DEVICE(USB_VID_TERRATEC,
2890                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
2891         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
2892         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
2893 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
2894         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
2895         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
2896         { USB_DEVICE(USB_VID_PINNACLE,
2897                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
2898         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
2899 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
2900         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
2901         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
2902         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
2903         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
2904 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
2905         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
2906         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
2907         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
2908         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
2909 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
2910         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
2911         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
2912         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
2913         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
2914 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
2915         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
2916         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
2917         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
2918         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
2919 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
2920         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
2921         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
2922         { USB_DEVICE(USB_VID_TERRATEC,
2923                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
2924         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
2925 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
2926         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
2927         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
2928         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
2929         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
2930 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
2931         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
2932         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
2933         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
2934         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
2935 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
2936         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
2937         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
2938         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
2939         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
2940 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
2941         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
2942         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
2943         { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
2944         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
2945 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
2946         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
2947         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
2948         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
2949         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090M) },
2950 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM8096MD) },
2951         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090MD) },
2952         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM7090) },
2953         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7090PVR) },
2954         { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
2955 /* 75 */{ USB_DEVICE(USB_VID_MEDION,    USB_PID_CREATIX_CTX1921) },
2956         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E) },
2957         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E_SE) },
2958         { 0 }           /* Terminating entry */
2959 };
2960 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
2961
2962 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
2963         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
2964         .usb_ctrl          = DEVICE_SPECIFIC, \
2965         .firmware          = "dvb-usb-dib0700-1.20.fw", \
2966         .download_firmware = dib0700_download_firmware, \
2967         .no_reconnect      = 1, \
2968         .size_of_priv      = sizeof(struct dib0700_state), \
2969         .i2c_algo          = &dib0700_i2c_algo, \
2970         .identify_state    = dib0700_identify_state
2971
2972 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
2973         .streaming_ctrl   = dib0700_streaming_ctrl, \
2974         .stream = { \
2975                 .type = USB_BULK, \
2976                 .count = 4, \
2977                 .endpoint = ep, \
2978                 .u = { \
2979                         .bulk = { \
2980                                 .buffersize = 39480, \
2981                         } \
2982                 } \
2983         }
2984
2985 struct dvb_usb_device_properties dib0700_devices[] = {
2986         {
2987                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
2988
2989                 .num_adapters = 1,
2990                 .adapter = {
2991                         {
2992                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2993                                 .pid_filter_count = 32,
2994                                 .pid_filter       = stk7700p_pid_filter,
2995                                 .pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
2996                                 .frontend_attach  = stk7700p_frontend_attach,
2997                                 .tuner_attach     = stk7700p_tuner_attach,
2998
2999                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3000                         },
3001                 },
3002
3003                 .num_device_descs = 8,
3004                 .devices = {
3005                         {   "DiBcom STK7700P reference design",
3006                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3007                                 { NULL },
3008                         },
3009                         {   "Hauppauge Nova-T Stick",
3010                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3011                                 { NULL },
3012                         },
3013                         {   "AVerMedia AVerTV DVB-T Volar",
3014                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3015                                 { NULL },
3016                         },
3017                         {   "Compro Videomate U500",
3018                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3019                                 { NULL },
3020                         },
3021                         {   "Uniwill STK7700P based (Hama and others)",
3022                                 { &dib0700_usb_id_table[7], NULL },
3023                                 { NULL },
3024                         },
3025                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
3026                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3027                                 { NULL },
3028                         },
3029                         {   "AVerMedia AVerTV DVB-T Express",
3030                                 { &dib0700_usb_id_table[20] },
3031                                 { NULL },
3032                         },
3033                         {   "Gigabyte U7000",
3034                                 { &dib0700_usb_id_table[21], NULL },
3035                                 { NULL },
3036                         }
3037                 },
3038
3039                 .rc.core = {
3040                         .rc_interval      = DEFAULT_RC_INTERVAL,
3041                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3042                         .rc_query         = dib0700_rc_query_old_firmware,
3043                         .allowed_protos   = RC_TYPE_RC5 |
3044                                             RC_TYPE_RC6 |
3045                                             RC_TYPE_NEC,
3046                         .change_protocol  = dib0700_change_protocol,
3047                 },
3048         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3049
3050                 .num_adapters = 2,
3051                 .adapter = {
3052                         {
3053                                 .frontend_attach  = bristol_frontend_attach,
3054                                 .tuner_attach     = bristol_tuner_attach,
3055
3056                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3057                         }, {
3058                                 .frontend_attach  = bristol_frontend_attach,
3059                                 .tuner_attach     = bristol_tuner_attach,
3060
3061                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3062                         }
3063                 },
3064
3065                 .num_device_descs = 1,
3066                 .devices = {
3067                         {   "Hauppauge Nova-T 500 Dual DVB-T",
3068                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
3069                                 { NULL },
3070                         },
3071                 },
3072
3073                 .rc.core = {
3074                         .rc_interval      = DEFAULT_RC_INTERVAL,
3075                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3076                         .rc_query         = dib0700_rc_query_old_firmware,
3077                         .allowed_protos   = RC_TYPE_RC5 |
3078                                             RC_TYPE_RC6 |
3079                                             RC_TYPE_NEC,
3080                         .change_protocol = dib0700_change_protocol,
3081                 },
3082         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3083
3084                 .num_adapters = 2,
3085                 .adapter = {
3086                         {
3087                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3088                                 .pid_filter_count = 32,
3089                                 .pid_filter       = stk70x0p_pid_filter,
3090                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3091                                 .frontend_attach  = stk7700d_frontend_attach,
3092                                 .tuner_attach     = stk7700d_tuner_attach,
3093
3094                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3095                         }, {
3096                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3097                                 .pid_filter_count = 32,
3098                                 .pid_filter       = stk70x0p_pid_filter,
3099                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3100                                 .frontend_attach  = stk7700d_frontend_attach,
3101                                 .tuner_attach     = stk7700d_tuner_attach,
3102
3103                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3104                         }
3105                 },
3106
3107                 .num_device_descs = 5,
3108                 .devices = {
3109                         {   "Pinnacle PCTV 2000e",
3110                                 { &dib0700_usb_id_table[11], NULL },
3111                                 { NULL },
3112                         },
3113                         {   "Terratec Cinergy DT XS Diversity",
3114                                 { &dib0700_usb_id_table[12], NULL },
3115                                 { NULL },
3116                         },
3117                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
3118                                 { &dib0700_usb_id_table[13], NULL },
3119                                 { NULL },
3120                         },
3121                         {   "DiBcom STK7700D reference design",
3122                                 { &dib0700_usb_id_table[14], NULL },
3123                                 { NULL },
3124                         },
3125                         {   "YUAN High-Tech DiBcom STK7700D",
3126                                 { &dib0700_usb_id_table[55], NULL },
3127                                 { NULL },
3128                         },
3129
3130                 },
3131
3132                 .rc.core = {
3133                         .rc_interval      = DEFAULT_RC_INTERVAL,
3134                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3135                         .rc_query         = dib0700_rc_query_old_firmware,
3136                         .allowed_protos   = RC_TYPE_RC5 |
3137                                             RC_TYPE_RC6 |
3138                                             RC_TYPE_NEC,
3139                         .change_protocol = dib0700_change_protocol,
3140                 },
3141         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3142
3143                 .num_adapters = 1,
3144                 .adapter = {
3145                         {
3146                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3147                                 .pid_filter_count = 32,
3148                                 .pid_filter       = stk70x0p_pid_filter,
3149                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3150                                 .frontend_attach  = stk7700P2_frontend_attach,
3151                                 .tuner_attach     = stk7700d_tuner_attach,
3152
3153                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3154                         },
3155                 },
3156
3157                 .num_device_descs = 3,
3158                 .devices = {
3159                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
3160                                 { &dib0700_usb_id_table[23], NULL },
3161                                 { NULL },
3162                         },
3163                         {   "Yuan EC372S",
3164                                 { &dib0700_usb_id_table[31], NULL },
3165                                 { NULL },
3166                         },
3167                         {   "Terratec Cinergy T Express",
3168                                 { &dib0700_usb_id_table[42], NULL },
3169                                 { NULL },
3170                         }
3171                 },
3172
3173                 .rc.core = {
3174                         .rc_interval      = DEFAULT_RC_INTERVAL,
3175                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3176                         .module_name      = "dib0700",
3177                         .rc_query         = dib0700_rc_query_old_firmware,
3178                         .allowed_protos   = RC_TYPE_RC5 |
3179                                             RC_TYPE_RC6 |
3180                                             RC_TYPE_NEC,
3181                         .change_protocol = dib0700_change_protocol,
3182                 },
3183         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3184
3185                 .num_adapters = 1,
3186                 .adapter = {
3187                         {
3188                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3189                                 .pid_filter_count = 32,
3190                                 .pid_filter       = stk70x0p_pid_filter,
3191                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3192                                 .frontend_attach  = stk7070p_frontend_attach,
3193                                 .tuner_attach     = dib7070p_tuner_attach,
3194
3195                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3196
3197                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3198                         },
3199                 },
3200
3201                 .num_device_descs = 11,
3202                 .devices = {
3203                         {   "DiBcom STK7070P reference design",
3204                                 { &dib0700_usb_id_table[15], NULL },
3205                                 { NULL },
3206                         },
3207                         {   "Pinnacle PCTV DVB-T Flash Stick",
3208                                 { &dib0700_usb_id_table[16], NULL },
3209                                 { NULL },
3210                         },
3211                         {   "Artec T14BR DVB-T",
3212                                 { &dib0700_usb_id_table[22], NULL },
3213                                 { NULL },
3214                         },
3215                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
3216                                 { &dib0700_usb_id_table[24], NULL },
3217                                 { NULL },
3218                         },
3219                         {   "Hauppauge Nova-T Stick",
3220                                 { &dib0700_usb_id_table[25], NULL },
3221                                 { NULL },
3222                         },
3223                         {   "Hauppauge Nova-T MyTV.t",
3224                                 { &dib0700_usb_id_table[26], NULL },
3225                                 { NULL },
3226                         },
3227                         {   "Pinnacle PCTV 72e",
3228                                 { &dib0700_usb_id_table[29], NULL },
3229                                 { NULL },
3230                         },
3231                         {   "Pinnacle PCTV 73e",
3232                                 { &dib0700_usb_id_table[30], NULL },
3233                                 { NULL },
3234                         },
3235                         {   "Elgato EyeTV DTT",
3236                                 { &dib0700_usb_id_table[49], NULL },
3237                                 { NULL },
3238                         },
3239                         {   "Yuan PD378S",
3240                                 { &dib0700_usb_id_table[45], NULL },
3241                                 { NULL },
3242                         },
3243                         {   "Elgato EyeTV Dtt Dlx PD378S",
3244                                 { &dib0700_usb_id_table[50], NULL },
3245                                 { NULL },
3246                         },
3247                 },
3248
3249                 .rc.core = {
3250                         .rc_interval      = DEFAULT_RC_INTERVAL,
3251                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3252                         .module_name      = "dib0700",
3253                         .rc_query         = dib0700_rc_query_old_firmware,
3254                         .allowed_protos   = RC_TYPE_RC5 |
3255                                             RC_TYPE_RC6 |
3256                                             RC_TYPE_NEC,
3257                         .change_protocol  = dib0700_change_protocol,
3258                 },
3259         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3260
3261                 .num_adapters = 1,
3262                 .adapter = {
3263                         {
3264                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3265                                 .pid_filter_count = 32,
3266                                 .pid_filter       = stk70x0p_pid_filter,
3267                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3268                                 .frontend_attach  = stk7070p_frontend_attach,
3269                                 .tuner_attach     = dib7070p_tuner_attach,
3270
3271                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3272
3273                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3274                         },
3275                 },
3276
3277                 .num_device_descs = 3,
3278                 .devices = {
3279                         {   "Pinnacle PCTV 73A",
3280                                 { &dib0700_usb_id_table[56], NULL },
3281                                 { NULL },
3282                         },
3283                         {   "Pinnacle PCTV 73e SE",
3284                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
3285                                 { NULL },
3286                         },
3287                         {   "Pinnacle PCTV 282e",
3288                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
3289                                 { NULL },
3290                         },
3291                 },
3292
3293                 .rc.core = {
3294                         .rc_interval      = DEFAULT_RC_INTERVAL,
3295                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3296                         .module_name      = "dib0700",
3297                         .rc_query         = dib0700_rc_query_old_firmware,
3298                         .allowed_protos   = RC_TYPE_RC5 |
3299                                             RC_TYPE_RC6 |
3300                                             RC_TYPE_NEC,
3301                         .change_protocol  = dib0700_change_protocol,
3302                 },
3303         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3304
3305                 .num_adapters = 2,
3306                 .adapter = {
3307                         {
3308                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3309                                 .pid_filter_count = 32,
3310                                 .pid_filter       = stk70x0p_pid_filter,
3311                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3312                                 .frontend_attach  = stk7070pd_frontend_attach0,
3313                                 .tuner_attach     = dib7070p_tuner_attach,
3314
3315                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3316
3317                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3318                         }, {
3319                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3320                                 .pid_filter_count = 32,
3321                                 .pid_filter       = stk70x0p_pid_filter,
3322                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3323                                 .frontend_attach  = stk7070pd_frontend_attach1,
3324                                 .tuner_attach     = dib7070p_tuner_attach,
3325
3326                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3327
3328                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3329                         }
3330                 },
3331
3332                 .num_device_descs = 6,
3333                 .devices = {
3334                         {   "DiBcom STK7070PD reference design",
3335                                 { &dib0700_usb_id_table[17], NULL },
3336                                 { NULL },
3337                         },
3338                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
3339                                 { &dib0700_usb_id_table[18], NULL },
3340                                 { NULL },
3341                         },
3342                         {   "Hauppauge Nova-TD Stick (52009)",
3343                                 { &dib0700_usb_id_table[35], NULL },
3344                                 { NULL },
3345                         },
3346                         {   "Hauppauge Nova-TD-500 (84xxx)",
3347                                 { &dib0700_usb_id_table[36], NULL },
3348                                 { NULL },
3349                         },
3350                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
3351                                 { &dib0700_usb_id_table[43],
3352                                         &dib0700_usb_id_table[53], NULL},
3353                                 { NULL },
3354                         },
3355                         {  "Sony PlayTV",
3356                                 { &dib0700_usb_id_table[44], NULL },
3357                                 { NULL },
3358                         },
3359                 },
3360
3361                 .rc.core = {
3362                         .rc_interval      = DEFAULT_RC_INTERVAL,
3363                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3364                         .module_name      = "dib0700",
3365                         .rc_query         = dib0700_rc_query_old_firmware,
3366                         .allowed_protos   = RC_TYPE_RC5 |
3367                                             RC_TYPE_RC6 |
3368                                             RC_TYPE_NEC,
3369                         .change_protocol = dib0700_change_protocol,
3370                 },
3371         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3372
3373                 .num_adapters = 2,
3374                 .adapter = {
3375                         {
3376                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3377                                 .pid_filter_count = 32,
3378                                 .pid_filter       = stk70x0p_pid_filter,
3379                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3380                                 .frontend_attach  = stk7070pd_frontend_attach0,
3381                                 .tuner_attach     = dib7070p_tuner_attach,
3382
3383                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3384
3385                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3386                         }, {
3387                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3388                                 .pid_filter_count = 32,
3389                                 .pid_filter       = stk70x0p_pid_filter,
3390                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3391                                 .frontend_attach  = stk7070pd_frontend_attach1,
3392                                 .tuner_attach     = dib7070p_tuner_attach,
3393
3394                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3395
3396                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
3397                         }
3398                 },
3399
3400                 .num_device_descs = 1,
3401                 .devices = {
3402                         {   "Elgato EyeTV Diversity",
3403                                 { &dib0700_usb_id_table[68], NULL },
3404                                 { NULL },
3405                         },
3406                 },
3407
3408                 .rc.core = {
3409                         .rc_interval      = DEFAULT_RC_INTERVAL,
3410                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
3411                         .module_name      = "dib0700",
3412                         .rc_query         = dib0700_rc_query_old_firmware,
3413                         .allowed_protos   = RC_TYPE_RC5 |
3414                                             RC_TYPE_RC6 |
3415                                             RC_TYPE_NEC,
3416                         .change_protocol  = dib0700_change_protocol,
3417                 },
3418         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3419
3420                 .num_adapters = 1,
3421                 .adapter = {
3422                         {
3423                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3424                                 .pid_filter_count = 32,
3425                                 .pid_filter       = stk70x0p_pid_filter,
3426                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3427                                 .frontend_attach  = stk7700ph_frontend_attach,
3428                                 .tuner_attach     = stk7700ph_tuner_attach,
3429
3430                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3431
3432                                 .size_of_priv = sizeof(struct
3433                                                 dib0700_adapter_state),
3434                         },
3435                 },
3436
3437                 .num_device_descs = 9,
3438                 .devices = {
3439                         {   "Terratec Cinergy HT USB XE",
3440                                 { &dib0700_usb_id_table[27], NULL },
3441                                 { NULL },
3442                         },
3443                         {   "Pinnacle Expresscard 320cx",
3444                                 { &dib0700_usb_id_table[28], NULL },
3445                                 { NULL },
3446                         },
3447                         {   "Terratec Cinergy HT Express",
3448                                 { &dib0700_usb_id_table[32], NULL },
3449                                 { NULL },
3450                         },
3451                         {   "Gigabyte U8000-RH",
3452                                 { &dib0700_usb_id_table[37], NULL },
3453                                 { NULL },
3454                         },
3455                         {   "YUAN High-Tech STK7700PH",
3456                                 { &dib0700_usb_id_table[38], NULL },
3457                                 { NULL },
3458                         },
3459                         {   "Asus My Cinema-U3000Hybrid",
3460                                 { &dib0700_usb_id_table[39], NULL },
3461                                 { NULL },
3462                         },
3463                         {   "YUAN High-Tech MC770",
3464                                 { &dib0700_usb_id_table[48], NULL },
3465                                 { NULL },
3466                         },
3467                         {   "Leadtek WinFast DTV Dongle H",
3468                                 { &dib0700_usb_id_table[51], NULL },
3469                                 { NULL },
3470                         },
3471                         {   "YUAN High-Tech STK7700D",
3472                                 { &dib0700_usb_id_table[54], NULL },
3473                                 { NULL },
3474                         },
3475                 },
3476
3477                 .rc.core = {
3478                         .rc_interval      = DEFAULT_RC_INTERVAL,
3479                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3480                         .module_name      = "dib0700",
3481                         .rc_query         = dib0700_rc_query_old_firmware,
3482                         .allowed_protos   = RC_TYPE_RC5 |
3483                                             RC_TYPE_RC6 |
3484                                             RC_TYPE_NEC,
3485                         .change_protocol  = dib0700_change_protocol,
3486                 },
3487         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3488                 .num_adapters = 1,
3489                 .adapter = {
3490                         {
3491                                 .frontend_attach  = s5h1411_frontend_attach,
3492                                 .tuner_attach     = xc5000_tuner_attach,
3493
3494                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3495
3496                                 .size_of_priv = sizeof(struct
3497                                                 dib0700_adapter_state),
3498                         },
3499                 },
3500
3501                 .num_device_descs = 2,
3502                 .devices = {
3503                         {   "Pinnacle PCTV HD Pro USB Stick",
3504                                 { &dib0700_usb_id_table[40], NULL },
3505                                 { NULL },
3506                         },
3507                         {   "Pinnacle PCTV HD USB Stick",
3508                                 { &dib0700_usb_id_table[41], NULL },
3509                                 { NULL },
3510                         },
3511                 },
3512
3513                 .rc.core = {
3514                         .rc_interval      = DEFAULT_RC_INTERVAL,
3515                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3516                         .module_name      = "dib0700",
3517                         .rc_query         = dib0700_rc_query_old_firmware,
3518                         .allowed_protos   = RC_TYPE_RC5 |
3519                                             RC_TYPE_RC6 |
3520                                             RC_TYPE_NEC,
3521                         .change_protocol  = dib0700_change_protocol,
3522                 },
3523         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3524                 .num_adapters = 1,
3525                 .adapter = {
3526                         {
3527                                 .frontend_attach  = lgdt3305_frontend_attach,
3528                                 .tuner_attach     = mxl5007t_tuner_attach,
3529
3530                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3531
3532                                 .size_of_priv = sizeof(struct
3533                                                 dib0700_adapter_state),
3534                         },
3535                 },
3536
3537                 .num_device_descs = 2,
3538                 .devices = {
3539                         {   "Hauppauge ATSC MiniCard (B200)",
3540                                 { &dib0700_usb_id_table[46], NULL },
3541                                 { NULL },
3542                         },
3543                         {   "Hauppauge ATSC MiniCard (B210)",
3544                                 { &dib0700_usb_id_table[47], NULL },
3545                                 { NULL },
3546                         },
3547                 },
3548         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3549
3550                 .num_adapters = 1,
3551                 .adapter = {
3552                         {
3553                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3554                                 .pid_filter_count = 32,
3555                                 .pid_filter       = stk70x0p_pid_filter,
3556                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
3557                                 .frontend_attach  = stk7770p_frontend_attach,
3558                                 .tuner_attach     = dib7770p_tuner_attach,
3559
3560                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3561
3562                                 .size_of_priv =
3563                                         sizeof(struct dib0700_adapter_state),
3564                         },
3565                 },
3566
3567                 .num_device_descs = 4,
3568                 .devices = {
3569                         {   "DiBcom STK7770P reference design",
3570                                 { &dib0700_usb_id_table[59], NULL },
3571                                 { NULL },
3572                         },
3573                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
3574                                 { &dib0700_usb_id_table[33],
3575                                         &dib0700_usb_id_table[52],
3576                                         &dib0700_usb_id_table[60], NULL},
3577                                 { NULL },
3578                         },
3579                         {   "TechniSat AirStar TeleStick 2",
3580                                 { &dib0700_usb_id_table[74], NULL },
3581                                 { NULL },
3582                         },
3583                         {   "Medion CTX1921 DVB-T USB",
3584                                 { &dib0700_usb_id_table[75], NULL },
3585                                 { NULL },
3586                         },
3587                 },
3588
3589                 .rc.core = {
3590                         .rc_interval      = DEFAULT_RC_INTERVAL,
3591                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3592                         .module_name      = "dib0700",
3593                         .rc_query         = dib0700_rc_query_old_firmware,
3594                         .allowed_protos   = RC_TYPE_RC5 |
3595                                             RC_TYPE_RC6 |
3596                                             RC_TYPE_NEC,
3597                         .change_protocol  = dib0700_change_protocol,
3598                 },
3599         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3600                 .num_adapters = 1,
3601                 .adapter = {
3602                         {
3603                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3604                                 .pid_filter_count = 32,
3605                                 .pid_filter = stk80xx_pid_filter,
3606                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3607                                 .frontend_attach  = stk807x_frontend_attach,
3608                                 .tuner_attach     = dib807x_tuner_attach,
3609
3610                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3611
3612                                 .size_of_priv =
3613                                         sizeof(struct dib0700_adapter_state),
3614                         },
3615                 },
3616
3617                 .num_device_descs = 3,
3618                 .devices = {
3619                         {   "DiBcom STK807xP reference design",
3620                                 { &dib0700_usb_id_table[62], NULL },
3621                                 { NULL },
3622                         },
3623                         {   "Prolink Pixelview SBTVD",
3624                                 { &dib0700_usb_id_table[63], NULL },
3625                                 { NULL },
3626                         },
3627                         {   "EvolutePC TVWay+",
3628                                 { &dib0700_usb_id_table[64], NULL },
3629                                 { NULL },
3630                         },
3631                 },
3632
3633                 .rc.core = {
3634                         .rc_interval      = DEFAULT_RC_INTERVAL,
3635                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
3636                         .module_name      = "dib0700",
3637                         .rc_query         = dib0700_rc_query_old_firmware,
3638                         .allowed_protos   = RC_TYPE_RC5 |
3639                                             RC_TYPE_RC6 |
3640                                             RC_TYPE_NEC,
3641                         .change_protocol  = dib0700_change_protocol,
3642                 },
3643         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3644                 .num_adapters = 2,
3645                 .adapter = {
3646                         {
3647                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3648                                 .pid_filter_count = 32,
3649                                 .pid_filter = stk80xx_pid_filter,
3650                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3651                                 .frontend_attach  = stk807xpvr_frontend_attach0,
3652                                 .tuner_attach     = dib807x_tuner_attach,
3653
3654                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3655
3656                                 .size_of_priv =
3657                                         sizeof(struct dib0700_adapter_state),
3658                         },
3659                         {
3660                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3661                                 .pid_filter_count = 32,
3662                                 .pid_filter = stk80xx_pid_filter,
3663                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3664                                 .frontend_attach  = stk807xpvr_frontend_attach1,
3665                                 .tuner_attach     = dib807x_tuner_attach,
3666
3667                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3668
3669                                 .size_of_priv =
3670                                         sizeof(struct dib0700_adapter_state),
3671                         },
3672                 },
3673
3674                 .num_device_descs = 1,
3675                 .devices = {
3676                         {   "DiBcom STK807xPVR reference design",
3677                                 { &dib0700_usb_id_table[61], NULL },
3678                                 { NULL },
3679                         },
3680                 },
3681
3682                 .rc.core = {
3683                         .rc_interval      = DEFAULT_RC_INTERVAL,
3684                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3685                         .module_name      = "dib0700",
3686                         .rc_query         = dib0700_rc_query_old_firmware,
3687                         .allowed_protos   = RC_TYPE_RC5 |
3688                                             RC_TYPE_RC6 |
3689                                             RC_TYPE_NEC,
3690                         .change_protocol  = dib0700_change_protocol,
3691                 },
3692         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3693                 .num_adapters = 1,
3694                 .adapter = {
3695                         {
3696                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3697                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3698                                 .pid_filter_count = 32,
3699                                 .pid_filter = stk80xx_pid_filter,
3700                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3701                                 .frontend_attach  = stk809x_frontend_attach,
3702                                 .tuner_attach     = dib809x_tuner_attach,
3703
3704                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3705
3706                                 .size_of_priv =
3707                                         sizeof(struct dib0700_adapter_state),
3708                         },
3709                 },
3710
3711                 .num_device_descs = 1,
3712                 .devices = {
3713                         {   "DiBcom STK8096GP reference design",
3714                                 { &dib0700_usb_id_table[67], NULL },
3715                                 { NULL },
3716                         },
3717                 },
3718
3719                 .rc.core = {
3720                         .rc_interval      = DEFAULT_RC_INTERVAL,
3721                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3722                         .module_name      = "dib0700",
3723                         .rc_query         = dib0700_rc_query_old_firmware,
3724                         .allowed_protos   = RC_TYPE_RC5 |
3725                                             RC_TYPE_RC6 |
3726                                             RC_TYPE_NEC,
3727                         .change_protocol  = dib0700_change_protocol,
3728                 },
3729         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3730                 .num_adapters = 1,
3731                 .adapter = {
3732                         {
3733                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3734                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3735                                 .pid_filter_count = 32,
3736                                 .pid_filter = dib90x0_pid_filter,
3737                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
3738                                 .frontend_attach  = stk9090m_frontend_attach,
3739                                 .tuner_attach     = dib9090_tuner_attach,
3740
3741                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3742
3743                                 .size_of_priv =
3744                                         sizeof(struct dib0700_adapter_state),
3745                         },
3746                 },
3747
3748                 .num_device_descs = 1,
3749                 .devices = {
3750                         {   "DiBcom STK9090M reference design",
3751                                 { &dib0700_usb_id_table[69], NULL },
3752                                 { NULL },
3753                         },
3754                 },
3755
3756                 .rc.core = {
3757                         .rc_interval      = DEFAULT_RC_INTERVAL,
3758                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3759                         .module_name      = "dib0700",
3760                         .rc_query         = dib0700_rc_query_old_firmware,
3761                         .allowed_protos   = RC_TYPE_RC5 |
3762                                             RC_TYPE_RC6 |
3763                                             RC_TYPE_NEC,
3764                         .change_protocol  = dib0700_change_protocol,
3765                 },
3766         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3767                 .num_adapters = 1,
3768                 .adapter = {
3769                         {
3770                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3771                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3772                                 .pid_filter_count = 32,
3773                                 .pid_filter = stk80xx_pid_filter,
3774                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3775                                 .frontend_attach  = nim8096md_frontend_attach,
3776                                 .tuner_attach     = nim8096md_tuner_attach,
3777
3778                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3779
3780                                 .size_of_priv =
3781                                         sizeof(struct dib0700_adapter_state),
3782                         },
3783                 },
3784
3785                 .num_device_descs = 1,
3786                 .devices = {
3787                         {   "DiBcom NIM8096MD reference design",
3788                                 { &dib0700_usb_id_table[70], NULL },
3789                                 { NULL },
3790                         },
3791                 },
3792
3793                 .rc.core = {
3794                         .rc_interval      = DEFAULT_RC_INTERVAL,
3795                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3796                         .module_name      = "dib0700",
3797                         .rc_query         = dib0700_rc_query_old_firmware,
3798                         .allowed_protos   = RC_TYPE_RC5 |
3799                                             RC_TYPE_RC6 |
3800                                             RC_TYPE_NEC,
3801                         .change_protocol  = dib0700_change_protocol,
3802                 },
3803         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3804                 .num_adapters = 1,
3805                 .adapter = {
3806                         {
3807                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3808                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3809                                 .pid_filter_count = 32,
3810                                 .pid_filter = dib90x0_pid_filter,
3811                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
3812                                 .frontend_attach  = nim9090md_frontend_attach,
3813                                 .tuner_attach     = nim9090md_tuner_attach,
3814
3815                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3816
3817                                 .size_of_priv =
3818                                         sizeof(struct dib0700_adapter_state),
3819                         },
3820                 },
3821
3822                 .num_device_descs = 1,
3823                 .devices = {
3824                         {   "DiBcom NIM9090MD reference design",
3825                                 { &dib0700_usb_id_table[71], NULL },
3826                                 { NULL },
3827                         },
3828                 },
3829
3830                 .rc.core = {
3831                         .rc_interval      = DEFAULT_RC_INTERVAL,
3832                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3833                         .module_name      = "dib0700",
3834                         .rc_query         = dib0700_rc_query_old_firmware,
3835                         .allowed_protos   = RC_TYPE_RC5 |
3836                                             RC_TYPE_RC6 |
3837                                             RC_TYPE_NEC,
3838                         .change_protocol  = dib0700_change_protocol,
3839                 },
3840         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3841                 .num_adapters = 1,
3842                 .adapter = {
3843                         {
3844                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3845                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3846                                 .pid_filter_count = 32,
3847                                 .pid_filter = stk70x0p_pid_filter,
3848                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3849                                 .frontend_attach  = nim7090_frontend_attach,
3850                                 .tuner_attach     = nim7090_tuner_attach,
3851
3852                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3853
3854                                 .size_of_priv =
3855                                         sizeof(struct dib0700_adapter_state),
3856                         },
3857                 },
3858
3859                 .num_device_descs = 1,
3860                 .devices = {
3861                         {   "DiBcom NIM7090 reference design",
3862                                 { &dib0700_usb_id_table[72], NULL },
3863                                 { NULL },
3864                         },
3865                 },
3866
3867                 .rc.core = {
3868                         .rc_interval      = DEFAULT_RC_INTERVAL,
3869                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3870                         .module_name      = "dib0700",
3871                         .rc_query         = dib0700_rc_query_old_firmware,
3872                         .allowed_protos   = RC_TYPE_RC5 |
3873                                             RC_TYPE_RC6 |
3874                                             RC_TYPE_NEC,
3875                         .change_protocol  = dib0700_change_protocol,
3876                 },
3877         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3878                 .num_adapters = 2,
3879                 .adapter = {
3880                         {
3881                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3882                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3883                                 .pid_filter_count = 32,
3884                                 .pid_filter = stk70x0p_pid_filter,
3885                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3886                                 .frontend_attach  = tfe7090pvr_frontend0_attach,
3887                                 .tuner_attach     = tfe7090pvr_tuner0_attach,
3888
3889                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3890
3891                                 .size_of_priv =
3892                                         sizeof(struct dib0700_adapter_state),
3893                         },
3894                         {
3895                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
3896                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3897                                 .pid_filter_count = 32,
3898                                 .pid_filter = stk70x0p_pid_filter,
3899                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3900                                 .frontend_attach  = tfe7090pvr_frontend1_attach,
3901                                 .tuner_attach     = tfe7090pvr_tuner1_attach,
3902
3903                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3904
3905                                 .size_of_priv =
3906                                         sizeof(struct dib0700_adapter_state),
3907                         },
3908                 },
3909
3910                 .num_device_descs = 1,
3911                 .devices = {
3912                         {   "DiBcom TFE7090PVR reference design",
3913                                 { &dib0700_usb_id_table[73], NULL },
3914                                 { NULL },
3915                         },
3916                 },
3917
3918                 .rc.core = {
3919                         .rc_interval      = DEFAULT_RC_INTERVAL,
3920                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3921                         .module_name      = "dib0700",
3922                         .rc_query         = dib0700_rc_query_old_firmware,
3923                         .allowed_protos   = RC_TYPE_RC5 |
3924                                             RC_TYPE_RC6 |
3925                                             RC_TYPE_NEC,
3926                         .change_protocol  = dib0700_change_protocol,
3927                 },
3928         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3929                 .num_adapters = 1,
3930                 .adapter = {
3931                         {
3932                                 .frontend_attach  = pctv340e_frontend_attach,
3933                                 .tuner_attach     = xc4000_tuner_attach,
3934
3935                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3936
3937                                 .size_of_priv = sizeof(struct
3938                                                 dib0700_adapter_state),
3939                         },
3940                 },
3941
3942                 .num_device_descs = 2,
3943                 .devices = {
3944                         {   "Pinnacle PCTV 340e HD Pro USB Stick",
3945                                 { &dib0700_usb_id_table[76], NULL },
3946                                 { NULL },
3947                         },
3948                         {   "Pinnacle PCTV Hybrid Stick Solo",
3949                                 { &dib0700_usb_id_table[77], NULL },
3950                                 { NULL },
3951                         },
3952                 },
3953                 .rc.core = {
3954                         .rc_interval      = DEFAULT_RC_INTERVAL,
3955                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
3956                         .module_name      = "dib0700",
3957                         .rc_query         = dib0700_rc_query_old_firmware,
3958                         .allowed_protos   = RC_TYPE_RC5 |
3959                                             RC_TYPE_RC6 |
3960                                             RC_TYPE_NEC,
3961                         .change_protocol  = dib0700_change_protocol,
3962                 },
3963         },
3964 };
3965
3966 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);