drivers/media/usb/dvb-usb/dib0700

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
bristol_frontend_attach
eeprom_read
bristol_tuner_attach
stk7700P2_frontend_attach
stk7700d_frontend_attach
stk7700d_tuner_attach
stk7700ph_xc3028_callback
stk7700ph_frontend_attach
stk7700ph_tuner_attach
dib0700_rc_query_old_firmware
stk7700p_frontend_attach
stk7700p_tuner_attach
dib7070_tuner_reset
dib7070_tuner_sleep
dib7070_set_param_override
dib7770_set_param_override
dib7770p_tuner_attach
dib7070p_tuner_attach
stk7700p_pid_filter
stk7700p_pid_filter_ctrl
stk70x0p_pid_filter
stk70x0p_pid_filter_ctrl
stk7070p_frontend_attach
stk7770p_frontend_attach
dib80xx_tuner_reset
dib80xx_tuner_sleep
dib807x_set_param_override
dib807x_tuner_attach
stk80xx_pid_filter
stk80xx_pid_filter_ctrl
stk807x_frontend_attach
stk807xpvr_frontend_attach0
stk807xpvr_frontend_attach1
dib8090_get_adc_power
dib8090_agc_control
dib8090_compute_pll_parameters
dib8096_set_param_override
dib809x_tuner_attach
stk809x_frontend_attach
stk809x_frontend1_attach
nim8096md_tuner_attach
nim8096md_frontend_attach
dib8096p_get_best_sampling
dib8096p_agc_startup
tfe8096p_frontend_attach
tfe8096p_tuner_attach
dib90x0_pid_filter
dib90x0_pid_filter_ctrl
dib90x0_tuner_reset
dib90x0_tuner_sleep
dib01x0_pmu_update
stk9090m_frontend_attach
dib9090_tuner_attach
nim9090md_frontend_attach
nim9090md_tuner_attach
dib7090p_get_best_sampling
dib7090_agc_startup
dib7090_agc_restart
tfe7790p_update_lna
tfe7090p_pvr_update_lna
nim7090_frontend_attach
nim7090_tuner_attach
tfe7090pvr_frontend0_attach
tfe7090pvr_frontend1_attach
tfe7090pvr_tuner0_attach
tfe7090pvr_tuner1_attach
tfe7790p_frontend_attach
tfe7790p_tuner_attach
stk7070pd_init
stk7070pd_frontend_attach0
stk7070pd_frontend_attach1
novatd_read_status_override
novatd_sleep_override
novatd_frontend_attach
s5h1411_frontend_attach
dib0700_xc5000_tuner_callback
xc5000_tuner_attach
dib0700_xc4000_tuner_callback
pctv340e_frontend_attach
xc4000_tuner_attach
lgdt3305_frontend_attach
mxl5007t_tuner_attach
xbox_one_attach
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
   3  *
   4  *  Copyright (C) 2005-9 DiBcom, SA et al
   5  */
   6 #include "dib0700.h"
   7 
   8 #include "dib3000mc.h"
   9 #include "dib7000m.h"
  10 #include "dib7000p.h"
  11 #include "dib8000.h"
  12 #include "dib9000.h"
  13 #include "mt2060.h"
  14 #include "mt2266.h"
  15 #include "tuner-xc2028.h"
  16 #include "xc5000.h"
  17 #include "xc4000.h"
  18 #include "s5h1411.h"
  19 #include "dib0070.h"
  20 #include "dib0090.h"
  21 #include "lgdt3305.h"
  22 #include "mxl5007t.h"
  23 #include "mn88472.h"
  24 #include "tda18250.h"
  25 
  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-Amplifier(s) (LNA), if applicable for the device (default: 0=automatic/off).");
  30 
  31 struct dib0700_adapter_state {
  32         int (*set_param_save) (struct dvb_frontend *);
  33         const struct firmware *frontend_firmware;
  34         struct dib7000p_ops dib7000p_ops;
  35         struct dib8000_ops dib8000_ops;
  36 };
  37 
  38 /* Hauppauge Nova-T 500 (aka Bristol)
  39  *  has a LNA on GPIO0 which is enabled by setting 1 */
  40 static struct mt2060_config bristol_mt2060_config[2] = {
  41         {
  42                 .i2c_address = 0x60,
  43                 .clock_out   = 3,
  44         }, {
  45                 .i2c_address = 0x61,
  46         }
  47 };
  48 
  49 
  50 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  51         .band_caps = BAND_VHF | BAND_UHF,
  52         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  53 
  54         .agc1_max = 42598,
  55         .agc1_min = 17694,
  56         .agc2_max = 45875,
  57         .agc2_min = 0,
  58 
  59         .agc1_pt1 = 0,
  60         .agc1_pt2 = 59,
  61 
  62         .agc1_slope1 = 0,
  63         .agc1_slope2 = 69,
  64 
  65         .agc2_pt1 = 0,
  66         .agc2_pt2 = 59,
  67 
  68         .agc2_slope1 = 111,
  69         .agc2_slope2 = 28,
  70 };
  71 
  72 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  73         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  74                 .max_time     = 0x196,
  75                 .ln_adc_level = 0x1cc7,
  76                 .output_mpeg2_in_188_bytes = 1,
  77         },
  78         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  79                 .max_time     = 0x196,
  80                 .ln_adc_level = 0x1cc7,
  81                 .output_mpeg2_in_188_bytes = 1,
  82         }
  83 };
  84 
  85 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  86 {
  87         struct dib0700_state *st = adap->dev->priv;
  88         if (adap->id == 0) {
  89                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  90                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  91                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  92                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  93 
  94                 if (force_lna_activation)
  95                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  96                 else
  97                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  98 
  99                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
 100                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
 101                         return -ENODEV;
 102                 }
 103         }
 104         st->mt2060_if1[adap->id] = 1220;
 105         return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 106                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 107 }
 108 
 109 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 110 {
 111         struct i2c_msg msg[2] = {
 112                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 113                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 114         };
 115         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 116         return 0;
 117 }
 118 
 119 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 120 {
 121         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 122         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
 123         s8 a;
 124         int if1=1220;
 125         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 126                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 127                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 128         }
 129         return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
 130                           &bristol_mt2060_config[adap->id], if1) == NULL ?
 131                           -ENODEV : 0;
 132 }
 133 
 134 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 135 
 136 /* MT226x */
 137 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 138         {
 139                 BAND_UHF,
 140 
 141                 /* 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,
 142                 * 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 */
 143                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 144             | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 145 
 146                 1130,
 147                 21,
 148 
 149                 0,
 150                 118,
 151 
 152                 0,
 153                 3530,
 154                 1,
 155                 0,
 156 
 157                 65535,
 158                 33770,
 159                 65535,
 160                 23592,
 161 
 162                 0,
 163                 62,
 164                 255,
 165                 64,
 166                 64,
 167                 132,
 168                 192,
 169                 80,
 170                 80,
 171 
 172                 17,
 173                 27,
 174                 23,
 175                 51,
 176 
 177                 1,
 178         }, {
 179                 BAND_VHF | BAND_LBAND,
 180 
 181                 /* 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,
 182                 * 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 */
 183                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 184             | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 185 
 186                 2372,
 187                 21,
 188 
 189                 0,
 190                 118,
 191 
 192                 0,
 193                 3530,
 194                 1,
 195                 0,
 196 
 197                 65535,
 198                 0,
 199                 65535,
 200                 23592,
 201 
 202                 0,
 203                 128,
 204                 128,
 205                 128,
 206                 0,
 207                 128,
 208                 253,
 209                 81,
 210                 0,
 211 
 212                 17,
 213                 27,
 214                 23,
 215                 51,
 216 
 217                 1,
 218         }
 219 };
 220 
 221 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 222         .internal = 60000,
 223         .sampling = 30000,
 224         .pll_prediv = 1,
 225         .pll_ratio = 8,
 226         .pll_range = 3,
 227         .pll_reset = 1,
 228         .pll_bypass = 0,
 229         .enable_refdiv = 0,
 230         .bypclk_div = 0,
 231         .IO_CLK_en_core = 1,
 232         .ADClkSrc = 1,
 233         .modulo = 2,
 234         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 235         .ifreq = 0,
 236         .timf = 20452225,
 237 };
 238 
 239 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 240         {       .output_mpeg2_in_188_bytes = 1,
 241                 .hostbus_diversity = 1,
 242                 .tuner_is_baseband = 1,
 243 
 244                 .agc_config_count = 2,
 245                 .agc = stk7700d_7000p_mt2266_agc_config,
 246                 .bw  = &stk7700d_mt2266_pll_config,
 247 
 248                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 249                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 250                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 251         },
 252         {       .output_mpeg2_in_188_bytes = 1,
 253                 .hostbus_diversity = 1,
 254                 .tuner_is_baseband = 1,
 255 
 256                 .agc_config_count = 2,
 257                 .agc = stk7700d_7000p_mt2266_agc_config,
 258                 .bw  = &stk7700d_mt2266_pll_config,
 259 
 260                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 261                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 262                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 263         }
 264 };
 265 
 266 static struct mt2266_config stk7700d_mt2266_config[2] = {
 267         {       .i2c_address = 0x60
 268         },
 269         {       .i2c_address = 0x60
 270         }
 271 };
 272 
 273 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 274 {
 275         struct dib0700_adapter_state *state = adap->priv;
 276 
 277         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 278                 return -ENODEV;
 279 
 280         if (adap->id == 0) {
 281                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 282                 msleep(10);
 283                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 284                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 285                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 286                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 287                 msleep(10);
 288                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 289                 msleep(10);
 290                 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 291                                              stk7700d_dib7000p_mt2266_config)
 292                     != 0) {
 293                         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
 294                         dvb_detach(state->dib7000p_ops.set_wbd_ref);
 295                         return -ENODEV;
 296                 }
 297         }
 298 
 299         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
 300                            0x80 + (adap->id << 1),
 301                            &stk7700d_dib7000p_mt2266_config[adap->id]);
 302 
 303         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 304 }
 305 
 306 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 307 {
 308         struct dib0700_adapter_state *state = adap->priv;
 309 
 310         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 311                 return -ENODEV;
 312 
 313         if (adap->id == 0) {
 314                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 315                 msleep(10);
 316                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 317                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 318                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 319                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 320                 msleep(10);
 321                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 322                 msleep(10);
 323                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 324                 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 325                                              stk7700d_dib7000p_mt2266_config)
 326                     != 0) {
 327                         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
 328                         dvb_detach(state->dib7000p_ops.set_wbd_ref);
 329                         return -ENODEV;
 330                 }
 331         }
 332 
 333         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
 334                            0x80 + (adap->id << 1),
 335                            &stk7700d_dib7000p_mt2266_config[adap->id]);
 336 
 337         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 338 }
 339 
 340 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 341 {
 342         struct i2c_adapter *tun_i2c;
 343         struct dib0700_adapter_state *state = adap->priv;
 344 
 345         tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 346                                             DIBX000_I2C_INTERFACE_TUNER, 1);
 347         return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
 348                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 349 }
 350 
 351 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 352 static struct dibx000_agc_config xc3028_agc_config = {
 353         .band_caps = BAND_VHF | BAND_UHF,
 354         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 355          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 356          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 357         .setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 358         .inv_gain = 712,
 359         .time_stabiliz = 21,
 360         .alpha_level = 0,
 361         .thlock = 118,
 362         .wbd_inv = 0,
 363         .wbd_ref = 2867,
 364         .wbd_sel = 0,
 365         .wbd_alpha = 2,
 366         .agc1_max = 0,
 367         .agc1_min = 0,
 368         .agc2_max = 39718,
 369         .agc2_min = 9930,
 370         .agc1_pt1 = 0,
 371         .agc1_pt2 = 0,
 372         .agc1_pt3 = 0,
 373         .agc1_slope1 = 0,
 374         .agc1_slope2 = 0,
 375         .agc2_pt1 = 0,
 376         .agc2_pt2 = 128,
 377         .agc2_slope1 = 29,
 378         .agc2_slope2 = 29,
 379         .alpha_mant = 17,
 380         .alpha_exp = 27,
 381         .beta_mant = 23,
 382         .beta_exp = 51,
 383         .perform_agc_softsplit = 1,
 384 };
 385 
 386 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 387 static struct dibx000_bandwidth_config xc3028_bw_config = {
 388         .internal = 60000,
 389         .sampling = 30000,
 390         .pll_prediv = 1,
 391         .pll_ratio = 8,
 392         .pll_range = 3,
 393         .pll_reset = 1,
 394         .pll_bypass = 0,
 395         .enable_refdiv = 0,
 396         .bypclk_div = 0,
 397         .IO_CLK_en_core = 1,
 398         .ADClkSrc = 1,
 399         .modulo = 0,
 400         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 401         .ifreq = (1 << 25) | 5816102,  /* ifreq = 5.200000 MHz */
 402         .timf = 20452225,
 403         .xtal_hz = 30000000,
 404 };
 405 
 406 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 407         .output_mpeg2_in_188_bytes = 1,
 408         .tuner_is_baseband = 1,
 409 
 410         .agc_config_count = 1,
 411         .agc = &xc3028_agc_config,
 412         .bw  = &xc3028_bw_config,
 413 
 414         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 415         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 416         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 417 };
 418 
 419 static int stk7700ph_xc3028_callback(void *ptr, int component,
 420                                      int command, int arg)
 421 {
 422         struct dvb_usb_adapter *adap = ptr;
 423         struct dib0700_adapter_state *state = adap->priv;
 424 
 425         switch (command) {
 426         case XC2028_TUNER_RESET:
 427                 /* Send the tuner in then out of reset */
 428                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
 429                 msleep(10);
 430                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 431                 break;
 432         case XC2028_RESET_CLK:
 433         case XC2028_I2C_FLUSH:
 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 = XC2028_DEFAULT_FIRMWARE,
 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.set_wbd_ref);
 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_proto 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_PROTO_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_PROTO_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_PROTO_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.set_wbd_ref);
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.set_wbd_ref);
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                         /* fall through */
1664         case BAND_VHF:
1665                         state->dib8000_ops.set_gpio(fe, 3, 0, 1);
1666                         break;
1667         case BAND_UHF:
1668                         state->dib8000_ops.set_gpio(fe, 3, 0, 0);
1669                         break;
1670         }
1671 
1672         ret = state->set_param_save(fe);
1673         if (ret < 0)
1674                 return ret;
1675 
1676         if (fe->dtv_property_cache.bandwidth_hz != 6000000) {
1677                 deb_info("only 6MHz bandwidth is supported\n");
1678                 return -EINVAL;
1679         }
1680 
1681         /* Update PLL if needed ratio */
1682         state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1683 
1684         /* Get optimize PLL ratio to remove spurious */
1685         pll_ratio = dib8090_compute_pll_parameters(fe);
1686         if (pll_ratio == 17)
1687                 timf = 21387946;
1688         else if (pll_ratio == 18)
1689                 timf = 20199727;
1690         else if (pll_ratio == 19)
1691                 timf = 19136583;
1692         else
1693                 timf = 18179756;
1694 
1695         /* Update ratio */
1696         state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
1697 
1698         state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, timf);
1699 
1700         if (band != BAND_CBAND) {
1701                 /* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */
1702                 target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2;
1703                 state->dib8000_ops.set_wbd_ref(fe, target);
1704         }
1705 
1706         if (band == BAND_CBAND) {
1707                 deb_info("tuning in CBAND - soft-AGC startup\n");
1708                 dib0090_set_tune_state(fe, CT_AGC_START);
1709 
1710                 do {
1711                         ret = dib0090_gain_control(fe);
1712                         msleep(ret);
1713                         tune_state = dib0090_get_tune_state(fe);
1714                         if (tune_state == CT_AGC_STEP_0)
1715                                 state->dib8000_ops.set_gpio(fe, 6, 0, 1);
1716                         else if (tune_state == CT_AGC_STEP_1) {
1717                                 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1718                                 if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */
1719                                         state->dib8000_ops.set_gpio(fe, 6, 0, 0);
1720                         }
1721                 } while (tune_state < CT_AGC_STOP);
1722 
1723                 deb_info("switching to PWM AGC\n");
1724                 dib0090_pwm_gain_reset(fe);
1725                 state->dib8000_ops.pwm_agc_reset(fe);
1726                 state->dib8000_ops.set_tune_state(fe, CT_DEMOD_START);
1727         } else {
1728                 /* for everything else than CBAND we are using standard AGC */
1729                 deb_info("not tuning in CBAND - standard AGC startup\n");
1730                 dib0090_pwm_gain_reset(fe);
1731         }
1732 
1733         return 0;
1734 }
1735 
1736 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1737 {
1738         struct dib0700_adapter_state *st = adap->priv;
1739         struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1740 
1741         if (adap->id == 0) {
1742                 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1743                         return -ENODEV;
1744         } else {
1745                 /* FIXME: check if it is fe_adap[1] */
1746                 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1747                         return -ENODEV;
1748         }
1749 
1750         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1751         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1752         return 0;
1753 }
1754 
1755 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1756 {
1757         struct dib0700_adapter_state *state = adap->priv;
1758 
1759         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1760                 return -ENODEV;
1761 
1762         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1763         msleep(10);
1764         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1765         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1766         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1767 
1768         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1769 
1770         dib0700_ctrl_clock(adap->dev, 72, 1);
1771 
1772         msleep(10);
1773         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1774         msleep(10);
1775         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1776 
1777         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1778 
1779         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1780 
1781         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1782 }
1783 
1784 static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap)
1785 {
1786         struct dib0700_adapter_state *state = adap->priv;
1787 
1788         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1789                 return -ENODEV;
1790 
1791         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0);
1792 
1793         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1794 
1795         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1796 }
1797 
1798 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1799 {
1800         struct dib0700_adapter_state *st = adap->priv;
1801         struct i2c_adapter *tun_i2c;
1802         struct dvb_frontend *fe_slave  = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
1803 
1804         if (fe_slave) {
1805                 tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1806                 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1807                         return -ENODEV;
1808                 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1809                 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1810         }
1811         tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1812         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1813                 return -ENODEV;
1814 
1815         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1816         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1817 
1818         return 0;
1819 }
1820 
1821 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1822 {
1823         struct dvb_frontend *fe_slave;
1824         struct dib0700_adapter_state *state = adap->priv;
1825 
1826         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1827                 return -ENODEV;
1828 
1829         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1830         msleep(20);
1831         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1832         msleep(1000);
1833         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1834         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1835         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1836 
1837         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1838 
1839         dib0700_ctrl_clock(adap->dev, 72, 1);
1840 
1841         msleep(20);
1842         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1843         msleep(20);
1844         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1845 
1846         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1847 
1848         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1849         if (adap->fe_adap[0].fe == NULL)
1850                 return -ENODEV;
1851 
1852         /* Needed to increment refcount */
1853         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1854                 return -ENODEV;
1855 
1856         fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1857         state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1858 
1859         return fe_slave == NULL ?  -ENODEV : 0;
1860 }
1861 
1862 /* TFE8096P */
1863 static struct dibx000_agc_config dib8096p_agc_config[2] = {
1864         {
1865                 .band_caps              = BAND_UHF,
1866                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1867                    P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1868                    P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1869                    P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1870                    P_agc_write=0 */
1871                 .setup                  = (0 << 15) | (0 << 14) | (5 << 11)
1872                         | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1873                         | (0 << 4) | (5 << 1) | (0 << 0),
1874 
1875                 .inv_gain               = 684,
1876                 .time_stabiliz  = 10,
1877 
1878                 .alpha_level    = 0,
1879                 .thlock                 = 118,
1880 
1881                 .wbd_inv                = 0,
1882                 .wbd_ref                = 1200,
1883                 .wbd_sel                = 3,
1884                 .wbd_alpha              = 5,
1885 
1886                 .agc1_max               = 65535,
1887                 .agc1_min               = 0,
1888 
1889                 .agc2_max               = 32767,
1890                 .agc2_min               = 0,
1891 
1892                 .agc1_pt1               = 0,
1893                 .agc1_pt2               = 0,
1894                 .agc1_pt3               = 105,
1895                 .agc1_slope1    = 0,
1896                 .agc1_slope2    = 156,
1897                 .agc2_pt1               = 105,
1898                 .agc2_pt2               = 255,
1899                 .agc2_slope1    = 54,
1900                 .agc2_slope2    = 0,
1901 
1902                 .alpha_mant             = 28,
1903                 .alpha_exp              = 26,
1904                 .beta_mant              = 31,
1905                 .beta_exp               = 51,
1906 
1907                 .perform_agc_softsplit = 0,
1908         } , {
1909                 .band_caps              = BAND_FM | BAND_VHF | BAND_CBAND,
1910                 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1911                    P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1912                    P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1913                    P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1914                    P_agc_write=0 */
1915                 .setup                  = (0 << 15) | (0 << 14) | (5 << 11)
1916                         | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1917                         | (0 << 4) | (5 << 1) | (0 << 0),
1918 
1919                 .inv_gain               = 732,
1920                 .time_stabiliz  = 10,
1921 
1922                 .alpha_level    = 0,
1923                 .thlock                 = 118,
1924 
1925                 .wbd_inv                = 0,
1926                 .wbd_ref                = 1200,
1927                 .wbd_sel                = 3,
1928                 .wbd_alpha              = 5,
1929 
1930                 .agc1_max               = 65535,
1931                 .agc1_min               = 0,
1932 
1933                 .agc2_max               = 32767,
1934                 .agc2_min               = 0,
1935 
1936                 .agc1_pt1               = 0,
1937                 .agc1_pt2               = 0,
1938                 .agc1_pt3               = 98,
1939                 .agc1_slope1    = 0,
1940                 .agc1_slope2    = 167,
1941                 .agc2_pt1               = 98,
1942                 .agc2_pt2               = 255,
1943                 .agc2_slope1    = 52,
1944                 .agc2_slope2    = 0,
1945 
1946                 .alpha_mant             = 28,
1947                 .alpha_exp              = 26,
1948                 .beta_mant              = 31,
1949                 .beta_exp               = 51,
1950 
1951                 .perform_agc_softsplit = 0,
1952         }
1953 };
1954 
1955 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1956         .internal = 108000,
1957         .sampling = 13500,
1958         .pll_prediv = 1,
1959         .pll_ratio = 9,
1960         .pll_range = 1,
1961         .pll_reset = 0,
1962         .pll_bypass = 0,
1963         .enable_refdiv = 0,
1964         .bypclk_div = 0,
1965         .IO_CLK_en_core = 0,
1966         .ADClkSrc = 0,
1967         .modulo = 2,
1968         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1969         .ifreq = (0 << 25) | 0,
1970         .timf = 20199729,
1971         .xtal_hz = 12000000,
1972 };
1973 
1974 static struct dib8000_config tfe8096p_dib8000_config = {
1975         .output_mpeg2_in_188_bytes      = 1,
1976         .hostbus_diversity                      = 1,
1977         .update_lna                                     = NULL,
1978 
1979         .agc_config_count                       = 2,
1980         .agc                                            = dib8096p_agc_config,
1981         .pll                                            = &dib8096p_clock_config_12_mhz,
1982 
1983         .gpio_dir                                       = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1984         .gpio_val                                       = DIB8000_GPIO_DEFAULT_VALUES,
1985         .gpio_pwm_pos                           = DIB8000_GPIO_DEFAULT_PWM_POS,
1986 
1987         .agc_control                            = NULL,
1988         .diversity_delay                        = 48,
1989         .output_mode                            = OUTMODE_MPEG2_FIFO,
1990         .enMpegOutput                           = 1,
1991 };
1992 
1993 static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1994         { 380, 81, 850, 64, 540, 4},
1995         { 860, 51, 866, 21, 375, 4},
1996         {1700, 0, 250, 0, 100, 6},
1997         {2600, 0, 250, 0, 100, 6},
1998         { 0xFFFF, 0, 0, 0, 0, 0},
1999 };
2000 
2001 static struct dib0090_config tfe8096p_dib0090_config = {
2002         .io.clock_khz                   = 12000,
2003         .io.pll_bypass                  = 0,
2004         .io.pll_range                   = 0,
2005         .io.pll_prediv                  = 3,
2006         .io.pll_loopdiv                 = 6,
2007         .io.adc_clock_ratio             = 0,
2008         .io.pll_int_loop_filt   = 0,
2009 
2010         .freq_offset_khz_uhf    = -143,
2011         .freq_offset_khz_vhf    = -143,
2012 
2013         .get_adc_power                  = dib8090_get_adc_power,
2014 
2015         .clkouttobamse                  = 1,
2016         .analog_output                  = 0,
2017 
2018         .wbd_vhf_offset                 = 0,
2019         .wbd_cband_offset               = 0,
2020         .use_pwm_agc                    = 1,
2021         .clkoutdrive                    = 0,
2022 
2023         .fref_clock_ratio               = 1,
2024 
2025         .ls_cfg_pad_drv                 = 0,
2026         .data_tx_drv                    = 0,
2027         .low_if                                 = NULL,
2028         .in_soc                                 = 1,
2029         .force_cband_input              = 0,
2030 };
2031 
2032 struct dibx090p_adc {
2033         u32 freq;                       /* RF freq MHz */
2034         u32 timf;                       /* New Timf */
2035         u32 pll_loopdiv;        /* New prediv */
2036         u32 pll_prediv;         /* New loopdiv */
2037 };
2038 
2039 struct dibx090p_best_adc {
2040         u32 timf;
2041         u32 pll_loopdiv;
2042         u32 pll_prediv;
2043 };
2044 
2045 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
2046 {
2047         u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2048         u16 xtal = 12000;
2049         u16 fcp_min = 1900;  /* PLL, Minimum Frequency of phase comparator (KHz) */
2050         u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */
2051         u32 fmem_max = 140000; /* 140MHz max SDRAM freq */
2052         u32 fdem_min = 66000;
2053         u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
2054         u32 harmonic_id = 0;
2055 
2056         adc->timf = 0;
2057         adc->pll_loopdiv = loopdiv;
2058         adc->pll_prediv = prediv;
2059 
2060         deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
2061 
2062         /* Find Min and Max prediv */
2063         while ((xtal / max_prediv) >= fcp_min)
2064                 max_prediv++;
2065 
2066         max_prediv--;
2067         min_prediv = max_prediv;
2068         while ((xtal / min_prediv) <= fcp_max) {
2069                 min_prediv--;
2070                 if (min_prediv == 1)
2071                         break;
2072         }
2073         deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2074 
2075         min_prediv = 1;
2076 
2077         for (prediv = min_prediv; prediv < max_prediv; prediv++) {
2078                 fcp = xtal / prediv;
2079                 if (fcp > fcp_min && fcp < fcp_max) {
2080                         for (loopdiv = 1; loopdiv < 64; loopdiv++) {
2081                                 fmem = ((xtal/prediv) * loopdiv);
2082                                 fdem = fmem / 2;
2083                                 fs   = fdem / 4;
2084 
2085                                 /* test min/max system restrictions */
2086                                 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
2087                                         spur = 0;
2088                                         /* test fs harmonics positions */
2089                                         for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs));  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
2090                                                 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)))) {
2091                                                         spur = 1;
2092                                                         break;
2093                                                 }
2094                                         }
2095 
2096                                         if (!spur) {
2097                                                 adc->pll_loopdiv = loopdiv;
2098                                                 adc->pll_prediv = prediv;
2099                                                 adc->timf = (4260880253U / fdem) * (1 << 8);
2100                                                 adc->timf += ((4260880253U % fdem) << 8) / fdem;
2101 
2102                                                 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);
2103                                                 break;
2104                                         }
2105                                 }
2106                         }
2107                 }
2108                 if (!spur)
2109                         break;
2110         }
2111 
2112         if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2113                 return -EINVAL;
2114         return 0;
2115 }
2116 
2117 static int dib8096p_agc_startup(struct dvb_frontend *fe)
2118 {
2119         struct dvb_usb_adapter *adap = fe->dvb->priv;
2120         struct dib0700_adapter_state *state = adap->priv;
2121         struct dibx000_bandwidth_config pll;
2122         struct dibx090p_best_adc adc;
2123         u16 target;
2124         int ret;
2125 
2126         ret = state->set_param_save(fe);
2127         if (ret < 0)
2128                 return ret;
2129         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2130 
2131         dib0090_pwm_gain_reset(fe);
2132         /* dib0090_get_wbd_target is returning any possible
2133            temperature compensated wbd-target */
2134         target = (dib0090_get_wbd_target(fe) * 8  + 1) / 2;
2135         state->dib8000_ops.set_wbd_ref(fe, target);
2136 
2137         if (dib8096p_get_best_sampling(fe, &adc) == 0) {
2138                 pll.pll_ratio  = adc.pll_loopdiv;
2139                 pll.pll_prediv = adc.pll_prediv;
2140 
2141                 dib0700_set_i2c_speed(adap->dev, 200);
2142                 state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
2143                 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2144                 dib0700_set_i2c_speed(adap->dev, 1000);
2145         }
2146         return 0;
2147 }
2148 
2149 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2150 {
2151         struct dib0700_state *st = adap->dev->priv;
2152         u32 fw_version;
2153         struct dib0700_adapter_state *state = adap->priv;
2154 
2155         if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
2156                 return -ENODEV;
2157 
2158         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2159         if (fw_version >= 0x10200)
2160                 st->fw_use_new_i2c_api = 1;
2161 
2162         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2163         msleep(20);
2164         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2165         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2166         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2167 
2168         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2169 
2170         dib0700_ctrl_clock(adap->dev, 72, 1);
2171 
2172         msleep(20);
2173         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2174         msleep(20);
2175         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2176 
2177         state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2178 
2179         adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
2180                                              0x80, &tfe8096p_dib8000_config);
2181 
2182         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2183 }
2184 
2185 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2186 {
2187         struct dib0700_adapter_state *st = adap->priv;
2188         struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
2189 
2190         tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
2191         tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
2192         tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
2193 
2194         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2195                                 &tfe8096p_dib0090_config) == NULL)
2196                 return -ENODEV;
2197 
2198         st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2199 
2200         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2201         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2202         return 0;
2203 }
2204 
2205 /* STK9090M */
2206 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2207 {
2208         return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2209 }
2210 
2211 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2212 {
2213         return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2214 }
2215 
2216 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2217 {
2218         return dib9000_set_gpio(fe, 5, 0, !onoff);
2219 }
2220 
2221 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2222 {
2223         return dib9000_set_gpio(fe, 0, 0, onoff);
2224 }
2225 
2226 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2227 {
2228         u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2229         u8 rb[2];
2230         struct i2c_msg msg[2] = {
2231                 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2232                 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2233         };
2234         u8 index_data;
2235 
2236         dibx000_i2c_set_speed(i2c, 250);
2237 
2238         if (i2c_transfer(i2c, msg, 2) != 2)
2239                 return -EIO;
2240 
2241         switch (rb[0] << 8 | rb[1]) {
2242         case 0:
2243                         deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2244                         return -EIO;
2245         case 1:
2246                         deb_info("Found DiB0170 rev2");
2247                         break;
2248         case 2:
2249                         deb_info("Found DiB0190 rev2");
2250                         break;
2251         default:
2252                         deb_info("DiB01x0 not found");
2253                         return -EIO;
2254         }
2255 
2256         for (index_data = 0; index_data < len; index_data += 2) {
2257                 wb[2] = (data[index_data + 1] >> 8) & 0xff;
2258                 wb[3] = (data[index_data + 1]) & 0xff;
2259 
2260                 if (data[index_data] == 0) {
2261                         wb[0] = (data[index_data] >> 8) & 0xff;
2262                         wb[1] = (data[index_data]) & 0xff;
2263                         msg[0].len = 2;
2264                         if (i2c_transfer(i2c, msg, 2) != 2)
2265                                 return -EIO;
2266                         wb[2] |= rb[0];
2267                         wb[3] |= rb[1] & ~(3 << 4);
2268                 }
2269 
2270                 wb[0] = (data[index_data] >> 8)&0xff;
2271                 wb[1] = (data[index_data])&0xff;
2272                 msg[0].len = 4;
2273                 if (i2c_transfer(i2c, &msg[0], 1) != 1)
2274                         return -EIO;
2275         }
2276         return 0;
2277 }
2278 
2279 static struct dib9000_config stk9090m_config = {
2280         .output_mpeg2_in_188_bytes = 1,
2281         .output_mode = OUTMODE_MPEG2_FIFO,
2282         .vcxo_timer = 279620,
2283         .timing_frequency = 20452225,
2284         .demod_clock_khz = 60000,
2285         .xtal_clock_khz = 30000,
2286         .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2287         .subband = {
2288                 2,
2289                 {
2290                         { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
2291                         { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
2292                         { 0 },
2293                 },
2294         },
2295         .gpio_function = {
2296                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2297                 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2298         },
2299 };
2300 
2301 static struct dib9000_config nim9090md_config[2] = {
2302         {
2303                 .output_mpeg2_in_188_bytes = 1,
2304                 .output_mode = OUTMODE_MPEG2_FIFO,
2305                 .vcxo_timer = 279620,
2306                 .timing_frequency = 20452225,
2307                 .demod_clock_khz = 60000,
2308                 .xtal_clock_khz = 30000,
2309                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2310         }, {
2311                 .output_mpeg2_in_188_bytes = 1,
2312                 .output_mode = OUTMODE_DIVERSITY,
2313                 .vcxo_timer = 279620,
2314                 .timing_frequency = 20452225,
2315                 .demod_clock_khz = 60000,
2316                 .xtal_clock_khz = 30000,
2317                 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2318                 .subband = {
2319                         2,
2320                         {
2321                                 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2322                                 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2323                                 { 0 },
2324                         },
2325                 },
2326                 .gpio_function = {
2327                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2328                         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2329                 },
2330         }
2331 };
2332 
2333 static struct dib0090_config dib9090_dib0090_config = {
2334         .io.pll_bypass = 0,
2335         .io.pll_range = 1,
2336         .io.pll_prediv = 1,
2337         .io.pll_loopdiv = 8,
2338         .io.adc_clock_ratio = 8,
2339         .io.pll_int_loop_filt = 0,
2340         .io.clock_khz = 30000,
2341         .reset = dib90x0_tuner_reset,
2342         .sleep = dib90x0_tuner_sleep,
2343         .clkouttobamse = 0,
2344         .analog_output = 0,
2345         .use_pwm_agc = 0,
2346         .clkoutdrive = 0,
2347         .freq_offset_khz_uhf = 0,
2348         .freq_offset_khz_vhf = 0,
2349 };
2350 
2351 static struct dib0090_config nim9090md_dib0090_config[2] = {
2352         {
2353                 .io.pll_bypass = 0,
2354                 .io.pll_range = 1,
2355                 .io.pll_prediv = 1,
2356                 .io.pll_loopdiv = 8,
2357                 .io.adc_clock_ratio = 8,
2358                 .io.pll_int_loop_filt = 0,
2359                 .io.clock_khz = 30000,
2360                 .reset = dib90x0_tuner_reset,
2361                 .sleep = dib90x0_tuner_sleep,
2362                 .clkouttobamse = 1,
2363                 .analog_output = 0,
2364                 .use_pwm_agc = 0,
2365                 .clkoutdrive = 0,
2366                 .freq_offset_khz_uhf = 0,
2367                 .freq_offset_khz_vhf = 0,
2368         }, {
2369                 .io.pll_bypass = 0,
2370                 .io.pll_range = 1,
2371                 .io.pll_prediv = 1,
2372                 .io.pll_loopdiv = 8,
2373                 .io.adc_clock_ratio = 8,
2374                 .io.pll_int_loop_filt = 0,
2375                 .io.clock_khz = 30000,
2376                 .reset = dib90x0_tuner_reset,
2377                 .sleep = dib90x0_tuner_sleep,
2378                 .clkouttobamse = 0,
2379                 .analog_output = 0,
2380                 .use_pwm_agc = 0,
2381                 .clkoutdrive = 0,
2382                 .freq_offset_khz_uhf = 0,
2383                 .freq_offset_khz_vhf = 0,
2384         }
2385 };
2386 
2387 
2388 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2389 {
2390         struct dib0700_adapter_state *state = adap->priv;
2391         struct dib0700_state *st = adap->dev->priv;
2392         u32 fw_version;
2393 
2394         /* Make use of the new i2c functions from FW 1.20 */
2395         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2396         if (fw_version >= 0x10200)
2397                 st->fw_use_new_i2c_api = 1;
2398         dib0700_set_i2c_speed(adap->dev, 340);
2399 
2400         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2401         msleep(20);
2402         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2403         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2404         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2405         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2406 
2407         dib0700_ctrl_clock(adap->dev, 72, 1);
2408 
2409         msleep(20);
2410         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2411         msleep(20);
2412         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2413 
2414         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2415 
2416         if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2417                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2418                 return -ENODEV;
2419         } else {
2420                 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2421         }
2422         stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2423         stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2424 
2425         adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2426 
2427         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2428 }
2429 
2430 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2431 {
2432         struct dib0700_adapter_state *state = adap->priv;
2433         struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2434         u16 data_dib190[10] = {
2435                 1, 0x1374,
2436                 2, 0x01a2,
2437                 7, 0x0020,
2438                 0, 0x00ef,
2439                 8, 0x0486,
2440         };
2441 
2442         if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2443                 return -ENODEV;
2444         if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2445                 return -ENODEV;
2446         i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2447         if (!i2c)
2448                 return -ENODEV;
2449         if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2450                 return -ENODEV;
2451         dib0700_set_i2c_speed(adap->dev, 1500);
2452         if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2453                 return -ENODEV;
2454         release_firmware(state->frontend_firmware);
2455         return 0;
2456 }
2457 
2458 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2459 {
2460         struct dib0700_adapter_state *state = adap->priv;
2461         struct dib0700_state *st = adap->dev->priv;
2462         struct i2c_adapter *i2c;
2463         struct dvb_frontend *fe_slave;
2464         u32 fw_version;
2465 
2466         /* Make use of the new i2c functions from FW 1.20 */
2467         dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2468         if (fw_version >= 0x10200)
2469                 st->fw_use_new_i2c_api = 1;
2470         dib0700_set_i2c_speed(adap->dev, 340);
2471 
2472         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2473         msleep(20);
2474         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2475         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2476         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2477         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2478 
2479         dib0700_ctrl_clock(adap->dev, 72, 1);
2480 
2481         msleep(20);
2482         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2483         msleep(20);
2484         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2485 
2486         if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2487                 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2488                 return -EIO;
2489         } else {
2490                 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2491         }
2492         nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2493         nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2494         nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2495         nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2496 
2497         dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2498         adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2499 
2500         if (adap->fe_adap[0].fe == NULL)
2501                 return -ENODEV;
2502 
2503         i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2504         dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2505 
2506         fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2507         dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2508 
2509         return fe_slave == NULL ?  -ENODEV : 0;
2510 }
2511 
2512 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2513 {
2514         struct dib0700_adapter_state *state = adap->priv;
2515         struct i2c_adapter *i2c;
2516         struct dvb_frontend *fe_slave;
2517         u16 data_dib190[10] = {
2518                 1, 0x5374,
2519                 2, 0x01ae,
2520                 7, 0x0020,
2521                 0, 0x00ef,
2522                 8, 0x0406,
2523         };
2524         if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2525                 return -ENODEV;
2526         i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2527         if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2528                 return -ENODEV;
2529         i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2530         if (!i2c)
2531                 return -ENODEV;
2532         if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2533                 return -ENODEV;
2534 
2535         dib0700_set_i2c_speed(adap->dev, 1500);
2536         if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2537                 return -ENODEV;
2538 
2539         fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2540         if (fe_slave != NULL) {
2541                 i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2542                 dib9000_set_i2c_adapter(fe_slave, i2c);
2543 
2544                 i2c = dib9000_get_tuner_interface(fe_slave);
2545                 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2546                         return -ENODEV;
2547                 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2548                 dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2549                 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2550                         return -ENODEV;
2551         }
2552         release_firmware(state->frontend_firmware);
2553 
2554         return 0;
2555 }
2556 
2557 /* NIM7090 */
2558 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dibx090p_best_adc *adc)
2559 {
2560         u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2561 
2562         u16 xtal = 12000;
2563         u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
2564         u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2565         u32 fdem_max = 76000;
2566         u32 fdem_min = 69500;
2567         u32 fcp = 0, fs = 0, fdem = 0;
2568         u32 harmonic_id = 0;
2569 
2570         adc->pll_loopdiv = loopdiv;
2571         adc->pll_prediv = prediv;
2572         adc->timf = 0;
2573 
2574         deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2575 
2576         /* Find Min and Max prediv */
2577         while ((xtal/max_prediv) >= fcp_min)
2578                 max_prediv++;
2579 
2580         max_prediv--;
2581         min_prediv = max_prediv;
2582         while ((xtal/min_prediv) <= fcp_max) {
2583                 min_prediv--;
2584                 if (min_prediv == 1)
2585                         break;
2586         }
2587         deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2588 
2589         min_prediv = 2;
2590 
2591         for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2592                 fcp = xtal / prediv;
2593                 if (fcp > fcp_min && fcp < fcp_max) {
2594                         for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2595                                 fdem = ((xtal/prediv) * loopdiv);
2596                                 fs   = fdem / 4;
2597                                 /* test min/max system restrictions */
2598 
2599                                 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2600                                         spur = 0;
2601                                         /* test fs harmonics positions */
2602                                         for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2603                                                 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)))) {
2604                                                         spur = 1;
2605                                                         break;
2606                                                 }
2607                                         }
2608 
2609                                         if (!spur) {
2610                                                 adc->pll_loopdiv = loopdiv;
2611                                                 adc->pll_prediv = prediv;
2612                                                 adc->timf = 2396745143UL/fdem*(1 << 9);
2613                                                 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2614                                                 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2615                                                 break;
2616                                         }
2617                                 }
2618                         }
2619                 }
2620                 if (!spur)
2621                         break;
2622         }
2623 
2624 
2625         if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2626                 return -EINVAL;
2627         else
2628                 return 0;
2629 }
2630 
2631 static int dib7090_agc_startup(struct dvb_frontend *fe)
2632 {
2633         struct dvb_usb_adapter *adap = fe->dvb->priv;
2634         struct dib0700_adapter_state *state = adap->priv;
2635         struct dibx000_bandwidth_config pll;
2636         u16 target;
2637         struct dibx090p_best_adc adc;
2638         int ret;
2639 
2640         ret = state->set_param_save(fe);
2641         if (ret < 0)
2642                 return ret;
2643 
2644         memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2645         dib0090_pwm_gain_reset(fe);
2646         target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2647         state->dib7000p_ops.set_wbd_ref(fe, target);
2648 
2649         if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2650                 pll.pll_ratio  = adc.pll_loopdiv;
2651                 pll.pll_prediv = adc.pll_prediv;
2652 
2653                 state->dib7000p_ops.update_pll(fe, &pll);
2654                 state->dib7000p_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2655         }
2656         return 0;
2657 }
2658 
2659 static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2660 {
2661         deb_info("AGC restart callback: %d", restart);
2662         if (restart == 0) /* before AGC startup */
2663                 dib0090_set_dc_servo(fe, 1);
2664         return 0;
2665 }
2666 
2667 static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
2668 {
2669         struct dvb_usb_adapter *adap = fe->dvb->priv;
2670         struct dib0700_adapter_state *state = adap->priv;
2671 
2672         deb_info("update LNA: agc global=%i", agc_global);
2673 
2674         if (agc_global < 25000) {
2675                 state->dib7000p_ops.set_gpio(fe, 8, 0, 0);
2676                 state->dib7000p_ops.set_agc1_min(fe, 0);
2677         } else {
2678                 state->dib7000p_ops.set_gpio(fe, 8, 0, 1);
2679                 state->dib7000p_ops.set_agc1_min(fe, 32768);
2680         }
2681 
2682         return 0;
2683 }
2684 
2685 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2686         { 380,   81, 850, 64, 540,  4},
2687         { 860,   51, 866, 21,  375, 4},
2688         {1700,    0, 250, 0,   100, 6},
2689         {2600,    0, 250, 0,   100, 6},
2690         { 0xFFFF, 0,   0, 0,   0,   0},
2691 };
2692 
2693 static struct dibx000_agc_config dib7090_agc_config[2] = {
2694         {
2695                 .band_caps      = BAND_UHF,
2696                 /* 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,
2697                 * 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 */
2698                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2699 
2700                 .inv_gain       = 687,
2701                 .time_stabiliz  = 10,
2702 
2703                 .alpha_level    = 0,
2704                 .thlock         = 118,
2705 
2706                 .wbd_inv        = 0,
2707                 .wbd_ref        = 1200,
2708                 .wbd_sel        = 3,
2709                 .wbd_alpha      = 5,
2710 
2711                 .agc1_max       = 65535,
2712                 .agc1_min       = 32768,
2713 
2714                 .agc2_max       = 65535,
2715                 .agc2_min       = 0,
2716 
2717                 .agc1_pt1       = 0,
2718                 .agc1_pt2       = 32,
2719                 .agc1_pt3       = 114,
2720                 .agc1_slope1    = 143,
2721                 .agc1_slope2    = 144,
2722                 .agc2_pt1       = 114,
2723                 .agc2_pt2       = 227,
2724                 .agc2_slope1    = 116,
2725                 .agc2_slope2    = 117,
2726 
2727                 .alpha_mant     = 18,
2728                 .alpha_exp      = 0,
2729                 .beta_mant      = 20,
2730                 .beta_exp       = 59,
2731 
2732                 .perform_agc_softsplit = 0,
2733         } , {
2734                 .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
2735                 /* 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,
2736                 * 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 */
2737                 .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2738 
2739                 .inv_gain       = 732,
2740                 .time_stabiliz  = 10,
2741 
2742                 .alpha_level    = 0,
2743                 .thlock         = 118,
2744 
2745                 .wbd_inv        = 0,
2746                 .wbd_ref        = 1200,
2747                 .wbd_sel        = 3,
2748                 .wbd_alpha      = 5,
2749 
2750                 .agc1_max       = 65535,
2751                 .agc1_min       = 0,
2752 
2753                 .agc2_max       = 65535,
2754                 .agc2_min       = 0,
2755 
2756                 .agc1_pt1       = 0,
2757                 .agc1_pt2       = 0,
2758                 .agc1_pt3       = 98,
2759                 .agc1_slope1    = 0,
2760                 .agc1_slope2    = 167,
2761                 .agc2_pt1       = 98,
2762                 .agc2_pt2       = 255,
2763                 .agc2_slope1    = 104,
2764                 .agc2_slope2    = 0,
2765 
2766                 .alpha_mant     = 18,
2767                 .alpha_exp      = 0,
2768                 .beta_mant      = 20,
2769                 .beta_exp       = 59,
2770 
2771                 .perform_agc_softsplit = 0,
2772         }
2773 };
2774 
2775 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2776         .internal = 60000,
2777         .sampling = 15000,
2778         .pll_prediv = 1,
2779         .pll_ratio = 5,
2780         .pll_range = 0,
2781         .pll_reset = 0,
2782         .pll_bypass = 0,
2783         .enable_refdiv = 0,
2784         .bypclk_div = 0,
2785         .IO_CLK_en_core = 1,
2786         .ADClkSrc = 1,
2787         .modulo = 2,
2788         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
2789         .ifreq = (0 << 25) | 0,
2790         .timf = 20452225,
2791         .xtal_hz = 15000000,
2792 };
2793 
2794 static struct dib7000p_config nim7090_dib7000p_config = {
2795         .output_mpeg2_in_188_bytes  = 1,
2796         .hostbus_diversity                      = 1,
2797         .tuner_is_baseband                      = 1,
2798         .update_lna                                     = tfe7790p_update_lna, /* GPIO used is the same as TFE7790 */
2799 
2800         .agc_config_count                       = 2,
2801         .agc                                            = dib7090_agc_config,
2802 
2803         .bw                                                     = &dib7090_clock_config_12_mhz,
2804 
2805         .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2806         .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2807         .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2808 
2809         .pwm_freq_div                           = 0,
2810 
2811         .agc_control                            = dib7090_agc_restart,
2812 
2813         .spur_protect                           = 0,
2814         .disable_sample_and_hold        = 0,
2815         .enable_current_mirror          = 0,
2816         .diversity_delay                        = 0,
2817 
2818         .output_mode                            = OUTMODE_MPEG2_FIFO,
2819         .enMpegOutput                           = 1,
2820 };
2821 
2822 static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
2823 {
2824         struct dvb_usb_adapter *adap = fe->dvb->priv;
2825         struct dib0700_adapter_state *state = adap->priv;
2826 
2827         deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
2828         if (agc_global < 25000) {
2829                 state->dib7000p_ops.set_gpio(fe, 5, 0, 0);
2830                 state->dib7000p_ops.set_agc1_min(fe, 0);
2831         } else {
2832                 state->dib7000p_ops.set_gpio(fe, 5, 0, 1);
2833                 state->dib7000p_ops.set_agc1_min(fe, 32768);
2834         }
2835 
2836         return 0;
2837 }
2838 
2839 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2840         {
2841                 .output_mpeg2_in_188_bytes  = 1,
2842                 .hostbus_diversity                      = 1,
2843                 .tuner_is_baseband                      = 1,
2844                 .update_lna                                     = tfe7090p_pvr_update_lna,
2845 
2846                 .agc_config_count                       = 2,
2847                 .agc                                            = dib7090_agc_config,
2848 
2849                 .bw                                                     = &dib7090_clock_config_12_mhz,
2850 
2851                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2852                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2853                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2854 
2855                 .pwm_freq_div                           = 0,
2856 
2857                 .agc_control                            = dib7090_agc_restart,
2858 
2859                 .spur_protect                           = 0,
2860                 .disable_sample_and_hold        = 0,
2861                 .enable_current_mirror          = 0,
2862                 .diversity_delay                        = 0,
2863 
2864                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2865                 .default_i2c_addr                       = 0x90,
2866                 .enMpegOutput                           = 1,
2867         }, {
2868                 .output_mpeg2_in_188_bytes  = 1,
2869                 .hostbus_diversity                      = 1,
2870                 .tuner_is_baseband                      = 1,
2871                 .update_lna                                     = tfe7090p_pvr_update_lna,
2872 
2873                 .agc_config_count                       = 2,
2874                 .agc                                            = dib7090_agc_config,
2875 
2876                 .bw                                                     = &dib7090_clock_config_12_mhz,
2877 
2878                 .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2879                 .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2880                 .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2881 
2882                 .pwm_freq_div                           = 0,
2883 
2884                 .agc_control                            = dib7090_agc_restart,
2885 
2886                 .spur_protect                           = 0,
2887                 .disable_sample_and_hold        = 0,
2888                 .enable_current_mirror          = 0,
2889                 .diversity_delay                        = 0,
2890 
2891                 .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2892                 .default_i2c_addr                       = 0x92,
2893                 .enMpegOutput                           = 0,
2894         }
2895 };
2896 
2897 static struct dib0090_config nim7090_dib0090_config = {
2898         .io.clock_khz = 12000,
2899         .io.pll_bypass = 0,
2900         .io.pll_range = 0,
2901         .io.pll_prediv = 3,
2902         .io.pll_loopdiv = 6,
2903         .io.adc_clock_ratio = 0,
2904         .io.pll_int_loop_filt = 0,
2905 
2906         .freq_offset_khz_uhf = 0,
2907         .freq_offset_khz_vhf = 0,
2908 
2909         .clkouttobamse = 1,
2910         .analog_output = 0,
2911 
2912         .wbd_vhf_offset = 0,
2913         .wbd_cband_offset = 0,
2914         .use_pwm_agc = 1,
2915         .clkoutdrive = 0,
2916 
2917         .fref_clock_ratio = 0,
2918 
2919         .wbd = dib7090_wbd_table,
2920 
2921         .ls_cfg_pad_drv = 0,
2922         .data_tx_drv = 0,
2923         .low_if = NULL,
2924         .in_soc = 1,
2925 };
2926 
2927 static struct dib7000p_config tfe7790p_dib7000p_config = {
2928         .output_mpeg2_in_188_bytes  = 1,
2929         .hostbus_diversity                      = 1,
2930         .tuner_is_baseband                      = 1,
2931         .update_lna                                     = tfe7790p_update_lna,
2932 
2933         .agc_config_count                       = 2,
2934         .agc                                            = dib7090_agc_config,
2935 
2936         .bw                                                     = &dib7090_clock_config_12_mhz,
2937 
2938         .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2939         .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
2940         .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
2941 
2942         .pwm_freq_div                           = 0,
2943 
2944         .agc_control                            = dib7090_agc_restart,
2945 
2946         .spur_protect                           = 0,
2947         .disable_sample_and_hold        = 0,
2948         .enable_current_mirror          = 0,
2949         .diversity_delay                        = 0,
2950 
2951         .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
2952         .enMpegOutput                           = 1,
2953 };
2954 
2955 static struct dib0090_config tfe7790p_dib0090_config = {
2956         .io.clock_khz = 12000,
2957         .io.pll_bypass = 0,
2958         .io.pll_range = 0,
2959         .io.pll_prediv = 3,
2960         .io.pll_loopdiv = 6,
2961         .io.adc_clock_ratio = 0,
2962         .io.pll_int_loop_filt = 0,
2963 
2964         .freq_offset_khz_uhf = 0,
2965         .freq_offset_khz_vhf = 0,
2966 
2967         .clkouttobamse = 1,
2968         .analog_output = 0,
2969 
2970         .wbd_vhf_offset = 0,
2971         .wbd_cband_offset = 0,
2972         .use_pwm_agc = 1,
2973         .clkoutdrive = 0,
2974 
2975         .fref_clock_ratio = 0,
2976 
2977         .wbd = dib7090_wbd_table,
2978 
2979         .ls_cfg_pad_drv = 0,
2980         .data_tx_drv = 0,
2981         .low_if = NULL,
2982         .in_soc = 1,
2983         .force_cband_input = 0,
2984         .is_dib7090e = 0,
2985         .force_crystal_mode = 1,
2986 };
2987 
2988 static struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2989         {
2990                 .io.clock_khz = 12000,
2991                 .io.pll_bypass = 0,
2992                 .io.pll_range = 0,
2993                 .io.pll_prediv = 3,
2994                 .io.pll_loopdiv = 6,
2995                 .io.adc_clock_ratio = 0,
2996                 .io.pll_int_loop_filt = 0,
2997 
2998                 .freq_offset_khz_uhf = 50,
2999                 .freq_offset_khz_vhf = 70,
3000 
3001                 .clkouttobamse = 1,
3002                 .analog_output = 0,
3003 
3004                 .wbd_vhf_offset = 0,
3005                 .wbd_cband_offset = 0,
3006                 .use_pwm_agc = 1,
3007                 .clkoutdrive = 0,
3008 
3009                 .fref_clock_ratio = 0,
3010 
3011                 .wbd = dib7090_wbd_table,
3012 
3013                 .ls_cfg_pad_drv = 0,
3014                 .data_tx_drv = 0,
3015                 .low_if = NULL,
3016                 .in_soc = 1,
3017         }, {
3018                 .io.clock_khz = 12000,
3019                 .io.pll_bypass = 0,
3020                 .io.pll_range = 0,
3021                 .io.pll_prediv = 3,
3022                 .io.pll_loopdiv = 6,
3023                 .io.adc_clock_ratio = 0,
3024                 .io.pll_int_loop_filt = 0,
3025 
3026                 .freq_offset_khz_uhf = -50,
3027                 .freq_offset_khz_vhf = -70,
3028 
3029                 .clkouttobamse = 1,
3030                 .analog_output = 0,
3031 
3032                 .wbd_vhf_offset = 0,
3033                 .wbd_cband_offset = 0,
3034                 .use_pwm_agc = 1,
3035                 .clkoutdrive = 0,
3036 
3037                 .fref_clock_ratio = 0,
3038 
3039                 .wbd = dib7090_wbd_table,
3040 
3041                 .ls_cfg_pad_drv = 0,
3042                 .data_tx_drv = 0,
3043                 .low_if = NULL,
3044                 .in_soc = 1,
3045         }
3046 };
3047 
3048 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
3049 {
3050         struct dib0700_adapter_state *state = adap->priv;
3051 
3052         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3053                 return -ENODEV;
3054 
3055         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3056         msleep(20);
3057         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3058         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3059         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3060         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3061 
3062         msleep(20);
3063         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3064         msleep(20);
3065         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3066 
3067         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
3068                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3069                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3070                 return -ENODEV;
3071         }
3072         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
3073 
3074         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3075 }
3076 
3077 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
3078 {
3079         struct dib0700_adapter_state *st = adap->priv;
3080         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3081 
3082         nim7090_dib0090_config.reset = st->dib7000p_ops.tuner_sleep,
3083         nim7090_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep,
3084         nim7090_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3085 
3086         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
3087                 return -ENODEV;
3088 
3089         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3090 
3091         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3092         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3093         return 0;
3094 }
3095 
3096 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
3097 {
3098         struct dib0700_state *st = adap->dev->priv;
3099         struct dib0700_adapter_state *state = adap->priv;
3100 
3101         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3102                 return -ENODEV;
3103 
3104         /* The TFE7090 requires the dib0700 to not be in master mode */
3105         st->disable_streaming_master_mode = 1;
3106 
3107         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3108         msleep(20);
3109         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3110         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3111         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3112         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3113 
3114         msleep(20);
3115         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3116         msleep(20);
3117         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3118 
3119         /* initialize IC 0 */
3120         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
3121                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3122                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3123                 return -ENODEV;
3124         }
3125 
3126         dib0700_set_i2c_speed(adap->dev, 340);
3127         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
3128         if (adap->fe_adap[0].fe == NULL)
3129                 return -ENODEV;
3130 
3131         state->dib7000p_ops.slave_reset(adap->fe_adap[0].fe);
3132 
3133         return 0;
3134 }
3135 
3136 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
3137 {
3138         struct i2c_adapter *i2c;
3139         struct dib0700_adapter_state *state = adap->priv;
3140 
3141         if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
3142                 err("the master dib7090 has to be initialized first");
3143                 return -ENODEV; /* the master device has not been initialized */
3144         }
3145 
3146         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3147                 return -ENODEV;
3148 
3149         i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
3150         if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
3151                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3152                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3153                 return -ENODEV;
3154         }
3155 
3156         adap->fe_adap[0].fe = state->dib7000p_ops.init(i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
3157         dib0700_set_i2c_speed(adap->dev, 200);
3158 
3159         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3160 }
3161 
3162 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
3163 {
3164         struct dib0700_adapter_state *st = adap->priv;
3165         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3166 
3167         tfe7090pvr_dib0090_config[0].reset = st->dib7000p_ops.tuner_sleep;
3168         tfe7090pvr_dib0090_config[0].sleep = st->dib7000p_ops.tuner_sleep;
3169         tfe7090pvr_dib0090_config[0].get_adc_power = st->dib7000p_ops.get_adc_power;
3170 
3171         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
3172                 return -ENODEV;
3173 
3174         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3175 
3176         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3177         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3178         return 0;
3179 }
3180 
3181 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
3182 {
3183         struct dib0700_adapter_state *st = adap->priv;
3184         struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3185 
3186         tfe7090pvr_dib0090_config[1].reset = st->dib7000p_ops.tuner_sleep;
3187         tfe7090pvr_dib0090_config[1].sleep = st->dib7000p_ops.tuner_sleep;
3188         tfe7090pvr_dib0090_config[1].get_adc_power = st->dib7000p_ops.get_adc_power;
3189 
3190         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
3191                 return -ENODEV;
3192 
3193         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3194 
3195         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3196         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3197         return 0;
3198 }
3199 
3200 static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
3201 {
3202         struct dib0700_state *st = adap->dev->priv;
3203         struct dib0700_adapter_state *state = adap->priv;
3204 
3205         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3206                 return -ENODEV;
3207 
3208         /* The TFE7790P requires the dib0700 to not be in master mode */
3209         st->disable_streaming_master_mode = 1;
3210 
3211         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3212         msleep(20);
3213         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3214         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3215         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3216         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3217         msleep(20);
3218         dib0700_ctrl_clock(adap->dev, 72, 1);
3219         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3220         msleep(20);
3221         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3222 
3223         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap,
3224                                 1, 0x10, &tfe7790p_dib7000p_config) != 0) {
3225                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3226                                 __func__);
3227                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3228                 return -ENODEV;
3229         }
3230         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
3231                         0x80, &tfe7790p_dib7000p_config);
3232 
3233         return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3234 }
3235 
3236 static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
3237 {
3238         struct dib0700_adapter_state *st = adap->priv;
3239         struct i2c_adapter *tun_i2c =
3240                 st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3241 
3242 
3243         tfe7790p_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3244         tfe7790p_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3245         tfe7790p_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3246 
3247         if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3248                                 &tfe7790p_dib0090_config) == NULL)
3249                 return -ENODEV;
3250 
3251         st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3252 
3253         st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3254         adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3255         return 0;
3256 }
3257 
3258 /* STK7070PD */
3259 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3260         {
3261                 .output_mpeg2_in_188_bytes = 1,
3262 
3263                 .agc_config_count = 1,
3264                 .agc = &dib7070_agc_config,
3265                 .bw  = &dib7070_bw_config_12_mhz,
3266                 .tuner_is_baseband = 1,
3267                 .spur_protect = 1,
3268 
3269                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3270                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3271                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3272 
3273                 .hostbus_diversity = 1,
3274         }, {
3275                 .output_mpeg2_in_188_bytes = 1,
3276 
3277                 .agc_config_count = 1,
3278                 .agc = &dib7070_agc_config,
3279                 .bw  = &dib7070_bw_config_12_mhz,
3280                 .tuner_is_baseband = 1,
3281                 .spur_protect = 1,
3282 
3283                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3284                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3285                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3286 
3287                 .hostbus_diversity = 1,
3288         }
3289 };
3290 
3291 static void stk7070pd_init(struct dvb_usb_device *dev)
3292 {
3293         dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3294         msleep(10);
3295         dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3296         dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3297         dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3298         dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3299 
3300         dib0700_ctrl_clock(dev, 72, 1);
3301 
3302         msleep(10);
3303         dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3304 }
3305 
3306 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3307 {
3308         struct dib0700_adapter_state *state = adap->priv;
3309 
3310         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3311                 return -ENODEV;
3312 
3313         stk7070pd_init(adap->dev);
3314 
3315         msleep(10);
3316         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3317 
3318         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3319                                      stk7070pd_dib7000p_config) != 0) {
3320                 err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3321                     __func__);
3322                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3323                 return -ENODEV;
3324         }
3325 
3326         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3327         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3328 }
3329 
3330 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3331 {
3332         struct dib0700_adapter_state *state = adap->priv;
3333 
3334         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3335                 return -ENODEV;
3336 
3337         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3338         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3339 }
3340 
3341 static int novatd_read_status_override(struct dvb_frontend *fe,
3342                                        enum fe_status *stat)
3343 {
3344         struct dvb_usb_adapter *adap = fe->dvb->priv;
3345         struct dvb_usb_device *dev = adap->dev;
3346         struct dib0700_state *state = dev->priv;
3347         int ret;
3348 
3349         ret = state->read_status(fe, stat);
3350 
3351         if (!ret)
3352                 dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3353                                 !!(*stat & FE_HAS_LOCK));
3354 
3355         return ret;
3356 }
3357 
3358 static int novatd_sleep_override(struct dvb_frontend* fe)
3359 {
3360         struct dvb_usb_adapter *adap = fe->dvb->priv;
3361         struct dvb_usb_device *dev = adap->dev;
3362         struct dib0700_state *state = dev->priv;
3363 
3364         /* turn off LED */
3365         dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3366 
3367         return state->sleep(fe);
3368 }
3369 
3370 /*
3371  * novatd_frontend_attach - Nova-TD specific attach
3372  *
3373  * Nova-TD has GPIO0, 1 and 2 for LEDs. So do not fiddle with them except for
3374  * information purposes.
3375  */
3376 static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3377 {
3378         struct dvb_usb_device *dev = adap->dev;
3379         struct dib0700_state *st = dev->priv;
3380         struct dib0700_adapter_state *state = adap->priv;
3381 
3382         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3383                 return -ENODEV;
3384 
3385         if (adap->id == 0) {
3386                 stk7070pd_init(dev);
3387 
3388                 /* turn the power LED on, the other two off (just in case) */
3389                 dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3390                 dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3391                 dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3392 
3393                 if (state->dib7000p_ops.i2c_enumeration(&dev->i2c_adap, 2, 18,
3394                                              stk7070pd_dib7000p_config) != 0) {
3395                         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3396                             __func__);
3397                         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3398                         return -ENODEV;
3399                 }
3400         }
3401 
3402         adap->fe_adap[0].fe = state->dib7000p_ops.init(&dev->i2c_adap,
3403                         adap->id == 0 ? 0x80 : 0x82,
3404                         &stk7070pd_dib7000p_config[adap->id]);
3405 
3406         if (adap->fe_adap[0].fe == NULL)
3407                 return -ENODEV;
3408 
3409         st->read_status = adap->fe_adap[0].fe->ops.read_status;
3410         adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3411         st->sleep = adap->fe_adap[0].fe->ops.sleep;
3412         adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3413 
3414         return 0;
3415 }
3416 
3417 /* S5H1411 */
3418 static struct s5h1411_config pinnacle_801e_config = {
3419         .output_mode   = S5H1411_PARALLEL_OUTPUT,
3420         .gpio          = S5H1411_GPIO_OFF,
3421         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINUOUS_NONINVERTING_CLOCK,
3422         .qam_if        = S5H1411_IF_44000,
3423         .vsb_if        = S5H1411_IF_44000,
3424         .inversion     = S5H1411_INVERSION_OFF,
3425         .status_mode   = S5H1411_DEMODLOCKING
3426 };
3427 
3428 /* Pinnacle PCTV HD Pro 801e GPIOs map:
3429    GPIO0  - currently unknown
3430    GPIO1  - xc5000 tuner reset
3431    GPIO2  - CX25843 sleep
3432    GPIO3  - currently unknown
3433    GPIO4  - currently unknown
3434    GPIO6  - currently unknown
3435    GPIO7  - currently unknown
3436    GPIO9  - currently unknown
3437    GPIO10 - CX25843 reset
3438  */
3439 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3440 {
3441         struct dib0700_state *st = adap->dev->priv;
3442 
3443         /* Make use of the new i2c functions from FW 1.20 */
3444         st->fw_use_new_i2c_api = 1;
3445 
3446         /* The s5h1411 requires the dib0700 to not be in master mode */
3447         st->disable_streaming_master_mode = 1;
3448 
3449         /* All msleep values taken from Windows USB trace */
3450         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3451         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3452         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3453         msleep(400);
3454         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3455         msleep(60);
3456         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3457         msleep(30);
3458         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3459         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3460         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3461         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3462         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3463         msleep(30);
3464 
3465         /* Put the CX25843 to sleep for now since we're in digital mode */
3466         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3467 
3468         /* GPIOs are initialized, do the attach */
3469         adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3470                               &adap->dev->i2c_adap);
3471         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3472 }
3473 
3474 static int dib0700_xc5000_tuner_callback(void *priv, int component,
3475                                          int command, int arg)
3476 {
3477         struct dvb_usb_adapter *adap = priv;
3478 
3479         if (command == XC5000_TUNER_RESET) {
3480                 /* Reset the tuner */
3481                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3482                 msleep(10);
3483                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3484                 msleep(10);
3485         } else {
3486                 err("xc5000: unknown tuner callback command: %d\n", command);
3487                 return -EINVAL;
3488         }
3489 
3490         return 0;
3491 }
3492 
3493 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3494         .i2c_address      = 0x64,
3495         .if_khz           = 5380,
3496 };
3497 
3498 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3499 {
3500         /* FIXME: generalize & move to common area */
3501         adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3502 
3503         return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3504                           &s5h1411_xc5000_tunerconfig)
3505                 == NULL ? -ENODEV : 0;
3506 }
3507 
3508 static int dib0700_xc4000_tuner_callback(void *priv, int component,
3509                                          int command, int arg)
3510 {
3511         struct dvb_usb_adapter *adap = priv;
3512         struct dib0700_adapter_state *state = adap->priv;
3513 
3514         if (command == XC4000_TUNER_RESET) {
3515                 /* Reset the tuner */
3516                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3517                 msleep(10);
3518                 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3519         } else {
3520                 err("xc4000: unknown tuner callback command: %d\n", command);
3521                 return -EINVAL;
3522         }
3523 
3524         return 0;
3525 }
3526 
3527 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3528         .band_caps = BAND_UHF | BAND_VHF,
3529         .setup = 0x64,
3530         .inv_gain = 0x02c8,
3531         .time_stabiliz = 0x15,
3532         .alpha_level = 0x00,
3533         .thlock = 0x76,
3534         .wbd_inv = 0x01,
3535         .wbd_ref = 0x0b33,
3536         .wbd_sel = 0x00,
3537         .wbd_alpha = 0x02,
3538         .agc1_max = 0x00,
3539         .agc1_min = 0x00,
3540         .agc2_max = 0x9b26,
3541         .agc2_min = 0x26ca,
3542         .agc1_pt1 = 0x00,
3543         .agc1_pt2 = 0x00,
3544         .agc1_pt3 = 0x00,
3545         .agc1_slope1 = 0x00,
3546         .agc1_slope2 = 0x00,
3547         .agc2_pt1 = 0x00,
3548         .agc2_pt2 = 0x80,
3549         .agc2_slope1 = 0x1d,
3550         .agc2_slope2 = 0x1d,
3551         .alpha_mant = 0x11,
3552         .alpha_exp = 0x1b,
3553         .beta_mant = 0x17,
3554         .beta_exp = 0x33,
3555         .perform_agc_softsplit = 0x00,
3556 };
3557 
3558 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3559         .internal = 60000,
3560         .sampling = 30000,
3561         .pll_prediv = 1,
3562         .pll_ratio = 8,
3563         .pll_range = 3,
3564         .pll_reset = 1,
3565         .pll_bypass = 0,
3566         .enable_refdiv = 0,
3567         .bypclk_div = 0,
3568         .IO_CLK_en_core = 1,
3569         .ADClkSrc = 1,
3570         .modulo = 0,
3571         .sad_cfg = (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
3572         .ifreq = 39370534,
3573         .timf = 20452225,
3574         .xtal_hz = 30000000
3575 };
3576 
3577 /* FIXME: none of these inputs are validated yet */
3578 static struct dib7000p_config pctv_340e_config = {
3579         .output_mpeg2_in_188_bytes = 1,
3580 
3581         .agc_config_count = 1,
3582         .agc = &stk7700p_7000p_xc4000_agc_config,
3583         .bw  = &stk7700p_xc4000_pll_config,
3584 
3585         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3586         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3587         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3588 };
3589 
3590 /* PCTV 340e GPIOs map:
3591    dib0700:
3592    GPIO2  - CX25843 sleep
3593    GPIO3  - CS5340 reset
3594    GPIO5  - IRD
3595    GPIO6  - Power Supply
3596    GPIO8  - LNA (1=off 0=on)
3597    GPIO10 - CX25843 reset
3598    dib7000:
3599    GPIO8  - xc4000 reset
3600  */
3601 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3602 {
3603         struct dib0700_state *st = adap->dev->priv;
3604         struct dib0700_adapter_state *state = adap->priv;
3605 
3606         if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3607                 return -ENODEV;
3608 
3609         /* Power Supply on */
3610         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
3611         msleep(50);
3612         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1);
3613         msleep(100); /* Allow power supply to settle before probing */
3614 
3615         /* cx25843 reset */
3616         dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 0);
3617         msleep(1); /* cx25843 datasheet say 350us required */
3618         dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 1);
3619 
3620         /* LNA off for now */
3621         dib0700_set_gpio(adap->dev, GPIO8,  GPIO_OUT, 1);
3622 
3623         /* Put the CX25843 to sleep for now since we're in digital mode */
3624         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3625 
3626         /* FIXME: not verified yet */
3627         dib0700_ctrl_clock(adap->dev, 72, 1);
3628 
3629         msleep(500);
3630 
3631         if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3632                 /* Demodulator not found for some reason? */
3633                 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3634                 return -ENODEV;
3635         }
3636 
3637         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x12,
3638                               &pctv_340e_config);
3639         st->is_dib7000pc = 1;
3640 
3641         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3642 }
3643 
3644 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3645         .i2c_address      = 0x61,
3646         .default_pm       = 1,
3647         .dvb_amplitude    = 0,
3648         .set_smoothedcvbs = 0,
3649         .if_khz           = 5400
3650 };
3651 
3652 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3653 {
3654         struct i2c_adapter *tun_i2c;
3655         struct dib0700_adapter_state *state = adap->priv;
3656 
3657         /* The xc4000 is not on the main i2c bus */
3658         tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
3659                                           DIBX000_I2C_INTERFACE_TUNER, 1);
3660         if (tun_i2c == NULL) {
3661                 printk(KERN_ERR "Could not reach tuner i2c bus\n");
3662                 return 0;
3663         }
3664 
3665         /* Setup the reset callback */
3666         adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3667 
3668         return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3669                           &dib7000p_xc4000_tunerconfig)
3670                 == NULL ? -ENODEV : 0;
3671 }
3672 
3673 static struct lgdt3305_config hcw_lgdt3305_config = {
3674         .i2c_addr           = 0x0e,
3675         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
3676         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
3677         .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
3678         .deny_i2c_rptr      = 0,
3679         .spectral_inversion = 1,
3680         .qam_if_khz         = 6000,
3681         .vsb_if_khz         = 6000,
3682         .usref_8vsb         = 0x0500,
3683 };
3684 
3685 static struct mxl5007t_config hcw_mxl5007t_config = {
3686         .xtal_freq_hz = MxL_XTAL_25_MHZ,
3687         .if_freq_hz = MxL_IF_6_MHZ,
3688         .invert_if = 1,
3689 };
3690 
3691 /* TIGER-ATSC map:
3692    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
3693    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
3694    GPIO4  - SCL2
3695    GPIO6  - EN_TUNER
3696    GPIO7  - SDA2
3697    GPIO10 - DEM_RST
3698 
3699    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
3700  */
3701 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3702 {
3703         struct dib0700_state *st = adap->dev->priv;
3704 
3705         /* Make use of the new i2c functions from FW 1.20 */
3706         st->fw_use_new_i2c_api = 1;
3707 
3708         st->disable_streaming_master_mode = 1;
3709 
3710         /* fe power enable */
3711         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3712         msleep(30);
3713         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3714         msleep(30);
3715 
3716         /* demod reset */
3717         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3718         msleep(30);
3719         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3720         msleep(30);
3721         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3722         msleep(30);
3723 
3724         adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3725                               &hcw_lgdt3305_config,
3726                               &adap->dev->i2c_adap);
3727 
3728         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3729 }
3730 
3731 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3732 {
3733         return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3734                           &adap->dev->i2c_adap, 0x60,
3735                           &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3736 }
3737 
3738 static int xbox_one_attach(struct dvb_usb_adapter *adap)
3739 {
3740         struct dib0700_state *st = adap->dev->priv;
3741         struct i2c_client *client_demod, *client_tuner;
3742         struct dvb_usb_device *d = adap->dev;
3743         struct mn88472_config mn88472_config = { };
3744         struct tda18250_config tda18250_config;
3745         struct i2c_board_info info;
3746 
3747         st->fw_use_new_i2c_api = 1;
3748         st->disable_streaming_master_mode = 1;
3749 
3750         /* fe power enable */
3751         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3752         msleep(30);
3753         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3754         msleep(30);
3755 
3756         /* demod reset */
3757         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3758         msleep(30);
3759         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3760         msleep(30);
3761         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3762         msleep(30);
3763 
3764         /* attach demod */
3765         mn88472_config.fe = &adap->fe_adap[0].fe;
3766         mn88472_config.i2c_wr_max = 22;
3767         mn88472_config.xtal = 20500000;
3768         mn88472_config.ts_mode = PARALLEL_TS_MODE;
3769         mn88472_config.ts_clock = FIXED_TS_CLOCK;
3770         memset(&info, 0, sizeof(struct i2c_board_info));
3771         strscpy(info.type, "mn88472", I2C_NAME_SIZE);
3772         info.addr = 0x18;
3773         info.platform_data = &mn88472_config;
3774         request_module(info.type);
3775         client_demod = i2c_new_device(&d->i2c_adap, &info);
3776         if (client_demod == NULL || client_demod->dev.driver == NULL)
3777                 goto fail_demod_device;
3778         if (!try_module_get(client_demod->dev.driver->owner))
3779                 goto fail_demod_module;
3780 
3781         st->i2c_client_demod = client_demod;
3782 
3783         adap->fe_adap[0].fe = mn88472_config.get_dvb_frontend(client_demod);
3784 
3785         /* attach tuner */
3786         memset(&tda18250_config, 0, sizeof(tda18250_config));
3787         tda18250_config.if_dvbt_6 = 3950;
3788         tda18250_config.if_dvbt_7 = 4450;
3789         tda18250_config.if_dvbt_8 = 4950;
3790         tda18250_config.if_dvbc_6 = 4950;
3791         tda18250_config.if_dvbc_8 = 4950;
3792         tda18250_config.if_atsc = 4079;
3793         tda18250_config.loopthrough = true;
3794         tda18250_config.xtal_freq = TDA18250_XTAL_FREQ_27MHZ;
3795         tda18250_config.fe = adap->fe_adap[0].fe;
3796 
3797         memset(&info, 0, sizeof(struct i2c_board_info));
3798         strscpy(info.type, "tda18250", I2C_NAME_SIZE);
3799         info.addr = 0x60;
3800         info.platform_data = &tda18250_config;
3801 
3802         request_module(info.type);
3803         client_tuner = i2c_new_device(&adap->dev->i2c_adap, &info);
3804         if (client_tuner == NULL || client_tuner->dev.driver == NULL)
3805                 goto fail_tuner_device;
3806         if (!try_module_get(client_tuner->dev.driver->owner))
3807                 goto fail_tuner_module;
3808 
3809         st->i2c_client_tuner = client_tuner;
3810         return 0;
3811 
3812 fail_tuner_module:
3813         i2c_unregister_device(client_tuner);
3814 fail_tuner_device:
3815         module_put(client_demod->dev.driver->owner);
3816 fail_demod_module:
3817         i2c_unregister_device(client_demod);
3818 fail_demod_device:
3819         return -ENODEV;
3820 }
3821 
3822 
3823 /* DVB-USB and USB stuff follows */
3824 struct usb_device_id dib0700_usb_id_table[] = {
3825 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
3826         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
3827         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
3828         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
3829         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
3830 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
3831         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
3832         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
3833         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
3834         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
3835 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
3836         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
3837         { USB_DEVICE(USB_VID_TERRATEC,
3838                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
3839         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
3840         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
3841 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
3842         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
3843         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
3844         { USB_DEVICE(USB_VID_PINNACLE,
3845                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
3846         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
3847 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
3848         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
3849         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
3850         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
3851         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
3852 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
3853         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
3854         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
3855         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
3856         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
3857 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
3858         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
3859         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
3860         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
3861         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
3862 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
3863         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
3864         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
3865         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
3866         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
3867 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
3868         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
3869         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
3870         { USB_DEVICE(USB_VID_TERRATEC,
3871                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
3872         { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
3873 /* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
3874         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
3875         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
3876         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
3877         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
3878 /* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
3879         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
3880         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
3881         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
3882         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
3883 /* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
3884         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
3885         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
3886         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
3887         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
3888 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
3889         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
3890         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
3891         { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
3892         { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
3893 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
3894         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
3895         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
3896         { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
3897         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090M) },
3898 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM8096MD) },
3899         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090MD) },
3900         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM7090) },
3901         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7090PVR) },
3902         { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
3903 /* 75 */{ USB_DEVICE(USB_VID_MEDION,    USB_PID_CREATIX_CTX1921) },
3904         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E) },
3905         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E_SE) },
3906         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7790P) },
3907         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE8096P) },
3908 /* 80 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_2) },
3909         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PCTV_2002E) },
3910         { USB_DEVICE(USB_VID_PCTV,      USB_PID_PCTV_2002E_SE) },
3911         { USB_DEVICE(USB_VID_PCTV,      USB_PID_DIBCOM_STK8096PVR) },
3912         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096PVR) },
3913 /* 85 */{ USB_DEVICE(USB_VID_HAMA,      USB_PID_HAMA_DVBT_HYBRID) },
3914         { USB_DEVICE(USB_VID_MICROSOFT, USB_PID_XBOX_ONE_TUNER) },
3915         { 0 }           /* Terminating entry */
3916 };
3917 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
3918 
3919 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
3920         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
3921         .usb_ctrl          = DEVICE_SPECIFIC, \
3922         .firmware          = "dvb-usb-dib0700-1.20.fw", \
3923         .download_firmware = dib0700_download_firmware, \
3924         .no_reconnect      = 1, \
3925         .size_of_priv      = sizeof(struct dib0700_state), \
3926         .i2c_algo          = &dib0700_i2c_algo, \
3927         .identify_state    = dib0700_identify_state
3928 
3929 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
3930         .streaming_ctrl   = dib0700_streaming_ctrl, \
3931         .stream = { \
3932                 .type = USB_BULK, \
3933                 .count = 4, \
3934                 .endpoint = ep, \
3935                 .u = { \
3936                         .bulk = { \
3937                                 .buffersize = 39480, \
3938                         } \
3939                 } \
3940         }
3941 
3942 #define DIB0700_NUM_FRONTENDS(n) \
3943         .num_frontends = n, \
3944         .size_of_priv     = sizeof(struct dib0700_adapter_state)
3945 
3946 struct dvb_usb_device_properties dib0700_devices[] = {
3947         {
3948                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
3949 
3950                 .num_adapters = 1,
3951                 .adapter = {
3952                         {
3953                         DIB0700_NUM_FRONTENDS(1),
3954                         .fe = {{
3955                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3956                                 .pid_filter_count = 32,
3957                                 .pid_filter       = stk7700p_pid_filter,
3958                                 .pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
3959                                 .frontend_attach  = stk7700p_frontend_attach,
3960                                 .tuner_attach     = stk7700p_tuner_attach,
3961 
3962                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3963                         }},
3964                         },
3965                 },
3966 
3967                 .num_device_descs = 8,
3968                 .devices = {
3969                         {   "DiBcom STK7700P reference design",
3970                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3971                                 { NULL },
3972                         },
3973                         {   "Hauppauge Nova-T Stick",
3974                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3975                                 { NULL },
3976                         },
3977                         {   "AVerMedia AVerTV DVB-T Volar",
3978                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3979                                 { NULL },
3980                         },
3981                         {   "Compro Videomate U500",
3982                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3983                                 { NULL },
3984                         },
3985                         {   "Uniwill STK7700P based (Hama and others)",
3986                                 { &dib0700_usb_id_table[7], NULL },
3987                                 { NULL },
3988                         },
3989                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
3990                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3991                                 { NULL },
3992                         },
3993                         {   "AVerMedia AVerTV DVB-T Express",
3994                                 { &dib0700_usb_id_table[20] },
3995                                 { NULL },
3996                         },
3997                         {   "Gigabyte U7000",
3998                                 { &dib0700_usb_id_table[21], NULL },
3999                                 { NULL },
4000                         }
4001                 },
4002 
4003                 .rc.core = {
4004                         .rc_interval      = DEFAULT_RC_INTERVAL,
4005                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4006                         .rc_query         = dib0700_rc_query_old_firmware,
4007                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4008                                             RC_PROTO_BIT_RC6_MCE |
4009                                             RC_PROTO_BIT_NEC,
4010                         .change_protocol  = dib0700_change_protocol,
4011                 },
4012         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4013 
4014                 .num_adapters = 2,
4015                 .adapter = {
4016                         {
4017                         DIB0700_NUM_FRONTENDS(1),
4018                         .fe = {{
4019                                 .frontend_attach  = bristol_frontend_attach,
4020                                 .tuner_attach     = bristol_tuner_attach,
4021 
4022                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4023                         }},
4024                         }, {
4025                         DIB0700_NUM_FRONTENDS(1),
4026                         .fe = {{
4027                                 .frontend_attach  = bristol_frontend_attach,
4028                                 .tuner_attach     = bristol_tuner_attach,
4029 
4030                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4031                         }},
4032                         }
4033                 },
4034 
4035                 .num_device_descs = 1,
4036                 .devices = {
4037                         {   "Hauppauge Nova-T 500 Dual DVB-T",
4038                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
4039                                 { NULL },
4040                         },
4041                 },
4042 
4043                 .rc.core = {
4044                         .rc_interval      = DEFAULT_RC_INTERVAL,
4045                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4046                         .rc_query         = dib0700_rc_query_old_firmware,
4047                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4048                                             RC_PROTO_BIT_RC6_MCE |
4049                                             RC_PROTO_BIT_NEC,
4050                         .change_protocol = dib0700_change_protocol,
4051                 },
4052         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4053 
4054                 .num_adapters = 2,
4055                 .adapter = {
4056                         {
4057                         DIB0700_NUM_FRONTENDS(1),
4058                         .fe = {{
4059                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4060                                 .pid_filter_count = 32,
4061                                 .pid_filter       = stk70x0p_pid_filter,
4062                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4063                                 .frontend_attach  = stk7700d_frontend_attach,
4064                                 .tuner_attach     = stk7700d_tuner_attach,
4065 
4066                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4067                         }},
4068                         }, {
4069                         DIB0700_NUM_FRONTENDS(1),
4070                         .fe = {{
4071                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4072                                 .pid_filter_count = 32,
4073                                 .pid_filter       = stk70x0p_pid_filter,
4074                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4075                                 .frontend_attach  = stk7700d_frontend_attach,
4076                                 .tuner_attach     = stk7700d_tuner_attach,
4077 
4078                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4079                         }},
4080                         }
4081                 },
4082 
4083                 .num_device_descs = 5,
4084                 .devices = {
4085                         {   "Pinnacle PCTV 2000e",
4086                                 { &dib0700_usb_id_table[11], NULL },
4087                                 { NULL },
4088                         },
4089                         {   "Terratec Cinergy DT XS Diversity",
4090                                 { &dib0700_usb_id_table[12], NULL },
4091                                 { NULL },
4092                         },
4093                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
4094                                 { &dib0700_usb_id_table[13], NULL },
4095                                 { NULL },
4096                         },
4097                         {   "DiBcom STK7700D reference design",
4098                                 { &dib0700_usb_id_table[14], NULL },
4099                                 { NULL },
4100                         },
4101                         {   "YUAN High-Tech DiBcom STK7700D",
4102                                 { &dib0700_usb_id_table[55], NULL },
4103                                 { NULL },
4104                         },
4105 
4106                 },
4107 
4108                 .rc.core = {
4109                         .rc_interval      = DEFAULT_RC_INTERVAL,
4110                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4111                         .rc_query         = dib0700_rc_query_old_firmware,
4112                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4113                                             RC_PROTO_BIT_RC6_MCE |
4114                                             RC_PROTO_BIT_NEC,
4115                         .change_protocol = dib0700_change_protocol,
4116                 },
4117         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4118 
4119                 .num_adapters = 1,
4120                 .adapter = {
4121                         {
4122                         DIB0700_NUM_FRONTENDS(1),
4123                         .fe = {{
4124                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4125                                 .pid_filter_count = 32,
4126                                 .pid_filter       = stk70x0p_pid_filter,
4127                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4128                                 .frontend_attach  = stk7700P2_frontend_attach,
4129                                 .tuner_attach     = stk7700d_tuner_attach,
4130 
4131                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4132                         }},
4133                         },
4134                 },
4135 
4136                 .num_device_descs = 3,
4137                 .devices = {
4138                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
4139                                 { &dib0700_usb_id_table[23], NULL },
4140                                 { NULL },
4141                         },
4142                         {   "Yuan EC372S",
4143                                 { &dib0700_usb_id_table[31], NULL },
4144                                 { NULL },
4145                         },
4146                         {   "Terratec Cinergy T Express",
4147                                 { &dib0700_usb_id_table[42], NULL },
4148                                 { NULL },
4149                         }
4150                 },
4151 
4152                 .rc.core = {
4153                         .rc_interval      = DEFAULT_RC_INTERVAL,
4154                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4155                         .module_name      = "dib0700",
4156                         .rc_query         = dib0700_rc_query_old_firmware,
4157                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4158                                             RC_PROTO_BIT_RC6_MCE |
4159                                             RC_PROTO_BIT_NEC,
4160                         .change_protocol = dib0700_change_protocol,
4161                 },
4162         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4163 
4164                 .num_adapters = 1,
4165                 .adapter = {
4166                         {
4167                         DIB0700_NUM_FRONTENDS(1),
4168                         .fe = {{
4169                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4170                                 .pid_filter_count = 32,
4171                                 .pid_filter       = stk70x0p_pid_filter,
4172                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4173                                 .frontend_attach  = stk7070p_frontend_attach,
4174                                 .tuner_attach     = dib7070p_tuner_attach,
4175 
4176                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4177                         }},
4178                         },
4179                 },
4180 
4181                 .num_device_descs = 12,
4182                 .devices = {
4183                         {   "DiBcom STK7070P reference design",
4184                                 { &dib0700_usb_id_table[15], NULL },
4185                                 { NULL },
4186                         },
4187                         {   "Pinnacle PCTV DVB-T Flash Stick",
4188                                 { &dib0700_usb_id_table[16], NULL },
4189                                 { NULL },
4190                         },
4191                         {   "Artec T14BR DVB-T",
4192                                 { &dib0700_usb_id_table[22], NULL },
4193                                 { NULL },
4194                         },
4195                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
4196                                 { &dib0700_usb_id_table[24], NULL },
4197                                 { NULL },
4198                         },
4199                         {   "Hauppauge Nova-T Stick",
4200                                 { &dib0700_usb_id_table[25], NULL },
4201                                 { NULL },
4202                         },
4203                         {   "Hauppauge Nova-T MyTV.t",
4204                                 { &dib0700_usb_id_table[26], NULL },
4205                                 { NULL },
4206                         },
4207                         {   "Pinnacle PCTV 72e",
4208                                 { &dib0700_usb_id_table[29], NULL },
4209                                 { NULL },
4210                         },
4211                         {   "Pinnacle PCTV 73e",
4212                                 { &dib0700_usb_id_table[30], NULL },
4213                                 { NULL },
4214                         },
4215                         {   "Elgato EyeTV DTT",
4216                                 { &dib0700_usb_id_table[49], NULL },
4217                                 { NULL },
4218                         },
4219                         {   "Yuan PD378S",
4220                                 { &dib0700_usb_id_table[45], NULL },
4221                                 { NULL },
4222                         },
4223                         {   "Elgato EyeTV Dtt Dlx PD378S",
4224                                 { &dib0700_usb_id_table[50], NULL },
4225                                 { NULL },
4226                         },
4227                         {   "Elgato EyeTV DTT rev. 2",
4228                                 { &dib0700_usb_id_table[80], NULL },
4229                                 { NULL },
4230                         },
4231                 },
4232 
4233                 .rc.core = {
4234                         .rc_interval      = DEFAULT_RC_INTERVAL,
4235                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4236                         .module_name      = "dib0700",
4237                         .rc_query         = dib0700_rc_query_old_firmware,
4238                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4239                                             RC_PROTO_BIT_RC6_MCE |
4240                                             RC_PROTO_BIT_NEC,
4241                         .change_protocol  = dib0700_change_protocol,
4242                 },
4243         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4244 
4245                 .num_adapters = 1,
4246                 .adapter = {
4247                         {
4248                         DIB0700_NUM_FRONTENDS(1),
4249                         .fe = {{
4250                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4251                                 .pid_filter_count = 32,
4252                                 .pid_filter       = stk70x0p_pid_filter,
4253                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4254                                 .frontend_attach  = stk7070p_frontend_attach,
4255                                 .tuner_attach     = dib7070p_tuner_attach,
4256 
4257                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4258                         }},
4259                         },
4260                 },
4261 
4262                 .num_device_descs = 3,
4263                 .devices = {
4264                         {   "Pinnacle PCTV 73A",
4265                                 { &dib0700_usb_id_table[56], NULL },
4266                                 { NULL },
4267                         },
4268                         {   "Pinnacle PCTV 73e SE",
4269                                 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
4270                                 { NULL },
4271                         },
4272                         {   "Pinnacle PCTV 282e",
4273                                 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
4274                                 { NULL },
4275                         },
4276                 },
4277 
4278                 .rc.core = {
4279                         .rc_interval      = DEFAULT_RC_INTERVAL,
4280                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4281                         .module_name      = "dib0700",
4282                         .rc_query         = dib0700_rc_query_old_firmware,
4283                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4284                                             RC_PROTO_BIT_RC6_MCE |
4285                                             RC_PROTO_BIT_NEC,
4286                         .change_protocol  = dib0700_change_protocol,
4287                 },
4288         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4289 
4290                 .num_adapters = 2,
4291                 .adapter = {
4292                         {
4293                         DIB0700_NUM_FRONTENDS(1),
4294                         .fe = {{
4295                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4296                                 .pid_filter_count = 32,
4297                                 .pid_filter       = stk70x0p_pid_filter,
4298                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4299                                 .frontend_attach  = novatd_frontend_attach,
4300                                 .tuner_attach     = dib7070p_tuner_attach,
4301 
4302                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4303                         }},
4304                         }, {
4305                         DIB0700_NUM_FRONTENDS(1),
4306                         .fe = {{
4307                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4308                                 .pid_filter_count = 32,
4309                                 .pid_filter       = stk70x0p_pid_filter,
4310                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4311                                 .frontend_attach  = novatd_frontend_attach,
4312                                 .tuner_attach     = dib7070p_tuner_attach,
4313 
4314                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4315                         }},
4316                         }
4317                 },
4318 
4319                 .num_device_descs = 3,
4320                 .devices = {
4321                         {   "Hauppauge Nova-TD Stick (52009)",
4322                                 { &dib0700_usb_id_table[35], NULL },
4323                                 { NULL },
4324                         },
4325                         {   "PCTV 2002e",
4326                                 { &dib0700_usb_id_table[81], NULL },
4327                                 { NULL },
4328                         },
4329                         {   "PCTV 2002e SE",
4330                                 { &dib0700_usb_id_table[82], NULL },
4331                                 { NULL },
4332                         },
4333                 },
4334 
4335                 .rc.core = {
4336                         .rc_interval      = DEFAULT_RC_INTERVAL,
4337                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4338                         .module_name      = "dib0700",
4339                         .rc_query         = dib0700_rc_query_old_firmware,
4340                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4341                                             RC_PROTO_BIT_RC6_MCE |
4342                                             RC_PROTO_BIT_NEC,
4343                         .change_protocol = dib0700_change_protocol,
4344                 },
4345         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4346 
4347                 .num_adapters = 2,
4348                 .adapter = {
4349                         {
4350                         DIB0700_NUM_FRONTENDS(1),
4351                         .fe = {{
4352                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4353                                 .pid_filter_count = 32,
4354                                 .pid_filter       = stk70x0p_pid_filter,
4355                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4356                                 .frontend_attach  = stk7070pd_frontend_attach0,
4357                                 .tuner_attach     = dib7070p_tuner_attach,
4358 
4359                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4360                         }},
4361                         }, {
4362                         DIB0700_NUM_FRONTENDS(1),
4363                         .fe = {{
4364                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4365                                 .pid_filter_count = 32,
4366                                 .pid_filter       = stk70x0p_pid_filter,
4367                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4368                                 .frontend_attach  = stk7070pd_frontend_attach1,
4369                                 .tuner_attach     = dib7070p_tuner_attach,
4370 
4371                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4372                         }},
4373                         }
4374                 },
4375 
4376                 .num_device_descs = 5,
4377                 .devices = {
4378                         {   "DiBcom STK7070PD reference design",
4379                                 { &dib0700_usb_id_table[17], NULL },
4380                                 { NULL },
4381                         },
4382                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
4383                                 { &dib0700_usb_id_table[18], NULL },
4384                                 { NULL },
4385                         },
4386                         {   "Hauppauge Nova-TD-500 (84xxx)",
4387                                 { &dib0700_usb_id_table[36], NULL },
4388                                 { NULL },
4389                         },
4390                         {  "Terratec Cinergy DT USB XS Diversity/ T5",
4391                                 { &dib0700_usb_id_table[43],
4392                                         &dib0700_usb_id_table[53], NULL},
4393                                 { NULL },
4394                         },
4395                         {  "Sony PlayTV",
4396                                 { &dib0700_usb_id_table[44], NULL },
4397                                 { NULL },
4398                         },
4399                 },
4400 
4401                 .rc.core = {
4402                         .rc_interval      = DEFAULT_RC_INTERVAL,
4403                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4404                         .module_name      = "dib0700",
4405                         .rc_query         = dib0700_rc_query_old_firmware,
4406                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4407                                             RC_PROTO_BIT_RC6_MCE |
4408                                             RC_PROTO_BIT_NEC,
4409                         .change_protocol = dib0700_change_protocol,
4410                 },
4411         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4412 
4413                 .num_adapters = 2,
4414                 .adapter = {
4415                         {
4416                         DIB0700_NUM_FRONTENDS(1),
4417                         .fe = {{
4418                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4419                                 .pid_filter_count = 32,
4420                                 .pid_filter       = stk70x0p_pid_filter,
4421                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4422                                 .frontend_attach  = stk7070pd_frontend_attach0,
4423                                 .tuner_attach     = dib7070p_tuner_attach,
4424 
4425                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4426                         }},
4427                         }, {
4428                         DIB0700_NUM_FRONTENDS(1),
4429                         .fe = {{
4430                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4431                                 .pid_filter_count = 32,
4432                                 .pid_filter       = stk70x0p_pid_filter,
4433                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4434                                 .frontend_attach  = stk7070pd_frontend_attach1,
4435                                 .tuner_attach     = dib7070p_tuner_attach,
4436 
4437                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4438                         }},
4439                         }
4440                 },
4441 
4442                 .num_device_descs = 1,
4443                 .devices = {
4444                         {   "Elgato EyeTV Diversity",
4445                                 { &dib0700_usb_id_table[68], NULL },
4446                                 { NULL },
4447                         },
4448                 },
4449 
4450                 .rc.core = {
4451                         .rc_interval      = DEFAULT_RC_INTERVAL,
4452                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4453                         .module_name      = "dib0700",
4454                         .rc_query         = dib0700_rc_query_old_firmware,
4455                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4456                                             RC_PROTO_BIT_RC6_MCE |
4457                                             RC_PROTO_BIT_NEC,
4458                         .change_protocol  = dib0700_change_protocol,
4459                 },
4460         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4461 
4462                 .num_adapters = 1,
4463                 .adapter = {
4464                         {
4465                         DIB0700_NUM_FRONTENDS(1),
4466                         .fe = {{
4467                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4468                                 .pid_filter_count = 32,
4469                                 .pid_filter       = stk70x0p_pid_filter,
4470                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4471                                 .frontend_attach  = stk7700ph_frontend_attach,
4472                                 .tuner_attach     = stk7700ph_tuner_attach,
4473 
4474                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4475                         }},
4476                         },
4477                 },
4478 
4479                 .num_device_descs = 10,
4480                 .devices = {
4481                         {   "Terratec Cinergy HT USB XE",
4482                                 { &dib0700_usb_id_table[27], NULL },
4483                                 { NULL },
4484                         },
4485                         {   "Pinnacle Expresscard 320cx",
4486                                 { &dib0700_usb_id_table[28], NULL },
4487                                 { NULL },
4488                         },
4489                         {   "Terratec Cinergy HT Express",
4490                                 { &dib0700_usb_id_table[32], NULL },
4491                                 { NULL },
4492                         },
4493                         {   "Gigabyte U8000-RH",
4494                                 { &dib0700_usb_id_table[37], NULL },
4495                                 { NULL },
4496                         },
4497                         {   "YUAN High-Tech STK7700PH",
4498                                 { &dib0700_usb_id_table[38], NULL },
4499                                 { NULL },
4500                         },
4501                         {   "Asus My Cinema-U3000Hybrid",
4502                                 { &dib0700_usb_id_table[39], NULL },
4503                                 { NULL },
4504                         },
4505                         {   "YUAN High-Tech MC770",
4506                                 { &dib0700_usb_id_table[48], NULL },
4507                                 { NULL },
4508                         },
4509                         {   "Leadtek WinFast DTV Dongle H",
4510                                 { &dib0700_usb_id_table[51], NULL },
4511                                 { NULL },
4512                         },
4513                         {   "YUAN High-Tech STK7700D",
4514                                 { &dib0700_usb_id_table[54], NULL },
4515                                 { NULL },
4516                         },
4517                         {   "Hama DVB=T Hybrid USB Stick",
4518                                 { &dib0700_usb_id_table[85], NULL },
4519                                 { NULL },
4520                         },
4521                 },
4522 
4523                 .rc.core = {
4524                         .rc_interval      = DEFAULT_RC_INTERVAL,
4525                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4526                         .module_name      = "dib0700",
4527                         .rc_query         = dib0700_rc_query_old_firmware,
4528                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4529                                             RC_PROTO_BIT_RC6_MCE |
4530                                             RC_PROTO_BIT_NEC,
4531                         .change_protocol  = dib0700_change_protocol,
4532                 },
4533         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4534                 .num_adapters = 1,
4535                 .adapter = {
4536                         {
4537                         DIB0700_NUM_FRONTENDS(1),
4538                         .fe = {{
4539                                 .frontend_attach  = s5h1411_frontend_attach,
4540                                 .tuner_attach     = xc5000_tuner_attach,
4541 
4542                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4543                         }},
4544                         },
4545                 },
4546 
4547                 .num_device_descs = 2,
4548                 .devices = {
4549                         {   "Pinnacle PCTV HD Pro USB Stick",
4550                                 { &dib0700_usb_id_table[40], NULL },
4551                                 { NULL },
4552                         },
4553                         {   "Pinnacle PCTV HD USB Stick",
4554                                 { &dib0700_usb_id_table[41], NULL },
4555                                 { NULL },
4556                         },
4557                 },
4558 
4559                 .rc.core = {
4560                         .rc_interval      = DEFAULT_RC_INTERVAL,
4561                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4562                         .module_name      = "dib0700",
4563                         .rc_query         = dib0700_rc_query_old_firmware,
4564                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4565                                             RC_PROTO_BIT_RC6_MCE |
4566                                             RC_PROTO_BIT_NEC,
4567                         .change_protocol  = dib0700_change_protocol,
4568                 },
4569         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4570                 .num_adapters = 1,
4571                 .adapter = {
4572                         {
4573                         DIB0700_NUM_FRONTENDS(1),
4574                         .fe = {{
4575                                 .frontend_attach  = lgdt3305_frontend_attach,
4576                                 .tuner_attach     = mxl5007t_tuner_attach,
4577 
4578                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4579                         }},
4580                         },
4581                 },
4582 
4583                 .num_device_descs = 2,
4584                 .devices = {
4585                         {   "Hauppauge ATSC MiniCard (B200)",
4586                                 { &dib0700_usb_id_table[46], NULL },
4587                                 { NULL },
4588                         },
4589                         {   "Hauppauge ATSC MiniCard (B210)",
4590                                 { &dib0700_usb_id_table[47], NULL },
4591                                 { NULL },
4592                         },
4593                 },
4594         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4595 
4596                 .num_adapters = 1,
4597                 .adapter = {
4598                         {
4599                         DIB0700_NUM_FRONTENDS(1),
4600                         .fe = {{
4601                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4602                                 .pid_filter_count = 32,
4603                                 .pid_filter       = stk70x0p_pid_filter,
4604                                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4605                                 .frontend_attach  = stk7770p_frontend_attach,
4606                                 .tuner_attach     = dib7770p_tuner_attach,
4607 
4608                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4609                         }},
4610                         },
4611                 },
4612 
4613                 .num_device_descs = 4,
4614                 .devices = {
4615                         {   "DiBcom STK7770P reference design",
4616                                 { &dib0700_usb_id_table[59], NULL },
4617                                 { NULL },
4618                         },
4619                         {   "Terratec Cinergy T USB XXS (HD)/ T3",
4620                                 { &dib0700_usb_id_table[33],
4621                                         &dib0700_usb_id_table[52],
4622                                         &dib0700_usb_id_table[60], NULL},
4623                                 { NULL },
4624                         },
4625                         {   "TechniSat AirStar TeleStick 2",
4626                                 { &dib0700_usb_id_table[74], NULL },
4627                                 { NULL },
4628                         },
4629                         {   "Medion CTX1921 DVB-T USB",
4630                                 { &dib0700_usb_id_table[75], NULL },
4631                                 { NULL },
4632                         },
4633                 },
4634 
4635                 .rc.core = {
4636                         .rc_interval      = DEFAULT_RC_INTERVAL,
4637                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4638                         .module_name      = "dib0700",
4639                         .rc_query         = dib0700_rc_query_old_firmware,
4640                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4641                                             RC_PROTO_BIT_RC6_MCE |
4642                                             RC_PROTO_BIT_NEC,
4643                         .change_protocol  = dib0700_change_protocol,
4644                 },
4645         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4646                 .num_adapters = 1,
4647                 .adapter = {
4648                         {
4649                         DIB0700_NUM_FRONTENDS(1),
4650                         .fe = {{
4651                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4652                                 .pid_filter_count = 32,
4653                                 .pid_filter = stk80xx_pid_filter,
4654                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4655                                 .frontend_attach  = stk807x_frontend_attach,
4656                                 .tuner_attach     = dib807x_tuner_attach,
4657 
4658                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4659                         }},
4660                         },
4661                 },
4662 
4663                 .num_device_descs = 3,
4664                 .devices = {
4665                         {   "DiBcom STK807xP reference design",
4666                                 { &dib0700_usb_id_table[62], NULL },
4667                                 { NULL },
4668                         },
4669                         {   "Prolink Pixelview SBTVD",
4670                                 { &dib0700_usb_id_table[63], NULL },
4671                                 { NULL },
4672                         },
4673                         {   "EvolutePC TVWay+",
4674                                 { &dib0700_usb_id_table[64], NULL },
4675                                 { NULL },
4676                         },
4677                 },
4678 
4679                 .rc.core = {
4680                         .rc_interval      = DEFAULT_RC_INTERVAL,
4681                         .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4682                         .module_name      = "dib0700",
4683                         .rc_query         = dib0700_rc_query_old_firmware,
4684                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4685                                             RC_PROTO_BIT_RC6_MCE |
4686                                             RC_PROTO_BIT_NEC,
4687                         .change_protocol  = dib0700_change_protocol,
4688                 },
4689         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4690                 .num_adapters = 2,
4691                 .adapter = {
4692                         {
4693                         DIB0700_NUM_FRONTENDS(1),
4694                         .fe = {{
4695                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4696                                 .pid_filter_count = 32,
4697                                 .pid_filter = stk80xx_pid_filter,
4698                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4699                                 .frontend_attach  = stk807xpvr_frontend_attach0,
4700                                 .tuner_attach     = dib807x_tuner_attach,
4701 
4702                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4703                         }},
4704                         },
4705                         {
4706                         DIB0700_NUM_FRONTENDS(1),
4707                         .fe = {{
4708                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4709                                 .pid_filter_count = 32,
4710                                 .pid_filter = stk80xx_pid_filter,
4711                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4712                                 .frontend_attach  = stk807xpvr_frontend_attach1,
4713                                 .tuner_attach     = dib807x_tuner_attach,
4714 
4715                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4716                         }},
4717                         },
4718                 },
4719 
4720                 .num_device_descs = 1,
4721                 .devices = {
4722                         {   "DiBcom STK807xPVR reference design",
4723                                 { &dib0700_usb_id_table[61], NULL },
4724                                 { NULL },
4725                         },
4726                 },
4727 
4728                 .rc.core = {
4729                         .rc_interval      = DEFAULT_RC_INTERVAL,
4730                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4731                         .module_name      = "dib0700",
4732                         .rc_query         = dib0700_rc_query_old_firmware,
4733                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4734                                             RC_PROTO_BIT_RC6_MCE |
4735                                             RC_PROTO_BIT_NEC,
4736                         .change_protocol  = dib0700_change_protocol,
4737                 },
4738         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4739                 .num_adapters = 1,
4740                 .adapter = {
4741                         {
4742                         DIB0700_NUM_FRONTENDS(1),
4743                         .fe = {{
4744                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4745                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4746                                 .pid_filter_count = 32,
4747                                 .pid_filter = stk80xx_pid_filter,
4748                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4749                                 .frontend_attach  = stk809x_frontend_attach,
4750                                 .tuner_attach     = dib809x_tuner_attach,
4751 
4752                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4753                         }},
4754                         },
4755                 },
4756 
4757                 .num_device_descs = 1,
4758                 .devices = {
4759                         {   "DiBcom STK8096GP reference design",
4760                                 { &dib0700_usb_id_table[67], NULL },
4761                                 { NULL },
4762                         },
4763                 },
4764 
4765                 .rc.core = {
4766                         .rc_interval      = DEFAULT_RC_INTERVAL,
4767                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4768                         .module_name      = "dib0700",
4769                         .rc_query         = dib0700_rc_query_old_firmware,
4770                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4771                                             RC_PROTO_BIT_RC6_MCE |
4772                                             RC_PROTO_BIT_NEC,
4773                         .change_protocol  = dib0700_change_protocol,
4774                 },
4775         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4776                 .num_adapters = 1,
4777                 .adapter = {
4778                         {
4779                         DIB0700_NUM_FRONTENDS(1),
4780                         .fe = {{
4781                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4782                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4783                                 .pid_filter_count = 32,
4784                                 .pid_filter = dib90x0_pid_filter,
4785                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4786                                 .frontend_attach  = stk9090m_frontend_attach,
4787                                 .tuner_attach     = dib9090_tuner_attach,
4788 
4789                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4790                         }},
4791                         },
4792                 },
4793 
4794                 .num_device_descs = 1,
4795                 .devices = {
4796                         {   "DiBcom STK9090M reference design",
4797                                 { &dib0700_usb_id_table[69], NULL },
4798                                 { NULL },
4799                         },
4800                 },
4801 
4802                 .rc.core = {
4803                         .rc_interval      = DEFAULT_RC_INTERVAL,
4804                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4805                         .module_name      = "dib0700",
4806                         .rc_query         = dib0700_rc_query_old_firmware,
4807                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4808                                             RC_PROTO_BIT_RC6_MCE |
4809                                             RC_PROTO_BIT_NEC,
4810                         .change_protocol  = dib0700_change_protocol,
4811                 },
4812         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4813                 .num_adapters = 1,
4814                 .adapter = {
4815                         {
4816                         DIB0700_NUM_FRONTENDS(1),
4817                         .fe = {{
4818                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4819                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4820                                 .pid_filter_count = 32,
4821                                 .pid_filter = stk80xx_pid_filter,
4822                                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4823                                 .frontend_attach  = nim8096md_frontend_attach,
4824                                 .tuner_attach     = nim8096md_tuner_attach,
4825 
4826                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4827                         }},
4828                         },
4829                 },
4830 
4831                 .num_device_descs = 1,
4832                 .devices = {
4833                         {   "DiBcom NIM8096MD reference design",
4834                                 { &dib0700_usb_id_table[70], NULL },
4835                                 { NULL },
4836                         },
4837                 },
4838 
4839                 .rc.core = {
4840                         .rc_interval      = DEFAULT_RC_INTERVAL,
4841                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4842                         .module_name      = "dib0700",
4843                         .rc_query         = dib0700_rc_query_old_firmware,
4844                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4845                                             RC_PROTO_BIT_RC6_MCE |
4846                                             RC_PROTO_BIT_NEC,
4847                         .change_protocol  = dib0700_change_protocol,
4848                 },
4849         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4850                 .num_adapters = 1,
4851                 .adapter = {
4852                         {
4853                         DIB0700_NUM_FRONTENDS(1),
4854                         .fe = {{
4855                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4856                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4857                                 .pid_filter_count = 32,
4858                                 .pid_filter = dib90x0_pid_filter,
4859                                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4860                                 .frontend_attach  = nim9090md_frontend_attach,
4861                                 .tuner_attach     = nim9090md_tuner_attach,
4862 
4863                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4864                         }},
4865                         },
4866                 },
4867 
4868                 .num_device_descs = 1,
4869                 .devices = {
4870                         {   "DiBcom NIM9090MD reference design",
4871                                 { &dib0700_usb_id_table[71], NULL },
4872                                 { NULL },
4873                         },
4874                 },
4875 
4876                 .rc.core = {
4877                         .rc_interval      = DEFAULT_RC_INTERVAL,
4878                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4879                         .module_name      = "dib0700",
4880                         .rc_query         = dib0700_rc_query_old_firmware,
4881                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4882                                             RC_PROTO_BIT_RC6_MCE |
4883                                             RC_PROTO_BIT_NEC,
4884                         .change_protocol  = dib0700_change_protocol,
4885                 },
4886         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4887                 .num_adapters = 1,
4888                 .adapter = {
4889                         {
4890                         DIB0700_NUM_FRONTENDS(1),
4891                         .fe = {{
4892                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4893                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4894                                 .pid_filter_count = 32,
4895                                 .pid_filter = stk70x0p_pid_filter,
4896                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4897                                 .frontend_attach  = nim7090_frontend_attach,
4898                                 .tuner_attach     = nim7090_tuner_attach,
4899 
4900                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4901                         }},
4902                         },
4903                 },
4904 
4905                 .num_device_descs = 1,
4906                 .devices = {
4907                         {   "DiBcom NIM7090 reference design",
4908                                 { &dib0700_usb_id_table[72], NULL },
4909                                 { NULL },
4910                         },
4911                 },
4912 
4913                 .rc.core = {
4914                         .rc_interval      = DEFAULT_RC_INTERVAL,
4915                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4916                         .module_name      = "dib0700",
4917                         .rc_query         = dib0700_rc_query_old_firmware,
4918                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4919                                             RC_PROTO_BIT_RC6_MCE |
4920                                             RC_PROTO_BIT_NEC,
4921                         .change_protocol  = dib0700_change_protocol,
4922                 },
4923         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4924                 .num_adapters = 2,
4925                 .adapter = {
4926                         {
4927                         DIB0700_NUM_FRONTENDS(1),
4928                         .fe = {{
4929                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4930                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4931                                 .pid_filter_count = 32,
4932                                 .pid_filter = stk70x0p_pid_filter,
4933                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4934                                 .frontend_attach  = tfe7090pvr_frontend0_attach,
4935                                 .tuner_attach     = tfe7090pvr_tuner0_attach,
4936 
4937                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4938                         }},
4939                         },
4940                         {
4941                         DIB0700_NUM_FRONTENDS(1),
4942                         .fe = {{
4943                                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4944                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4945                                 .pid_filter_count = 32,
4946                                 .pid_filter = stk70x0p_pid_filter,
4947                                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4948                                 .frontend_attach  = tfe7090pvr_frontend1_attach,
4949                                 .tuner_attach     = tfe7090pvr_tuner1_attach,
4950 
4951                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4952                         }},
4953                         },
4954                 },
4955 
4956                 .num_device_descs = 1,
4957                 .devices = {
4958                         {   "DiBcom TFE7090PVR reference design",
4959                                 { &dib0700_usb_id_table[73], NULL },
4960                                 { NULL },
4961                         },
4962                 },
4963 
4964                 .rc.core = {
4965                         .rc_interval      = DEFAULT_RC_INTERVAL,
4966                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4967                         .module_name      = "dib0700",
4968                         .rc_query         = dib0700_rc_query_old_firmware,
4969                         .allowed_protos   = RC_PROTO_BIT_RC5 |
4970                                             RC_PROTO_BIT_RC6_MCE |
4971                                             RC_PROTO_BIT_NEC,
4972                         .change_protocol  = dib0700_change_protocol,
4973                 },
4974         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4975                 .num_adapters = 1,
4976                 .adapter = {
4977                         {
4978                         DIB0700_NUM_FRONTENDS(1),
4979                         .fe = {{
4980                                 .frontend_attach  = pctv340e_frontend_attach,
4981                                 .tuner_attach     = xc4000_tuner_attach,
4982 
4983                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4984                         }},
4985                         },
4986                 },
4987 
4988                 .num_device_descs = 2,
4989                 .devices = {
4990                         {   "Pinnacle PCTV 340e HD Pro USB Stick",
4991                                 { &dib0700_usb_id_table[76], NULL },
4992                                 { NULL },
4993                         },
4994                         {   "Pinnacle PCTV Hybrid Stick Solo",
4995                                 { &dib0700_usb_id_table[77], NULL },
4996                                 { NULL },
4997                         },
4998                 },
4999                 .rc.core = {
5000                         .rc_interval      = DEFAULT_RC_INTERVAL,
5001                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5002                         .module_name      = "dib0700",
5003                         .rc_query         = dib0700_rc_query_old_firmware,
5004                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5005                                             RC_PROTO_BIT_RC6_MCE |
5006                                             RC_PROTO_BIT_NEC,
5007                         .change_protocol  = dib0700_change_protocol,
5008                 },
5009         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5010                 .num_adapters = 1,
5011                 .adapter = {
5012                         {
5013                                 DIB0700_NUM_FRONTENDS(1),
5014                                 .fe = {{
5015                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5016                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5017                                         .pid_filter_count = 32,
5018                                         .pid_filter = stk70x0p_pid_filter,
5019                                         .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5020                                         .frontend_attach  = tfe7790p_frontend_attach,
5021                                         .tuner_attach     = tfe7790p_tuner_attach,
5022 
5023                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5024                                 } },
5025                         },
5026                 },
5027 
5028                 .num_device_descs = 1,
5029                 .devices = {
5030                         {   "DiBcom TFE7790P reference design",
5031                                 { &dib0700_usb_id_table[78], NULL },
5032                                 { NULL },
5033                         },
5034                 },
5035 
5036                 .rc.core = {
5037                         .rc_interval      = DEFAULT_RC_INTERVAL,
5038                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5039                         .module_name      = "dib0700",
5040                         .rc_query         = dib0700_rc_query_old_firmware,
5041                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5042                                             RC_PROTO_BIT_RC6_MCE |
5043                                             RC_PROTO_BIT_NEC,
5044                         .change_protocol  = dib0700_change_protocol,
5045                 },
5046         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5047                 .num_adapters = 1,
5048                 .adapter = {
5049                         {
5050                                 DIB0700_NUM_FRONTENDS(1),
5051                                 .fe = {{
5052                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5053                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5054                                         .pid_filter_count = 32,
5055                                         .pid_filter = stk80xx_pid_filter,
5056                                         .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5057                                         .frontend_attach  = tfe8096p_frontend_attach,
5058                                         .tuner_attach     = tfe8096p_tuner_attach,
5059 
5060                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5061 
5062                                 } },
5063                         },
5064                 },
5065 
5066                 .num_device_descs = 1,
5067                 .devices = {
5068                         {   "DiBcom TFE8096P reference design",
5069                                 { &dib0700_usb_id_table[79], NULL },
5070                                 { NULL },
5071                         },
5072                 },
5073 
5074                 .rc.core = {
5075                         .rc_interval      = DEFAULT_RC_INTERVAL,
5076                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5077                         .module_name      = "dib0700",
5078                         .rc_query         = dib0700_rc_query_old_firmware,
5079                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5080                                             RC_PROTO_BIT_RC6_MCE |
5081                                             RC_PROTO_BIT_NEC,
5082                         .change_protocol  = dib0700_change_protocol,
5083                 },
5084         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5085                 .num_adapters = 2,
5086                 .adapter = {
5087                         {
5088                                 .num_frontends = 1,
5089                                 .fe = {{
5090                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5091                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5092                                         .pid_filter_count = 32,
5093                                         .pid_filter = stk80xx_pid_filter,
5094                                         .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5095                                         .frontend_attach  = stk809x_frontend_attach,
5096                                         .tuner_attach     = dib809x_tuner_attach,
5097 
5098                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5099                                 } },
5100                                 .size_of_priv =
5101                                         sizeof(struct dib0700_adapter_state),
5102                         }, {
5103                                 .num_frontends = 1,
5104                                 .fe = { {
5105                                         .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5106                                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5107                                         .pid_filter_count = 32,
5108                                         .pid_filter = stk80xx_pid_filter,
5109                                         .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5110                                         .frontend_attach  = stk809x_frontend1_attach,
5111                                         .tuner_attach     = dib809x_tuner_attach,
5112 
5113                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5114                                 } },
5115                                 .size_of_priv =
5116                                         sizeof(struct dib0700_adapter_state),
5117                         },
5118                 },
5119                 .num_device_descs = 1,
5120                 .devices = {
5121                         {   "DiBcom STK8096-PVR reference design",
5122                                 { &dib0700_usb_id_table[83],
5123                                         &dib0700_usb_id_table[84], NULL},
5124                                 { NULL },
5125                         },
5126                 },
5127 
5128                 .rc.core = {
5129                         .rc_interval      = DEFAULT_RC_INTERVAL,
5130                         .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5131                         .module_name  = "dib0700",
5132                         .rc_query         = dib0700_rc_query_old_firmware,
5133                         .allowed_protos   = RC_PROTO_BIT_RC5 |
5134                                 RC_PROTO_BIT_RC6_MCE |
5135                                 RC_PROTO_BIT_NEC,
5136                         .change_protocol  = dib0700_change_protocol,
5137                 },
5138         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5139                 .num_adapters = 1,
5140                 .adapter = {
5141                         {
5142                                 DIB0700_NUM_FRONTENDS(1),
5143                                 .fe = {{
5144                                         .frontend_attach = xbox_one_attach,
5145 
5146                                         DIB0700_DEFAULT_STREAMING_CONFIG(0x82),
5147                                 } },
5148                         },
5149                 },
5150                 .num_device_descs = 1,
5151                 .devices = {
5152                         { "Microsoft Xbox One Digital TV Tuner",
5153                                 { &dib0700_usb_id_table[86], NULL },
5154                                 { NULL },
5155                         },
5156                 },
5157         },
5158 };
5159 
5160 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/media/usb/dvb-usb/dib0700_devices.c

DEFINITIONS
