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