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