usb/dvb-usb/dib0700_devices.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
0003  *
0004  *  Copyright (C) 2005-9 DiBcom, SA et al
0005  */
0006 #include "dib0700.h"
0007
0008 #include "dib3000mc.h"
0009 #include "dib7000m.h"
0010 #include "dib7000p.h"
0011 #include "dib8000.h"
0012 #include "dib9000.h"
0013 #include "mt2060.h"
0014 #include "mt2266.h"
0015 #include "xc2028.h"
0016 #include "xc5000.h"
0017 #include "xc4000.h"
0018 #include "s5h1411.h"
0019 #include "dib0070.h"
0020 #include "dib0090.h"
0021 #include "lgdt3305.h"
0022 #include "mxl5007t.h"
0023 #include "mn88472.h"
0024 #include "tda18250.h"
0025
0026
0027 static int force_lna_activation;
0028 module_param(force_lna_activation, int, 0644);
0029 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifier(s) (LNA), if applicable for the device (default: 0=automatic/off).");
0030
0031 struct dib0700_adapter_state {
0032     int (*set_param_save) (struct dvb_frontend *);
0033     const struct firmware *frontend_firmware;
0034     struct dib7000p_ops dib7000p_ops;
0035     struct dib8000_ops dib8000_ops;
0036 };
0037
0038 /* Hauppauge Nova-T 500 (aka Bristol)
0039  *  has a LNA on GPIO0 which is enabled by setting 1 */
0040 static struct mt2060_config bristol_mt2060_config[2] = {
0041     {
0042         .i2c_address = 0x60,
0043         .clock_out   = 3,
0044     }, {
0045         .i2c_address = 0x61,
0046     }
0047 };
0048
0049
0050 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
0051     .band_caps = BAND_VHF | BAND_UHF,
0052     .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
0053
0054     .agc1_max = 42598,
0055     .agc1_min = 17694,
0056     .agc2_max = 45875,
0057     .agc2_min = 0,
0058
0059     .agc1_pt1 = 0,
0060     .agc1_pt2 = 59,
0061
0062     .agc1_slope1 = 0,
0063     .agc1_slope2 = 69,
0064
0065     .agc2_pt1 = 0,
0066     .agc2_pt2 = 59,
0067
0068     .agc2_slope1 = 111,
0069     .agc2_slope2 = 28,
0070 };
0071
0072 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
0073     {   .agc          = &bristol_dib3000p_mt2060_agc_config,
0074         .max_time     = 0x196,
0075         .ln_adc_level = 0x1cc7,
0076         .output_mpeg2_in_188_bytes = 1,
0077     },
0078     {   .agc          = &bristol_dib3000p_mt2060_agc_config,
0079         .max_time     = 0x196,
0080         .ln_adc_level = 0x1cc7,
0081         .output_mpeg2_in_188_bytes = 1,
0082     }
0083 };
0084
0085 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
0086 {
0087     struct dib0700_state *st = adap->dev->priv;
0088     if (adap->id == 0) {
0089         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
0090         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
0091         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
0092         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
0093
0094         if (force_lna_activation)
0095             dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
0096         else
0097             dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
0098
0099         if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
0100             dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
0101             return -ENODEV;
0102         }
0103     }
0104     st->mt2060_if1[adap->id] = 1220;
0105     return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
0106         (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
0107 }
0108
0109 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
0110 {
0111     struct i2c_msg msg[2] = {
0112         { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
0113         { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
0114     };
0115     if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
0116     return 0;
0117 }
0118
0119 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
0120 {
0121     struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
0122     struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
0123     s8 a;
0124     int if1=1220;
0125     if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
0126         adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
0127         if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
0128     }
0129     return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
0130               &bristol_mt2060_config[adap->id], if1) == NULL ?
0131               -ENODEV : 0;
0132 }
0133
0134 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
0135
0136 /* MT226x */
0137 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
0138     {
0139         BAND_UHF,
0140
0141         /* 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,
0142         * 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 */
0143         (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
0144         | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
0145
0146         1130,
0147         21,
0148
0149         0,
0150         118,
0151
0152         0,
0153         3530,
0154         1,
0155         0,
0156
0157         65535,
0158         33770,
0159         65535,
0160         23592,
0161
0162         0,
0163         62,
0164         255,
0165         64,
0166         64,
0167         132,
0168         192,
0169         80,
0170         80,
0171
0172         17,
0173         27,
0174         23,
0175         51,
0176
0177         1,
0178     }, {
0179         BAND_VHF | BAND_LBAND,
0180
0181         /* 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,
0182         * 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 */
0183         (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
0184         | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
0185
0186         2372,
0187         21,
0188
0189         0,
0190         118,
0191
0192         0,
0193         3530,
0194         1,
0195         0,
0196
0197         65535,
0198         0,
0199         65535,
0200         23592,
0201
0202         0,
0203         128,
0204         128,
0205         128,
0206         0,
0207         128,
0208         253,
0209         81,
0210         0,
0211
0212         17,
0213         27,
0214         23,
0215         51,
0216
0217         1,
0218     }
0219 };
0220
0221 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
0222     .internal = 60000,
0223     .sampling = 30000,
0224     .pll_prediv = 1,
0225     .pll_ratio = 8,
0226     .pll_range = 3,
0227     .pll_reset = 1,
0228     .pll_bypass = 0,
0229     .enable_refdiv = 0,
0230     .bypclk_div = 0,
0231     .IO_CLK_en_core = 1,
0232     .ADClkSrc = 1,
0233     .modulo = 2,
0234     .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
0235     .ifreq = 0,
0236     .timf = 20452225,
0237 };
0238
0239 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
0240     {   .output_mpeg2_in_188_bytes = 1,
0241         .hostbus_diversity = 1,
0242         .tuner_is_baseband = 1,
0243
0244         .agc_config_count = 2,
0245         .agc = stk7700d_7000p_mt2266_agc_config,
0246         .bw  = &stk7700d_mt2266_pll_config,
0247
0248         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
0249         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
0250         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
0251     },
0252     {   .output_mpeg2_in_188_bytes = 1,
0253         .hostbus_diversity = 1,
0254         .tuner_is_baseband = 1,
0255
0256         .agc_config_count = 2,
0257         .agc = stk7700d_7000p_mt2266_agc_config,
0258         .bw  = &stk7700d_mt2266_pll_config,
0259
0260         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
0261         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
0262         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
0263     }
0264 };
0265
0266 static struct mt2266_config stk7700d_mt2266_config[2] = {
0267     {   .i2c_address = 0x60
0268     },
0269     {   .i2c_address = 0x60
0270     }
0271 };
0272
0273 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
0274 {
0275     struct dib0700_adapter_state *state = adap->priv;
0276
0277     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
0278         return -ENODEV;
0279
0280     if (adap->id == 0) {
0281         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
0282         msleep(10);
0283         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
0284         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
0285         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
0286         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
0287         msleep(10);
0288         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
0289         msleep(10);
0290         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
0291                          stk7700d_dib7000p_mt2266_config)
0292             != 0) {
0293             err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
0294             dvb_detach(state->dib7000p_ops.set_wbd_ref);
0295             return -ENODEV;
0296         }
0297     }
0298
0299     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
0300                0x80 + (adap->id << 1),
0301                &stk7700d_dib7000p_mt2266_config[adap->id]);
0302
0303     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
0304 }
0305
0306 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
0307 {
0308     struct dib0700_adapter_state *state = adap->priv;
0309
0310     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
0311         return -ENODEV;
0312
0313     if (adap->id == 0) {
0314         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
0315         msleep(10);
0316         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
0317         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
0318         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
0319         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
0320         msleep(10);
0321         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
0322         msleep(10);
0323         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
0324         if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
0325                          stk7700d_dib7000p_mt2266_config)
0326             != 0) {
0327             err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
0328             dvb_detach(state->dib7000p_ops.set_wbd_ref);
0329             return -ENODEV;
0330         }
0331     }
0332
0333     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
0334                0x80 + (adap->id << 1),
0335                &stk7700d_dib7000p_mt2266_config[adap->id]);
0336
0337     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
0338 }
0339
0340 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
0341 {
0342     struct i2c_adapter *tun_i2c;
0343     struct dib0700_adapter_state *state = adap->priv;
0344
0345     tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
0346                         DIBX000_I2C_INTERFACE_TUNER, 1);
0347     return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
0348         &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
0349 }
0350
0351 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
0352 static struct dibx000_agc_config xc3028_agc_config = {
0353     .band_caps = BAND_VHF | BAND_UHF,
0354     /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
0355      * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
0356      * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
0357     .setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
0358     .inv_gain = 712,
0359     .time_stabiliz = 21,
0360     .alpha_level = 0,
0361     .thlock = 118,
0362     .wbd_inv = 0,
0363     .wbd_ref = 2867,
0364     .wbd_sel = 0,
0365     .wbd_alpha = 2,
0366     .agc1_max = 0,
0367     .agc1_min = 0,
0368     .agc2_max = 39718,
0369     .agc2_min = 9930,
0370     .agc1_pt1 = 0,
0371     .agc1_pt2 = 0,
0372     .agc1_pt3 = 0,
0373     .agc1_slope1 = 0,
0374     .agc1_slope2 = 0,
0375     .agc2_pt1 = 0,
0376     .agc2_pt2 = 128,
0377     .agc2_slope1 = 29,
0378     .agc2_slope2 = 29,
0379     .alpha_mant = 17,
0380     .alpha_exp = 27,
0381     .beta_mant = 23,
0382     .beta_exp = 51,
0383     .perform_agc_softsplit = 1,
0384 };
0385
0386 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
0387 static struct dibx000_bandwidth_config xc3028_bw_config = {
0388     .internal = 60000,
0389     .sampling = 30000,
0390     .pll_prediv = 1,
0391     .pll_ratio = 8,
0392     .pll_range = 3,
0393     .pll_reset = 1,
0394     .pll_bypass = 0,
0395     .enable_refdiv = 0,
0396     .bypclk_div = 0,
0397     .IO_CLK_en_core = 1,
0398     .ADClkSrc = 1,
0399     .modulo = 0,
0400     .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
0401     .ifreq = (1 << 25) | 5816102,  /* ifreq = 5.200000 MHz */
0402     .timf = 20452225,
0403     .xtal_hz = 30000000,
0404 };
0405
0406 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
0407     .output_mpeg2_in_188_bytes = 1,
0408     .tuner_is_baseband = 1,
0409
0410     .agc_config_count = 1,
0411     .agc = &xc3028_agc_config,
0412     .bw  = &xc3028_bw_config,
0413
0414     .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
0415     .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
0416     .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
0417 };
0418
0419 static int stk7700ph_xc3028_callback(void *ptr, int component,
0420                      int command, int arg)
0421 {
0422     struct dvb_usb_adapter *adap = ptr;
0423     struct dib0700_adapter_state *state = adap->priv;
0424
0425     switch (command) {
0426     case XC2028_TUNER_RESET:
0427         /* Send the tuner in then out of reset */
0428         state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
0429         msleep(10);
0430         state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
0431         break;
0432     case XC2028_RESET_CLK:
0433     case XC2028_I2C_FLUSH:
0434         break;
0435     default:
0436         err("%s: unknown command %d, arg %d\n", __func__,
0437             command, arg);
0438         return -EINVAL;
0439     }
0440     return 0;
0441 }
0442
0443 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
0444     .fname = XC2028_DEFAULT_FIRMWARE,
0445     .max_len = 64,
0446     .demod = XC3028_FE_DIBCOM52,
0447 };
0448
0449 static struct xc2028_config stk7700ph_xc3028_config = {
0450     .i2c_addr = 0x61,
0451     .ctrl = &stk7700ph_xc3028_ctrl,
0452 };
0453
0454 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
0455 {
0456     struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
0457     struct dib0700_adapter_state *state = adap->priv;
0458
0459     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
0460         return -ENODEV;
0461
0462     if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
0463         desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
0464         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
0465     else
0466         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
0467     msleep(20);
0468     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
0469     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
0470     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
0471     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
0472     msleep(10);
0473     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
0474     msleep(20);
0475     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
0476     msleep(10);
0477
0478     if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
0479                      &stk7700ph_dib7700_xc3028_config) != 0) {
0480         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
0481             __func__);
0482         dvb_detach(state->dib7000p_ops.set_wbd_ref);
0483         return -ENODEV;
0484     }
0485
0486     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
0487         &stk7700ph_dib7700_xc3028_config);
0488
0489     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
0490 }
0491
0492 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
0493 {
0494     struct i2c_adapter *tun_i2c;
0495     struct dib0700_adapter_state *state = adap->priv;
0496
0497     tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
0498         DIBX000_I2C_INTERFACE_TUNER, 1);
0499
0500     stk7700ph_xc3028_config.i2c_adap = tun_i2c;
0501
0502     /* FIXME: generalize & move to common area */
0503     adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
0504
0505     return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
0506         == NULL ? -ENODEV : 0;
0507 }
0508
0509 #define DEFAULT_RC_INTERVAL 50
0510
0511 /*
0512  * This function is used only when firmware is < 1.20 version. Newer
0513  * firmwares use bulk mode, with functions implemented at dib0700_core,
0514  * at dib0700_rc_urb_completion()
0515  */
0516 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
0517 {
0518     enum rc_proto protocol;
0519     u32 scancode;
0520     u8 toggle;
0521     int i;
0522     struct dib0700_state *st = d->priv;
0523
0524     if (st->fw_version >= 0x10200) {
0525         /* For 1.20 firmware , We need to keep the RC polling
0526            callback so we can reuse the input device setup in
0527            dvb-usb-remote.c.  However, the actual work is being done
0528            in the bulk URB completion handler. */
0529         return 0;
0530     }
0531
0532     st->buf[0] = REQUEST_POLL_RC;
0533     st->buf[1] = 0;
0534
0535     i = dib0700_ctrl_rd(d, st->buf, 2, st->buf, 4);
0536     if (i <= 0) {
0537         err("RC Query Failed");
0538         return -EIO;
0539     }
0540
0541     /* losing half of KEY_0 events from Philipps rc5 remotes.. */
0542     if (st->buf[0] == 0 && st->buf[1] == 0
0543         && st->buf[2] == 0 && st->buf[3] == 0)
0544         return 0;
0545
0546     /* 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]);  */
0547
0548     dib0700_rc_setup(d, NULL); /* reset ir sensor data to prevent false events */
0549
0550     switch (d->props.rc.core.protocol) {
0551     case RC_PROTO_BIT_NEC:
0552         /* NEC protocol sends repeat code as 0 0 0 FF */
0553         if ((st->buf[3 - 2] == 0x00) && (st->buf[3 - 3] == 0x00) &&
0554             (st->buf[3] == 0xff)) {
0555             rc_repeat(d->rc_dev);
0556             return 0;
0557         }
0558
0559         protocol = RC_PROTO_NEC;
0560         scancode = RC_SCANCODE_NEC(st->buf[3 - 2], st->buf[3 - 3]);
0561         toggle = 0;
0562         break;
0563
0564     default:
0565         /* RC-5 protocol changes toggle bit on new keypress */
0566         protocol = RC_PROTO_RC5;
0567         scancode = RC_SCANCODE_RC5(st->buf[3 - 2], st->buf[3 - 3]);
0568         toggle = st->buf[3 - 1];
0569         break;
0570     }
0571
0572     rc_keydown(d->rc_dev, protocol, scancode, toggle);
0573     return 0;
0574 }
0575
0576 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
0577 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
0578     BAND_UHF | BAND_VHF,
0579
0580     /* 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,
0581      * 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 */
0582     (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
0583     | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
0584
0585     712,
0586     41,
0587
0588     0,
0589     118,
0590
0591     0,
0592     4095,
0593     0,
0594     0,
0595
0596     42598,
0597     17694,
0598     45875,
0599     2621,
0600     0,
0601     76,
0602     139,
0603     52,
0604     59,
0605     107,
0606     172,
0607     57,
0608     70,
0609
0610     21,
0611     25,
0612     28,
0613     48,
0614
0615     1,
0616     {  0,
0617        107,
0618        51800,
0619        24700
0620     },
0621 };
0622
0623 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
0624     .band_caps = BAND_UHF | BAND_VHF,
0625     /* 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,
0626      * 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 */
0627     .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
0628     .inv_gain = 712,
0629     .time_stabiliz = 41,
0630     .alpha_level = 0,
0631     .thlock = 118,
0632     .wbd_inv = 0,
0633     .wbd_ref = 4095,
0634     .wbd_sel = 0,
0635     .wbd_alpha = 0,
0636     .agc1_max = 42598,
0637     .agc1_min = 16384,
0638     .agc2_max = 42598,
0639     .agc2_min = 0,
0640     .agc1_pt1 = 0,
0641     .agc1_pt2 = 137,
0642     .agc1_pt3 = 255,
0643     .agc1_slope1 = 0,
0644     .agc1_slope2 = 255,
0645     .agc2_pt1 = 0,
0646     .agc2_pt2 = 0,
0647     .agc2_slope1 = 0,
0648     .agc2_slope2 = 41,
0649     .alpha_mant = 15,
0650     .alpha_exp = 25,
0651     .beta_mant = 28,
0652     .beta_exp = 48,
0653     .perform_agc_softsplit = 0,
0654 };
0655
0656 static struct dibx000_bandwidth_config stk7700p_pll_config = {
0657     .internal = 60000,
0658     .sampling = 30000,
0659     .pll_prediv = 1,
0660     .pll_ratio = 8,
0661     .pll_range = 3,
0662     .pll_reset = 1,
0663     .pll_bypass = 0,
0664     .enable_refdiv = 0,
0665     .bypclk_div = 0,
0666     .IO_CLK_en_core = 1,
0667     .ADClkSrc = 1,
0668     .modulo = 0,
0669     .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
0670     .ifreq = 60258167,
0671     .timf = 20452225,
0672     .xtal_hz = 30000000,
0673 };
0674
0675 static struct dib7000m_config stk7700p_dib7000m_config = {
0676     .dvbt_mode = 1,
0677     .output_mpeg2_in_188_bytes = 1,
0678     .quartz_direct = 1,
0679
0680     .agc_config_count = 1,
0681     .agc = &stk7700p_7000m_mt2060_agc_config,
0682     .bw  = &stk7700p_pll_config,
0683
0684     .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
0685     .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
0686     .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
0687 };
0688
0689 static struct dib7000p_config stk7700p_dib7000p_config = {
0690     .output_mpeg2_in_188_bytes = 1,
0691
0692     .agc_config_count = 1,
0693     .agc = &stk7700p_7000p_mt2060_agc_config,
0694     .bw  = &stk7700p_pll_config,
0695
0696     .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
0697     .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
0698     .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
0699 };
0700
0701 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
0702 {
0703     struct dib0700_state *st = adap->dev->priv;
0704     struct dib0700_adapter_state *state = adap->priv;
0705
0706     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
0707         return -ENODEV;
0708
0709     /* unless there is no real power management in DVB - we leave the device on GPIO6 */
0710
0711     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
0712     dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
0713
0714     dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
0715     dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
0716
0717     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
0718     dib0700_ctrl_clock(adap->dev, 72, 1);
0719     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
0720
0721     dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
0722
0723     st->mt2060_if1[0] = 1220;
0724
0725     if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) {
0726         adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
0727         st->is_dib7000pc = 1;
0728     } else {
0729         memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops));
0730         adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
0731     }
0732
0733     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
0734 }
0735
0736 static struct mt2060_config stk7700p_mt2060_config = {
0737     0x60
0738 };
0739
0740 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
0741 {
0742     struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
0743     struct dib0700_state *st = adap->dev->priv;
0744     struct i2c_adapter *tun_i2c;
0745     struct dib0700_adapter_state *state = adap->priv;
0746     s8 a;
0747     int if1=1220;
0748
0749     if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
0750         adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
0751         if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
0752     }
0753     if (st->is_dib7000pc)
0754         tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
0755     else
0756         tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
0757
0758     return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
0759         if1) == NULL ? -ENODEV : 0;
0760 }
0761
0762 /* DIB7070 generic */
0763 static struct dibx000_agc_config dib7070_agc_config = {
0764     .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
0765     /* 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,
0766      * 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 */
0767     .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
0768     .inv_gain = 600,
0769     .time_stabiliz = 10,
0770     .alpha_level = 0,
0771     .thlock = 118,
0772     .wbd_inv = 0,
0773     .wbd_ref = 3530,
0774     .wbd_sel = 1,
0775     .wbd_alpha = 5,
0776     .agc1_max = 65535,
0777     .agc1_min = 0,
0778     .agc2_max = 65535,
0779     .agc2_min = 0,
0780     .agc1_pt1 = 0,
0781     .agc1_pt2 = 40,
0782     .agc1_pt3 = 183,
0783     .agc1_slope1 = 206,
0784     .agc1_slope2 = 255,
0785     .agc2_pt1 = 72,
0786     .agc2_pt2 = 152,
0787     .agc2_slope1 = 88,
0788     .agc2_slope2 = 90,
0789     .alpha_mant = 17,
0790     .alpha_exp = 27,
0791     .beta_mant = 23,
0792     .beta_exp = 51,
0793     .perform_agc_softsplit = 0,
0794 };
0795
0796 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
0797 {
0798     struct dvb_usb_adapter *adap = fe->dvb->priv;
0799     struct dib0700_adapter_state *state = adap->priv;
0800
0801     deb_info("reset: %d", onoff);
0802     return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
0803 }
0804
0805 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
0806 {
0807     struct dvb_usb_adapter *adap = fe->dvb->priv;
0808     struct dib0700_adapter_state *state = adap->priv;
0809
0810     deb_info("sleep: %d", onoff);
0811     return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff);
0812 }
0813
0814 static struct dib0070_config dib7070p_dib0070_config[2] = {
0815     {
0816         .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
0817         .reset = dib7070_tuner_reset,
0818         .sleep = dib7070_tuner_sleep,
0819         .clock_khz = 12000,
0820         .clock_pad_drive = 4,
0821         .charge_pump = 2,
0822     }, {
0823         .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
0824         .reset = dib7070_tuner_reset,
0825         .sleep = dib7070_tuner_sleep,
0826         .clock_khz = 12000,
0827         .charge_pump = 2,
0828     }
0829 };
0830
0831 static struct dib0070_config dib7770p_dib0070_config = {
0832      .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
0833      .reset = dib7070_tuner_reset,
0834      .sleep = dib7070_tuner_sleep,
0835      .clock_khz = 12000,
0836      .clock_pad_drive = 0,
0837      .flip_chip = 1,
0838      .charge_pump = 2,
0839 };
0840
0841 static int dib7070_set_param_override(struct dvb_frontend *fe)
0842 {
0843     struct dtv_frontend_properties *p = &fe->dtv_property_cache;
0844     struct dvb_usb_adapter *adap = fe->dvb->priv;
0845     struct dib0700_adapter_state *state = adap->priv;
0846
0847     u16 offset;
0848     u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
0849     switch (band) {
0850         case BAND_VHF: offset = 950; break;
0851         case BAND_UHF:
0852         default: offset = 550; break;
0853     }
0854     deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
0855     state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
0856     return state->set_param_save(fe);
0857 }
0858
0859 static int dib7770_set_param_override(struct dvb_frontend *fe)
0860 {
0861     struct dtv_frontend_properties *p = &fe->dtv_property_cache;
0862     struct dvb_usb_adapter *adap = fe->dvb->priv;
0863     struct dib0700_adapter_state *state = adap->priv;
0864
0865     u16 offset;
0866     u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
0867     switch (band) {
0868     case BAND_VHF:
0869         state->dib7000p_ops.set_gpio(fe, 0, 0, 1);
0870         offset = 850;
0871         break;
0872     case BAND_UHF:
0873     default:
0874         state->dib7000p_ops.set_gpio(fe, 0, 0, 0);
0875         offset = 250;
0876         break;
0877     }
0878     deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
0879     state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
0880     return state->set_param_save(fe);
0881 }
0882
0883 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
0884 {
0885     struct dib0700_adapter_state *st = adap->priv;
0886     struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
0887              DIBX000_I2C_INTERFACE_TUNER, 1);
0888
0889     if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
0890                &dib7770p_dib0070_config) == NULL)
0891         return -ENODEV;
0892
0893     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
0894     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
0895     return 0;
0896 }
0897
0898 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
0899 {
0900     struct dib0700_adapter_state *st = adap->priv;
0901     struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
0902
0903     if (adap->id == 0) {
0904         if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
0905             return -ENODEV;
0906     } else {
0907         if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
0908             return -ENODEV;
0909     }
0910
0911     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
0912     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
0913     return 0;
0914 }
0915
0916 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
0917         u16 pid, int onoff)
0918 {
0919     struct dib0700_adapter_state *state = adapter->priv;
0920     struct dib0700_state *st = adapter->dev->priv;
0921
0922     if (st->is_dib7000pc)
0923         return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
0924     return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
0925 }
0926
0927 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
0928 {
0929     struct dib0700_state *st = adapter->dev->priv;
0930     struct dib0700_adapter_state *state = adapter->priv;
0931     if (st->is_dib7000pc)
0932         return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
0933     return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
0934 }
0935
0936 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
0937 {
0938     struct dib0700_adapter_state *state = adapter->priv;
0939     return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
0940 }
0941
0942 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
0943 {
0944     struct dib0700_adapter_state *state = adapter->priv;
0945     return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
0946 }
0947
0948 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
0949     .internal = 60000,
0950     .sampling = 15000,
0951     .pll_prediv = 1,
0952     .pll_ratio = 20,
0953     .pll_range = 3,
0954     .pll_reset = 1,
0955     .pll_bypass = 0,
0956     .enable_refdiv = 0,
0957     .bypclk_div = 0,
0958     .IO_CLK_en_core = 1,
0959     .ADClkSrc = 1,
0960     .modulo = 2,
0961     .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
0962     .ifreq = (0 << 25) | 0,
0963     .timf = 20452225,
0964     .xtal_hz = 12000000,
0965 };
0966
0967 static struct dib7000p_config dib7070p_dib7000p_config = {
0968     .output_mpeg2_in_188_bytes = 1,
0969
0970     .agc_config_count = 1,
0971     .agc = &dib7070_agc_config,
0972     .bw  = &dib7070_bw_config_12_mhz,
0973     .tuner_is_baseband = 1,
0974     .spur_protect = 1,
0975
0976     .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
0977     .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
0978     .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
0979
0980     .hostbus_diversity = 1,
0981 };
0982
0983 /* STK7070P */
0984 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
0985 {
0986     struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
0987     struct dib0700_adapter_state *state = adap->priv;
0988
0989     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
0990         return -ENODEV;
0991
0992     if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
0993         p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
0994         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
0995     else
0996         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
0997     msleep(10);
0998     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
0999     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         fallthrough;
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     /* FIXME: if adap->id != 0, check if it is fe_adap[1] */
1742     if (!dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config))
1743         return -ENODEV;
1744
1745     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1746     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1747     return 0;
1748 }
1749
1750 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1751 {
1752     struct dib0700_adapter_state *state = adap->priv;
1753
1754     if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1755         return -ENODEV;
1756
1757     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1758     msleep(10);
1759     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1760     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1761     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1762
1763     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1764
1765     dib0700_ctrl_clock(adap->dev, 72, 1);
1766
1767     msleep(10);
1768     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1769     msleep(10);
1770     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1771
1772     state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1773
1774     adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1775
1776     return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1777 }
1778
1779 static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap)
1780 {
1781     struct dib0700_adapter_state *state = adap->priv;
1782
1783     if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1784         return -ENODEV;
1785
1786     state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0);
1787
1788     adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1789
1790     return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
1791 }
1792
1793 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1794 {
1795     struct dib0700_adapter_state *st = adap->priv;
1796     struct i2c_adapter *tun_i2c;
1797     struct dvb_frontend *fe_slave  = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
1798
1799     if (fe_slave) {
1800         tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1801         if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1802             return -ENODEV;
1803         fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1804         fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1805     }
1806     tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1807     if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1808         return -ENODEV;
1809
1810     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1811     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1812
1813     return 0;
1814 }
1815
1816 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1817 {
1818     struct dvb_frontend *fe_slave;
1819     struct dib0700_adapter_state *state = adap->priv;
1820
1821     if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1822         return -ENODEV;
1823
1824     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1825     msleep(20);
1826     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1827     msleep(1000);
1828     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1829     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1830     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1831
1832     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1833
1834     dib0700_ctrl_clock(adap->dev, 72, 1);
1835
1836     msleep(20);
1837     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1838     msleep(20);
1839     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1840
1841     state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1842
1843     adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1844     if (adap->fe_adap[0].fe == NULL)
1845         return -ENODEV;
1846
1847     /* Needed to increment refcount */
1848     if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1849         return -ENODEV;
1850
1851     fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1852     state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1853
1854     return fe_slave == NULL ?  -ENODEV : 0;
1855 }
1856
1857 /* TFE8096P */
1858 static struct dibx000_agc_config dib8096p_agc_config[2] = {
1859     {
1860         .band_caps      = BAND_UHF,
1861         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1862            P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1863            P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1864            P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1865            P_agc_write=0 */
1866         .setup          = (0 << 15) | (0 << 14) | (5 << 11)
1867             | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1868             | (0 << 4) | (5 << 1) | (0 << 0),
1869
1870         .inv_gain       = 684,
1871         .time_stabiliz  = 10,
1872
1873         .alpha_level    = 0,
1874         .thlock         = 118,
1875
1876         .wbd_inv        = 0,
1877         .wbd_ref        = 1200,
1878         .wbd_sel        = 3,
1879         .wbd_alpha      = 5,
1880
1881         .agc1_max       = 65535,
1882         .agc1_min       = 0,
1883
1884         .agc2_max       = 32767,
1885         .agc2_min       = 0,
1886
1887         .agc1_pt1       = 0,
1888         .agc1_pt2       = 0,
1889         .agc1_pt3       = 105,
1890         .agc1_slope1    = 0,
1891         .agc1_slope2    = 156,
1892         .agc2_pt1       = 105,
1893         .agc2_pt2       = 255,
1894         .agc2_slope1    = 54,
1895         .agc2_slope2    = 0,
1896
1897         .alpha_mant     = 28,
1898         .alpha_exp      = 26,
1899         .beta_mant      = 31,
1900         .beta_exp       = 51,
1901
1902         .perform_agc_softsplit = 0,
1903     } , {
1904         .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
1905         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1906            P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1907            P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1908            P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1909            P_agc_write=0 */
1910         .setup          = (0 << 15) | (0 << 14) | (5 << 11)
1911             | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1912             | (0 << 4) | (5 << 1) | (0 << 0),
1913
1914         .inv_gain       = 732,
1915         .time_stabiliz  = 10,
1916
1917         .alpha_level    = 0,
1918         .thlock         = 118,
1919
1920         .wbd_inv        = 0,
1921         .wbd_ref        = 1200,
1922         .wbd_sel        = 3,
1923         .wbd_alpha      = 5,
1924
1925         .agc1_max       = 65535,
1926         .agc1_min       = 0,
1927
1928         .agc2_max       = 32767,
1929         .agc2_min       = 0,
1930
1931         .agc1_pt1       = 0,
1932         .agc1_pt2       = 0,
1933         .agc1_pt3       = 98,
1934         .agc1_slope1    = 0,
1935         .agc1_slope2    = 167,
1936         .agc2_pt1       = 98,
1937         .agc2_pt2       = 255,
1938         .agc2_slope1    = 52,
1939         .agc2_slope2    = 0,
1940
1941         .alpha_mant     = 28,
1942         .alpha_exp      = 26,
1943         .beta_mant      = 31,
1944         .beta_exp       = 51,
1945
1946         .perform_agc_softsplit = 0,
1947     }
1948 };
1949
1950 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1951     .internal = 108000,
1952     .sampling = 13500,
1953     .pll_prediv = 1,
1954     .pll_ratio = 9,
1955     .pll_range = 1,
1956     .pll_reset = 0,
1957     .pll_bypass = 0,
1958     .enable_refdiv = 0,
1959     .bypclk_div = 0,
1960     .IO_CLK_en_core = 0,
1961     .ADClkSrc = 0,
1962     .modulo = 2,
1963     .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1964     .ifreq = (0 << 25) | 0,
1965     .timf = 20199729,
1966     .xtal_hz = 12000000,
1967 };
1968
1969 static struct dib8000_config tfe8096p_dib8000_config = {
1970     .output_mpeg2_in_188_bytes  = 1,
1971     .hostbus_diversity          = 1,
1972     .update_lna                 = NULL,
1973
1974     .agc_config_count           = 2,
1975     .agc                        = dib8096p_agc_config,
1976     .pll                        = &dib8096p_clock_config_12_mhz,
1977
1978     .gpio_dir                   = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1979     .gpio_val                   = DIB8000_GPIO_DEFAULT_VALUES,
1980     .gpio_pwm_pos               = DIB8000_GPIO_DEFAULT_PWM_POS,
1981
1982     .agc_control                = NULL,
1983     .diversity_delay            = 48,
1984     .output_mode                = OUTMODE_MPEG2_FIFO,
1985     .enMpegOutput               = 1,
1986 };
1987
1988 static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1989     { 380, 81, 850, 64, 540, 4},
1990     { 860, 51, 866, 21, 375, 4},
1991     {1700, 0, 250, 0, 100, 6},
1992     {2600, 0, 250, 0, 100, 6},
1993     { 0xFFFF, 0, 0, 0, 0, 0},
1994 };
1995
1996 static struct dib0090_config tfe8096p_dib0090_config = {
1997     .io.clock_khz           = 12000,
1998     .io.pll_bypass          = 0,
1999     .io.pll_range           = 0,
2000     .io.pll_prediv          = 3,
2001     .io.pll_loopdiv         = 6,
2002     .io.adc_clock_ratio     = 0,
2003     .io.pll_int_loop_filt   = 0,
2004
2005     .freq_offset_khz_uhf    = -143,
2006     .freq_offset_khz_vhf    = -143,
2007
2008     .get_adc_power          = dib8090_get_adc_power,
2009
2010     .clkouttobamse          = 1,
2011     .analog_output          = 0,
2012
2013     .wbd_vhf_offset         = 0,
2014     .wbd_cband_offset       = 0,
2015     .use_pwm_agc            = 1,
2016     .clkoutdrive            = 0,
2017
2018     .fref_clock_ratio       = 1,
2019
2020     .ls_cfg_pad_drv         = 0,
2021     .data_tx_drv            = 0,
2022     .low_if                 = NULL,
2023     .in_soc                 = 1,
2024     .force_cband_input      = 0,
2025 };
2026
2027 struct dibx090p_adc {
2028     u32 freq;           /* RF freq MHz */
2029     u32 timf;           /* New Timf */
2030     u32 pll_loopdiv;    /* New prediv */
2031     u32 pll_prediv;     /* New loopdiv */
2032 };
2033
2034 struct dibx090p_best_adc {
2035     u32 timf;
2036     u32 pll_loopdiv;
2037     u32 pll_prediv;
2038 };
2039
2040 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
2041 {
2042     u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2043     u16 xtal = 12000;
2044     u16 fcp_min = 1900;  /* PLL, Minimum Frequency of phase comparator (KHz) */
2045     u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */
2046     u32 fmem_max = 140000; /* 140MHz max SDRAM freq */
2047     u32 fdem_min = 66000;
2048     u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
2049     u32 harmonic_id = 0;
2050
2051     adc->timf = 0;
2052     adc->pll_loopdiv = loopdiv;
2053     adc->pll_prediv = prediv;
2054
2055     deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
2056
2057     /* Find Min and Max prediv */
2058     while ((xtal / max_prediv) >= fcp_min)
2059         max_prediv++;
2060
2061     max_prediv--;
2062     min_prediv = max_prediv;
2063     while ((xtal / min_prediv) <= fcp_max) {
2064         min_prediv--;
2065         if (min_prediv == 1)
2066             break;
2067     }
2068     deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2069
2070     min_prediv = 1;
2071
2072     for (prediv = min_prediv; prediv < max_prediv; prediv++) {
2073         fcp = xtal / prediv;
2074         if (fcp > fcp_min && fcp < fcp_max) {
2075             for (loopdiv = 1; loopdiv < 64; loopdiv++) {
2076                 fmem = ((xtal/prediv) * loopdiv);
2077                 fdem = fmem / 2;
2078                 fs   = fdem / 4;
2079
2080                 /* test min/max system restrictions */
2081                 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
2082                     spur = 0;
2083                     /* test fs harmonics positions */
2084                     for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs));  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
2085                         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)))) {
2086                             spur = 1;
2087                             break;
2088                         }
2089                     }
2090
2091                     if (!spur) {
2092                         adc->pll_loopdiv = loopdiv;
2093                         adc->pll_prediv = prediv;
2094                         adc->timf = (4260880253U / fdem) * (1 << 8);
2095                         adc->timf += ((4260880253U % fdem) << 8) / fdem;
2096
2097                         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);
2098                         break;
2099                     }
2100                 }
2101             }
2102         }
2103         if (!spur)
2104             break;
2105     }
2106
2107     if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2108         return -EINVAL;
2109     return 0;
2110 }
2111
2112 static int dib8096p_agc_startup(struct dvb_frontend *fe)
2113 {
2114     struct dvb_usb_adapter *adap = fe->dvb->priv;
2115     struct dib0700_adapter_state *state = adap->priv;
2116     struct dibx000_bandwidth_config pll;
2117     struct dibx090p_best_adc adc;
2118     u16 target;
2119     int ret;
2120
2121     ret = state->set_param_save(fe);
2122     if (ret < 0)
2123         return ret;
2124     memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2125
2126     dib0090_pwm_gain_reset(fe);
2127     /* dib0090_get_wbd_target is returning any possible
2128        temperature compensated wbd-target */
2129     target = (dib0090_get_wbd_target(fe) * 8  + 1) / 2;
2130     state->dib8000_ops.set_wbd_ref(fe, target);
2131
2132     if (dib8096p_get_best_sampling(fe, &adc) == 0) {
2133         pll.pll_ratio  = adc.pll_loopdiv;
2134         pll.pll_prediv = adc.pll_prediv;
2135
2136         dib0700_set_i2c_speed(adap->dev, 200);
2137         state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
2138         state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2139         dib0700_set_i2c_speed(adap->dev, 1000);
2140     }
2141     return 0;
2142 }
2143
2144 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2145 {
2146     struct dib0700_state *st = adap->dev->priv;
2147     u32 fw_version;
2148     struct dib0700_adapter_state *state = adap->priv;
2149
2150     if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
2151         return -ENODEV;
2152
2153     dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2154     if (fw_version >= 0x10200)
2155         st->fw_use_new_i2c_api = 1;
2156
2157     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2158     msleep(20);
2159     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2160     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2161     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2162
2163     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2164
2165     dib0700_ctrl_clock(adap->dev, 72, 1);
2166
2167     msleep(20);
2168     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2169     msleep(20);
2170     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2171
2172     state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2173
2174     adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
2175                          0x80, &tfe8096p_dib8000_config);
2176
2177     return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2178 }
2179
2180 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2181 {
2182     struct dib0700_adapter_state *st = adap->priv;
2183     struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
2184
2185     tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
2186     tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
2187     tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
2188
2189     if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2190                 &tfe8096p_dib0090_config) == NULL)
2191         return -ENODEV;
2192
2193     st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2194
2195     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2196     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2197     return 0;
2198 }
2199
2200 /* STK9090M */
2201 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2202 {
2203     return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2204 }
2205
2206 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2207 {
2208     return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2209 }
2210
2211 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2212 {
2213     return dib9000_set_gpio(fe, 5, 0, !onoff);
2214 }
2215
2216 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2217 {
2218     return dib9000_set_gpio(fe, 0, 0, onoff);
2219 }
2220
2221 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2222 {
2223     u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2224     u8 rb[2];
2225     struct i2c_msg msg[2] = {
2226         {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2227         {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2228     };
2229     u8 index_data;
2230
2231     dibx000_i2c_set_speed(i2c, 250);
2232
2233     if (i2c_transfer(i2c, msg, 2) != 2)
2234         return -EIO;
2235
2236     switch (rb[0] << 8 | rb[1]) {
2237     case 0:
2238             deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2239             return -EIO;
2240     case 1:
2241             deb_info("Found DiB0170 rev2");
2242             break;
2243     case 2:
2244             deb_info("Found DiB0190 rev2");
2245             break;
2246     default:
2247             deb_info("DiB01x0 not found");
2248             return -EIO;
2249     }
2250
2251     for (index_data = 0; index_data < len; index_data += 2) {
2252         wb[2] = (data[index_data + 1] >> 8) & 0xff;
2253         wb[3] = (data[index_data + 1]) & 0xff;
2254
2255         if (data[index_data] == 0) {
2256             wb[0] = (data[index_data] >> 8) & 0xff;
2257             wb[1] = (data[index_data]) & 0xff;
2258             msg[0].len = 2;
2259             if (i2c_transfer(i2c, msg, 2) != 2)
2260                 return -EIO;
2261             wb[2] |= rb[0];
2262             wb[3] |= rb[1] & ~(3 << 4);
2263         }
2264
2265         wb[0] = (data[index_data] >> 8)&0xff;
2266         wb[1] = (data[index_data])&0xff;
2267         msg[0].len = 4;
2268         if (i2c_transfer(i2c, &msg[0], 1) != 1)
2269             return -EIO;
2270     }
2271     return 0;
2272 }
2273
2274 static struct dib9000_config stk9090m_config = {
2275     .output_mpeg2_in_188_bytes = 1,
2276     .output_mode = OUTMODE_MPEG2_FIFO,
2277     .vcxo_timer = 279620,
2278     .timing_frequency = 20452225,
2279     .demod_clock_khz = 60000,
2280     .xtal_clock_khz = 30000,
2281     .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2282     .subband = {
2283         2,
2284         {
2285             { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
2286             { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
2287             { 0 },
2288         },
2289     },
2290     .gpio_function = {
2291         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2292         { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2293     },
2294 };
2295
2296 static struct dib9000_config nim9090md_config[2] = {
2297     {
2298         .output_mpeg2_in_188_bytes = 1,
2299         .output_mode = OUTMODE_MPEG2_FIFO,
2300         .vcxo_timer = 279620,
2301         .timing_frequency = 20452225,
2302         .demod_clock_khz = 60000,
2303         .xtal_clock_khz = 30000,
2304         .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2305     }, {
2306         .output_mpeg2_in_188_bytes = 1,
2307         .output_mode = OUTMODE_DIVERSITY,
2308         .vcxo_timer = 279620,
2309         .timing_frequency = 20452225,
2310         .demod_clock_khz = 60000,
2311         .xtal_clock_khz = 30000,
2312         .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2313         .subband = {
2314             2,
2315             {
2316                 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2317                 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2318                 { 0 },
2319             },
2320         },
2321         .gpio_function = {
2322             { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2323             { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2324         },
2325     }
2326 };
2327
2328 static struct dib0090_config dib9090_dib0090_config = {
2329     .io.pll_bypass = 0,
2330     .io.pll_range = 1,
2331     .io.pll_prediv = 1,
2332     .io.pll_loopdiv = 8,
2333     .io.adc_clock_ratio = 8,
2334     .io.pll_int_loop_filt = 0,
2335     .io.clock_khz = 30000,
2336     .reset = dib90x0_tuner_reset,
2337     .sleep = dib90x0_tuner_sleep,
2338     .clkouttobamse = 0,
2339     .analog_output = 0,
2340     .use_pwm_agc = 0,
2341     .clkoutdrive = 0,
2342     .freq_offset_khz_uhf = 0,
2343     .freq_offset_khz_vhf = 0,
2344 };
2345
2346 static struct dib0090_config nim9090md_dib0090_config[2] = {
2347     {
2348         .io.pll_bypass = 0,
2349         .io.pll_range = 1,
2350         .io.pll_prediv = 1,
2351         .io.pll_loopdiv = 8,
2352         .io.adc_clock_ratio = 8,
2353         .io.pll_int_loop_filt = 0,
2354         .io.clock_khz = 30000,
2355         .reset = dib90x0_tuner_reset,
2356         .sleep = dib90x0_tuner_sleep,
2357         .clkouttobamse = 1,
2358         .analog_output = 0,
2359         .use_pwm_agc = 0,
2360         .clkoutdrive = 0,
2361         .freq_offset_khz_uhf = 0,
2362         .freq_offset_khz_vhf = 0,
2363     }, {
2364         .io.pll_bypass = 0,
2365         .io.pll_range = 1,
2366         .io.pll_prediv = 1,
2367         .io.pll_loopdiv = 8,
2368         .io.adc_clock_ratio = 8,
2369         .io.pll_int_loop_filt = 0,
2370         .io.clock_khz = 30000,
2371         .reset = dib90x0_tuner_reset,
2372         .sleep = dib90x0_tuner_sleep,
2373         .clkouttobamse = 0,
2374         .analog_output = 0,
2375         .use_pwm_agc = 0,
2376         .clkoutdrive = 0,
2377         .freq_offset_khz_uhf = 0,
2378         .freq_offset_khz_vhf = 0,
2379     }
2380 };
2381
2382
2383 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2384 {
2385     struct dib0700_adapter_state *state = adap->priv;
2386     struct dib0700_state *st = adap->dev->priv;
2387     u32 fw_version;
2388
2389     /* Make use of the new i2c functions from FW 1.20 */
2390     dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2391     if (fw_version >= 0x10200)
2392         st->fw_use_new_i2c_api = 1;
2393     dib0700_set_i2c_speed(adap->dev, 340);
2394
2395     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2396     msleep(20);
2397     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2398     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2399     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2400     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2401
2402     dib0700_ctrl_clock(adap->dev, 72, 1);
2403
2404     msleep(20);
2405     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2406     msleep(20);
2407     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2408
2409     dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2410
2411     if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2412         deb_info("%s: Upload failed. (file not found?)\n", __func__);
2413         return -ENODEV;
2414     } else {
2415         deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2416     }
2417     stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2418     stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2419
2420     adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2421
2422     return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2423 }
2424
2425 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2426 {
2427     struct dib0700_adapter_state *state = adap->priv;
2428     struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2429     u16 data_dib190[10] = {
2430         1, 0x1374,
2431         2, 0x01a2,
2432         7, 0x0020,
2433         0, 0x00ef,
2434         8, 0x0486,
2435     };
2436
2437     if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2438         return -ENODEV;
2439     if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2440         return -ENODEV;
2441     i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2442     if (!i2c)
2443         return -ENODEV;
2444     if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2445         return -ENODEV;
2446     dib0700_set_i2c_speed(adap->dev, 1500);
2447     if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2448         return -ENODEV;
2449     release_firmware(state->frontend_firmware);
2450     return 0;
2451 }
2452
2453 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2454 {
2455     struct dib0700_adapter_state *state = adap->priv;
2456     struct dib0700_state *st = adap->dev->priv;
2457     struct i2c_adapter *i2c;
2458     struct dvb_frontend *fe_slave;
2459     u32 fw_version;
2460
2461     /* Make use of the new i2c functions from FW 1.20 */
2462     dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2463     if (fw_version >= 0x10200)
2464         st->fw_use_new_i2c_api = 1;
2465     dib0700_set_i2c_speed(adap->dev, 340);
2466
2467     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2468     msleep(20);
2469     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2470     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2471     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2472     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2473
2474     dib0700_ctrl_clock(adap->dev, 72, 1);
2475
2476     msleep(20);
2477     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2478     msleep(20);
2479     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2480
2481     if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2482         deb_info("%s: Upload failed. (file not found?)\n", __func__);
2483         return -EIO;
2484     } else {
2485         deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2486     }
2487     nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2488     nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2489     nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2490     nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2491
2492     dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2493     adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2494
2495     if (adap->fe_adap[0].fe == NULL)
2496         return -ENODEV;
2497
2498     i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2499     dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2500
2501     fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2502     dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2503
2504     return fe_slave == NULL ?  -ENODEV : 0;
2505 }
2506
2507 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2508 {
2509     struct dib0700_adapter_state *state = adap->priv;
2510     struct i2c_adapter *i2c;
2511     struct dvb_frontend *fe_slave;
2512     u16 data_dib190[10] = {
2513         1, 0x5374,
2514         2, 0x01ae,
2515         7, 0x0020,
2516         0, 0x00ef,
2517         8, 0x0406,
2518     };
2519     if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2520         return -ENODEV;
2521     i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2522     if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2523         return -ENODEV;
2524     i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2525     if (!i2c)
2526         return -ENODEV;
2527     if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2528         return -ENODEV;
2529
2530     dib0700_set_i2c_speed(adap->dev, 1500);
2531     if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2532         return -ENODEV;
2533
2534     fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2535     if (fe_slave != NULL) {
2536         i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2537         dib9000_set_i2c_adapter(fe_slave, i2c);
2538
2539         i2c = dib9000_get_tuner_interface(fe_slave);
2540         if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2541             return -ENODEV;
2542         fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2543         dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2544         if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2545             return -ENODEV;
2546     }
2547     release_firmware(state->frontend_firmware);
2548
2549     return 0;
2550 }
2551
2552 /* NIM7090 */
2553 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dibx090p_best_adc *adc)
2554 {
2555     u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2556
2557     u16 xtal = 12000;
2558     u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
2559     u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2560     u32 fdem_max = 76000;
2561     u32 fdem_min = 69500;
2562     u32 fcp = 0, fs = 0, fdem = 0;
2563     u32 harmonic_id = 0;
2564
2565     adc->pll_loopdiv = loopdiv;
2566     adc->pll_prediv = prediv;
2567     adc->timf = 0;
2568
2569     deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2570
2571     /* Find Min and Max prediv */
2572     while ((xtal/max_prediv) >= fcp_min)
2573         max_prediv++;
2574
2575     max_prediv--;
2576     min_prediv = max_prediv;
2577     while ((xtal/min_prediv) <= fcp_max) {
2578         min_prediv--;
2579         if (min_prediv == 1)
2580             break;
2581     }
2582     deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2583
2584     min_prediv = 2;
2585
2586     for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2587         fcp = xtal / prediv;
2588         if (fcp > fcp_min && fcp < fcp_max) {
2589             for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2590                 fdem = ((xtal/prediv) * loopdiv);
2591                 fs   = fdem / 4;
2592                 /* test min/max system restrictions */
2593
2594                 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2595                     spur = 0;
2596                     /* test fs harmonics positions */
2597                     for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2598                         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)))) {
2599                             spur = 1;
2600                             break;
2601                         }
2602                     }
2603
2604                     if (!spur) {
2605                         adc->pll_loopdiv = loopdiv;
2606                         adc->pll_prediv = prediv;
2607                         adc->timf = 2396745143UL/fdem*(1 << 9);
2608                         adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2609                         deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2610                         break;
2611                     }
2612                 }
2613             }
2614         }
2615         if (!spur)
2616             break;
2617     }
2618
2619
2620     if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2621         return -EINVAL;
2622     else
2623         return 0;
2624 }
2625
2626 static int dib7090_agc_startup(struct dvb_frontend *fe)
2627 {
2628     struct dvb_usb_adapter *adap = fe->dvb->priv;
2629     struct dib0700_adapter_state *state = adap->priv;
2630     struct dibx000_bandwidth_config pll;
2631     u16 target;
2632     struct dibx090p_best_adc adc;
2633     int ret;
2634
2635     ret = state->set_param_save(fe);
2636     if (ret < 0)
2637         return ret;
2638
2639     memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2640     dib0090_pwm_gain_reset(fe);
2641     target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2642     state->dib7000p_ops.set_wbd_ref(fe, target);
2643
2644     if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2645         pll.pll_ratio  = adc.pll_loopdiv;
2646         pll.pll_prediv = adc.pll_prediv;
2647
2648         state->dib7000p_ops.update_pll(fe, &pll);
2649         state->dib7000p_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2650     }
2651     return 0;
2652 }
2653
2654 static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2655 {
2656     deb_info("AGC restart callback: %d", restart);
2657     if (restart == 0) /* before AGC startup */
2658         dib0090_set_dc_servo(fe, 1);
2659     return 0;
2660 }
2661
2662 static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
2663 {
2664     struct dvb_usb_adapter *adap = fe->dvb->priv;
2665     struct dib0700_adapter_state *state = adap->priv;
2666
2667     deb_info("update LNA: agc global=%i", agc_global);
2668
2669     if (agc_global < 25000) {
2670         state->dib7000p_ops.set_gpio(fe, 8, 0, 0);
2671         state->dib7000p_ops.set_agc1_min(fe, 0);
2672     } else {
2673         state->dib7000p_ops.set_gpio(fe, 8, 0, 1);
2674         state->dib7000p_ops.set_agc1_min(fe, 32768);
2675     }
2676
2677     return 0;
2678 }
2679
2680 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2681     { 380,   81, 850, 64, 540,  4},
2682     { 860,   51, 866, 21,  375, 4},
2683     {1700,    0, 250, 0,   100, 6},
2684     {2600,    0, 250, 0,   100, 6},
2685     { 0xFFFF, 0,   0, 0,   0,   0},
2686 };
2687
2688 static struct dibx000_agc_config dib7090_agc_config[2] = {
2689     {
2690         .band_caps      = BAND_UHF,
2691         /* 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,
2692         * 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 */
2693         .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2694
2695         .inv_gain       = 687,
2696         .time_stabiliz  = 10,
2697
2698         .alpha_level    = 0,
2699         .thlock         = 118,
2700
2701         .wbd_inv        = 0,
2702         .wbd_ref        = 1200,
2703         .wbd_sel        = 3,
2704         .wbd_alpha      = 5,
2705
2706         .agc1_max       = 65535,
2707         .agc1_min       = 32768,
2708
2709         .agc2_max       = 65535,
2710         .agc2_min       = 0,
2711
2712         .agc1_pt1       = 0,
2713         .agc1_pt2       = 32,
2714         .agc1_pt3       = 114,
2715         .agc1_slope1    = 143,
2716         .agc1_slope2    = 144,
2717         .agc2_pt1       = 114,
2718         .agc2_pt2       = 227,
2719         .agc2_slope1    = 116,
2720         .agc2_slope2    = 117,
2721
2722         .alpha_mant     = 18,
2723         .alpha_exp      = 0,
2724         .beta_mant      = 20,
2725         .beta_exp       = 59,
2726
2727         .perform_agc_softsplit = 0,
2728     } , {
2729         .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
2730         /* 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,
2731         * 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 */
2732         .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2733
2734         .inv_gain       = 732,
2735         .time_stabiliz  = 10,
2736
2737         .alpha_level    = 0,
2738         .thlock         = 118,
2739
2740         .wbd_inv        = 0,
2741         .wbd_ref        = 1200,
2742         .wbd_sel        = 3,
2743         .wbd_alpha      = 5,
2744
2745         .agc1_max       = 65535,
2746         .agc1_min       = 0,
2747
2748         .agc2_max       = 65535,
2749         .agc2_min       = 0,
2750
2751         .agc1_pt1       = 0,
2752         .agc1_pt2       = 0,
2753         .agc1_pt3       = 98,
2754         .agc1_slope1    = 0,
2755         .agc1_slope2    = 167,
2756         .agc2_pt1       = 98,
2757         .agc2_pt2       = 255,
2758         .agc2_slope1    = 104,
2759         .agc2_slope2    = 0,
2760
2761         .alpha_mant     = 18,
2762         .alpha_exp      = 0,
2763         .beta_mant      = 20,
2764         .beta_exp       = 59,
2765
2766         .perform_agc_softsplit = 0,
2767     }
2768 };
2769
2770 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2771     .internal = 60000,
2772     .sampling = 15000,
2773     .pll_prediv = 1,
2774     .pll_ratio = 5,
2775     .pll_range = 0,
2776     .pll_reset = 0,
2777     .pll_bypass = 0,
2778     .enable_refdiv = 0,
2779     .bypclk_div = 0,
2780     .IO_CLK_en_core = 1,
2781     .ADClkSrc = 1,
2782     .modulo = 2,
2783     .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
2784     .ifreq = (0 << 25) | 0,
2785     .timf = 20452225,
2786     .xtal_hz = 15000000,
2787 };
2788
2789 static struct dib7000p_config nim7090_dib7000p_config = {
2790     .output_mpeg2_in_188_bytes  = 1,
2791     .hostbus_diversity          = 1,
2792     .tuner_is_baseband          = 1,
2793     .update_lna                 = tfe7790p_update_lna, /* GPIO used is the same as TFE7790 */
2794
2795     .agc_config_count           = 2,
2796     .agc                        = dib7090_agc_config,
2797
2798     .bw                         = &dib7090_clock_config_12_mhz,
2799
2800     .gpio_dir                   = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2801     .gpio_val                   = DIB7000P_GPIO_DEFAULT_VALUES,
2802     .gpio_pwm_pos               = DIB7000P_GPIO_DEFAULT_PWM_POS,
2803
2804     .pwm_freq_div               = 0,
2805
2806     .agc_control                = dib7090_agc_restart,
2807
2808     .spur_protect               = 0,
2809     .disable_sample_and_hold    = 0,
2810     .enable_current_mirror      = 0,
2811     .diversity_delay            = 0,
2812
2813     .output_mode                = OUTMODE_MPEG2_FIFO,
2814     .enMpegOutput               = 1,
2815 };
2816
2817 static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
2818 {
2819     struct dvb_usb_adapter *adap = fe->dvb->priv;
2820     struct dib0700_adapter_state *state = adap->priv;
2821
2822     deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
2823     if (agc_global < 25000) {
2824         state->dib7000p_ops.set_gpio(fe, 5, 0, 0);
2825         state->dib7000p_ops.set_agc1_min(fe, 0);
2826     } else {
2827         state->dib7000p_ops.set_gpio(fe, 5, 0, 1);
2828         state->dib7000p_ops.set_agc1_min(fe, 32768);
2829     }
2830
2831     return 0;
2832 }
2833
2834 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2835     {
2836         .output_mpeg2_in_188_bytes  = 1,
2837         .hostbus_diversity          = 1,
2838         .tuner_is_baseband          = 1,
2839         .update_lna                 = tfe7090p_pvr_update_lna,
2840
2841         .agc_config_count           = 2,
2842         .agc                        = dib7090_agc_config,
2843
2844         .bw                         = &dib7090_clock_config_12_mhz,
2845
2846         .gpio_dir                   = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2847         .gpio_val                   = DIB7000P_GPIO_DEFAULT_VALUES,
2848         .gpio_pwm_pos               = DIB7000P_GPIO_DEFAULT_PWM_POS,
2849
2850         .pwm_freq_div               = 0,
2851
2852         .agc_control                = dib7090_agc_restart,
2853
2854         .spur_protect               = 0,
2855         .disable_sample_and_hold    = 0,
2856         .enable_current_mirror      = 0,
2857         .diversity_delay            = 0,
2858
2859         .output_mode                = OUTMODE_MPEG2_PAR_GATED_CLK,
2860         .default_i2c_addr           = 0x90,
2861         .enMpegOutput               = 1,
2862     }, {
2863         .output_mpeg2_in_188_bytes  = 1,
2864         .hostbus_diversity          = 1,
2865         .tuner_is_baseband          = 1,
2866         .update_lna                 = tfe7090p_pvr_update_lna,
2867
2868         .agc_config_count           = 2,
2869         .agc                        = dib7090_agc_config,
2870
2871         .bw                         = &dib7090_clock_config_12_mhz,
2872
2873         .gpio_dir                   = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2874         .gpio_val                   = DIB7000P_GPIO_DEFAULT_VALUES,
2875         .gpio_pwm_pos               = DIB7000P_GPIO_DEFAULT_PWM_POS,
2876
2877         .pwm_freq_div               = 0,
2878
2879         .agc_control                = dib7090_agc_restart,
2880
2881         .spur_protect               = 0,
2882         .disable_sample_and_hold    = 0,
2883         .enable_current_mirror      = 0,
2884         .diversity_delay            = 0,
2885
2886         .output_mode                = OUTMODE_MPEG2_PAR_GATED_CLK,
2887         .default_i2c_addr           = 0x92,
2888         .enMpegOutput               = 0,
2889     }
2890 };
2891
2892 static struct dib0090_config nim7090_dib0090_config = {
2893     .io.clock_khz = 12000,
2894     .io.pll_bypass = 0,
2895     .io.pll_range = 0,
2896     .io.pll_prediv = 3,
2897     .io.pll_loopdiv = 6,
2898     .io.adc_clock_ratio = 0,
2899     .io.pll_int_loop_filt = 0,
2900
2901     .freq_offset_khz_uhf = 0,
2902     .freq_offset_khz_vhf = 0,
2903
2904     .clkouttobamse = 1,
2905     .analog_output = 0,
2906
2907     .wbd_vhf_offset = 0,
2908     .wbd_cband_offset = 0,
2909     .use_pwm_agc = 1,
2910     .clkoutdrive = 0,
2911
2912     .fref_clock_ratio = 0,
2913
2914     .wbd = dib7090_wbd_table,
2915
2916     .ls_cfg_pad_drv = 0,
2917     .data_tx_drv = 0,
2918     .low_if = NULL,
2919     .in_soc = 1,
2920 };
2921
2922 static struct dib7000p_config tfe7790p_dib7000p_config = {
2923     .output_mpeg2_in_188_bytes  = 1,
2924     .hostbus_diversity          = 1,
2925     .tuner_is_baseband          = 1,
2926     .update_lna                 = tfe7790p_update_lna,
2927
2928     .agc_config_count           = 2,
2929     .agc                        = dib7090_agc_config,
2930
2931     .bw                         = &dib7090_clock_config_12_mhz,
2932
2933     .gpio_dir                   = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2934     .gpio_val                   = DIB7000P_GPIO_DEFAULT_VALUES,
2935     .gpio_pwm_pos               = DIB7000P_GPIO_DEFAULT_PWM_POS,
2936
2937     .pwm_freq_div               = 0,
2938
2939     .agc_control                = dib7090_agc_restart,
2940
2941     .spur_protect               = 0,
2942     .disable_sample_and_hold    = 0,
2943     .enable_current_mirror      = 0,
2944     .diversity_delay            = 0,
2945
2946     .output_mode                = OUTMODE_MPEG2_PAR_GATED_CLK,
2947     .enMpegOutput               = 1,
2948 };
2949
2950 static struct dib0090_config tfe7790p_dib0090_config = {
2951     .io.clock_khz = 12000,
2952     .io.pll_bypass = 0,
2953     .io.pll_range = 0,
2954     .io.pll_prediv = 3,
2955     .io.pll_loopdiv = 6,
2956     .io.adc_clock_ratio = 0,
2957     .io.pll_int_loop_filt = 0,
2958
2959     .freq_offset_khz_uhf = 0,
2960     .freq_offset_khz_vhf = 0,
2961
2962     .clkouttobamse = 1,
2963     .analog_output = 0,
2964
2965     .wbd_vhf_offset = 0,
2966     .wbd_cband_offset = 0,
2967     .use_pwm_agc = 1,
2968     .clkoutdrive = 0,
2969
2970     .fref_clock_ratio = 0,
2971
2972     .wbd = dib7090_wbd_table,
2973
2974     .ls_cfg_pad_drv = 0,
2975     .data_tx_drv = 0,
2976     .low_if = NULL,
2977     .in_soc = 1,
2978     .force_cband_input = 0,
2979     .is_dib7090e = 0,
2980     .force_crystal_mode = 1,
2981 };
2982
2983 static struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2984     {
2985         .io.clock_khz = 12000,
2986         .io.pll_bypass = 0,
2987         .io.pll_range = 0,
2988         .io.pll_prediv = 3,
2989         .io.pll_loopdiv = 6,
2990         .io.adc_clock_ratio = 0,
2991         .io.pll_int_loop_filt = 0,
2992
2993         .freq_offset_khz_uhf = 50,
2994         .freq_offset_khz_vhf = 70,
2995
2996         .clkouttobamse = 1,
2997         .analog_output = 0,
2998
2999         .wbd_vhf_offset = 0,
3000         .wbd_cband_offset = 0,
3001         .use_pwm_agc = 1,
3002         .clkoutdrive = 0,
3003
3004         .fref_clock_ratio = 0,
3005
3006         .wbd = dib7090_wbd_table,
3007
3008         .ls_cfg_pad_drv = 0,
3009         .data_tx_drv = 0,
3010         .low_if = NULL,
3011         .in_soc = 1,
3012     }, {
3013         .io.clock_khz = 12000,
3014         .io.pll_bypass = 0,
3015         .io.pll_range = 0,
3016         .io.pll_prediv = 3,
3017         .io.pll_loopdiv = 6,
3018         .io.adc_clock_ratio = 0,
3019         .io.pll_int_loop_filt = 0,
3020
3021         .freq_offset_khz_uhf = -50,
3022         .freq_offset_khz_vhf = -70,
3023
3024         .clkouttobamse = 1,
3025         .analog_output = 0,
3026
3027         .wbd_vhf_offset = 0,
3028         .wbd_cband_offset = 0,
3029         .use_pwm_agc = 1,
3030         .clkoutdrive = 0,
3031
3032         .fref_clock_ratio = 0,
3033
3034         .wbd = dib7090_wbd_table,
3035
3036         .ls_cfg_pad_drv = 0,
3037         .data_tx_drv = 0,
3038         .low_if = NULL,
3039         .in_soc = 1,
3040     }
3041 };
3042
3043 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
3044 {
3045     struct dib0700_adapter_state *state = adap->priv;
3046
3047     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3048         return -ENODEV;
3049
3050     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3051     msleep(20);
3052     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3053     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3054     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3055     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3056
3057     msleep(20);
3058     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3059     msleep(20);
3060     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3061
3062     if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
3063         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3064         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3065         return -ENODEV;
3066     }
3067     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
3068
3069     return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3070 }
3071
3072 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
3073 {
3074     struct dib0700_adapter_state *st = adap->priv;
3075     struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3076
3077     nim7090_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3078     nim7090_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3079     nim7090_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3080
3081     if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
3082         return -ENODEV;
3083
3084     st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3085
3086     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3087     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3088     return 0;
3089 }
3090
3091 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
3092 {
3093     struct dib0700_state *st = adap->dev->priv;
3094     struct dib0700_adapter_state *state = adap->priv;
3095
3096     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3097         return -ENODEV;
3098
3099     /* The TFE7090 requires the dib0700 to not be in master mode */
3100     st->disable_streaming_master_mode = 1;
3101
3102     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3103     msleep(20);
3104     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3105     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3106     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3107     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3108
3109     msleep(20);
3110     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3111     msleep(20);
3112     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3113
3114     /* initialize IC 0 */
3115     if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
3116         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3117         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3118         return -ENODEV;
3119     }
3120
3121     dib0700_set_i2c_speed(adap->dev, 340);
3122     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
3123     if (adap->fe_adap[0].fe == NULL)
3124         return -ENODEV;
3125
3126     state->dib7000p_ops.slave_reset(adap->fe_adap[0].fe);
3127
3128     return 0;
3129 }
3130
3131 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
3132 {
3133     struct i2c_adapter *i2c;
3134     struct dib0700_adapter_state *state = adap->priv;
3135
3136     if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
3137         err("the master dib7090 has to be initialized first");
3138         return -ENODEV; /* the master device has not been initialized */
3139     }
3140
3141     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3142         return -ENODEV;
3143
3144     i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
3145     if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
3146         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3147         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3148         return -ENODEV;
3149     }
3150
3151     adap->fe_adap[0].fe = state->dib7000p_ops.init(i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
3152     dib0700_set_i2c_speed(adap->dev, 200);
3153
3154     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3155 }
3156
3157 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
3158 {
3159     struct dib0700_adapter_state *st = adap->priv;
3160     struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3161
3162     tfe7090pvr_dib0090_config[0].reset = st->dib7000p_ops.tuner_sleep;
3163     tfe7090pvr_dib0090_config[0].sleep = st->dib7000p_ops.tuner_sleep;
3164     tfe7090pvr_dib0090_config[0].get_adc_power = st->dib7000p_ops.get_adc_power;
3165
3166     if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
3167         return -ENODEV;
3168
3169     st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3170
3171     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3172     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3173     return 0;
3174 }
3175
3176 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
3177 {
3178     struct dib0700_adapter_state *st = adap->priv;
3179     struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3180
3181     tfe7090pvr_dib0090_config[1].reset = st->dib7000p_ops.tuner_sleep;
3182     tfe7090pvr_dib0090_config[1].sleep = st->dib7000p_ops.tuner_sleep;
3183     tfe7090pvr_dib0090_config[1].get_adc_power = st->dib7000p_ops.get_adc_power;
3184
3185     if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
3186         return -ENODEV;
3187
3188     st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3189
3190     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3191     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3192     return 0;
3193 }
3194
3195 static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
3196 {
3197     struct dib0700_state *st = adap->dev->priv;
3198     struct dib0700_adapter_state *state = adap->priv;
3199
3200     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3201         return -ENODEV;
3202
3203     /* The TFE7790P requires the dib0700 to not be in master mode */
3204     st->disable_streaming_master_mode = 1;
3205
3206     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3207     msleep(20);
3208     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3209     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3210     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3211     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3212     msleep(20);
3213     dib0700_ctrl_clock(adap->dev, 72, 1);
3214     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3215     msleep(20);
3216     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3217
3218     if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap,
3219                 1, 0x10, &tfe7790p_dib7000p_config) != 0) {
3220         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3221                 __func__);
3222         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3223         return -ENODEV;
3224     }
3225     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
3226             0x80, &tfe7790p_dib7000p_config);
3227
3228     return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3229 }
3230
3231 static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
3232 {
3233     struct dib0700_adapter_state *st = adap->priv;
3234     struct i2c_adapter *tun_i2c =
3235         st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3236
3237
3238     tfe7790p_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3239     tfe7790p_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3240     tfe7790p_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3241
3242     if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3243                 &tfe7790p_dib0090_config) == NULL)
3244         return -ENODEV;
3245
3246     st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3247
3248     st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3249     adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3250     return 0;
3251 }
3252
3253 /* STK7070PD */
3254 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3255     {
3256         .output_mpeg2_in_188_bytes = 1,
3257
3258         .agc_config_count = 1,
3259         .agc = &dib7070_agc_config,
3260         .bw  = &dib7070_bw_config_12_mhz,
3261         .tuner_is_baseband = 1,
3262         .spur_protect = 1,
3263
3264         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3265         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3266         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3267
3268         .hostbus_diversity = 1,
3269     }, {
3270         .output_mpeg2_in_188_bytes = 1,
3271
3272         .agc_config_count = 1,
3273         .agc = &dib7070_agc_config,
3274         .bw  = &dib7070_bw_config_12_mhz,
3275         .tuner_is_baseband = 1,
3276         .spur_protect = 1,
3277
3278         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3279         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3280         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3281
3282         .hostbus_diversity = 1,
3283     }
3284 };
3285
3286 static void stk7070pd_init(struct dvb_usb_device *dev)
3287 {
3288     dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3289     msleep(10);
3290     dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3291     dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3292     dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3293     dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3294
3295     dib0700_ctrl_clock(dev, 72, 1);
3296
3297     msleep(10);
3298     dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3299 }
3300
3301 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3302 {
3303     struct dib0700_adapter_state *state = adap->priv;
3304
3305     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3306         return -ENODEV;
3307
3308     stk7070pd_init(adap->dev);
3309
3310     msleep(10);
3311     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3312
3313     if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3314                      stk7070pd_dib7000p_config) != 0) {
3315         err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3316             __func__);
3317         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3318         return -ENODEV;
3319     }
3320
3321     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3322     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3323 }
3324
3325 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3326 {
3327     struct dib0700_adapter_state *state = adap->priv;
3328
3329     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3330         return -ENODEV;
3331
3332     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3333     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3334 }
3335
3336 static int novatd_read_status_override(struct dvb_frontend *fe,
3337                        enum fe_status *stat)
3338 {
3339     struct dvb_usb_adapter *adap = fe->dvb->priv;
3340     struct dvb_usb_device *dev = adap->dev;
3341     struct dib0700_state *state = dev->priv;
3342     int ret;
3343
3344     ret = state->read_status(fe, stat);
3345
3346     if (!ret)
3347         dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3348                 !!(*stat & FE_HAS_LOCK));
3349
3350     return ret;
3351 }
3352
3353 static int novatd_sleep_override(struct dvb_frontend* fe)
3354 {
3355     struct dvb_usb_adapter *adap = fe->dvb->priv;
3356     struct dvb_usb_device *dev = adap->dev;
3357     struct dib0700_state *state = dev->priv;
3358
3359     /* turn off LED */
3360     dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3361
3362     return state->sleep(fe);
3363 }
3364
3365 /*
3366  * novatd_frontend_attach - Nova-TD specific attach
3367  *
3368  * Nova-TD has GPIO0, 1 and 2 for LEDs. So do not fiddle with them except for
3369  * information purposes.
3370  */
3371 static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3372 {
3373     struct dvb_usb_device *dev = adap->dev;
3374     struct dib0700_state *st = dev->priv;
3375     struct dib0700_adapter_state *state = adap->priv;
3376
3377     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3378         return -ENODEV;
3379
3380     if (adap->id == 0) {
3381         stk7070pd_init(dev);
3382
3383         /* turn the power LED on, the other two off (just in case) */
3384         dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3385         dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3386         dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3387
3388         if (state->dib7000p_ops.i2c_enumeration(&dev->i2c_adap, 2, 18,
3389                          stk7070pd_dib7000p_config) != 0) {
3390             err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3391                 __func__);
3392             dvb_detach(state->dib7000p_ops.set_wbd_ref);
3393             return -ENODEV;
3394         }
3395     }
3396
3397     adap->fe_adap[0].fe = state->dib7000p_ops.init(&dev->i2c_adap,
3398             adap->id == 0 ? 0x80 : 0x82,
3399             &stk7070pd_dib7000p_config[adap->id]);
3400
3401     if (adap->fe_adap[0].fe == NULL)
3402         return -ENODEV;
3403
3404     st->read_status = adap->fe_adap[0].fe->ops.read_status;
3405     adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3406     st->sleep = adap->fe_adap[0].fe->ops.sleep;
3407     adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3408
3409     return 0;
3410 }
3411
3412 /* S5H1411 */
3413 static struct s5h1411_config pinnacle_801e_config = {
3414     .output_mode   = S5H1411_PARALLEL_OUTPUT,
3415     .gpio          = S5H1411_GPIO_OFF,
3416     .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINUOUS_NONINVERTING_CLOCK,
3417     .qam_if        = S5H1411_IF_44000,
3418     .vsb_if        = S5H1411_IF_44000,
3419     .inversion     = S5H1411_INVERSION_OFF,
3420     .status_mode   = S5H1411_DEMODLOCKING
3421 };
3422
3423 /* Pinnacle PCTV HD Pro 801e GPIOs map:
3424    GPIO0  - currently unknown
3425    GPIO1  - xc5000 tuner reset
3426    GPIO2  - CX25843 sleep
3427    GPIO3  - currently unknown
3428    GPIO4  - currently unknown
3429    GPIO6  - currently unknown
3430    GPIO7  - currently unknown
3431    GPIO9  - currently unknown
3432    GPIO10 - CX25843 reset
3433  */
3434 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3435 {
3436     struct dib0700_state *st = adap->dev->priv;
3437
3438     /* Make use of the new i2c functions from FW 1.20 */
3439     st->fw_use_new_i2c_api = 1;
3440
3441     /* The s5h1411 requires the dib0700 to not be in master mode */
3442     st->disable_streaming_master_mode = 1;
3443
3444     /* All msleep values taken from Windows USB trace */
3445     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3446     dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3447     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3448     msleep(400);
3449     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3450     msleep(60);
3451     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3452     msleep(30);
3453     dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3454     dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3455     dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3456     dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3457     dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3458     msleep(30);
3459
3460     /* Put the CX25843 to sleep for now since we're in digital mode */
3461     dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3462
3463     /* GPIOs are initialized, do the attach */
3464     adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3465                   &adap->dev->i2c_adap);
3466     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3467 }
3468
3469 static int dib0700_xc5000_tuner_callback(void *priv, int component,
3470                      int command, int arg)
3471 {
3472     struct dvb_usb_adapter *adap = priv;
3473
3474     if (command == XC5000_TUNER_RESET) {
3475         /* Reset the tuner */
3476         dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3477         msleep(10);
3478         dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3479         msleep(10);
3480     } else {
3481         err("xc5000: unknown tuner callback command: %d\n", command);
3482         return -EINVAL;
3483     }
3484
3485     return 0;
3486 }
3487
3488 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3489     .i2c_address      = 0x64,
3490     .if_khz           = 5380,
3491 };
3492
3493 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3494 {
3495     /* FIXME: generalize & move to common area */
3496     adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3497
3498     return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3499               &s5h1411_xc5000_tunerconfig)
3500         == NULL ? -ENODEV : 0;
3501 }
3502
3503 static int dib0700_xc4000_tuner_callback(void *priv, int component,
3504                      int command, int arg)
3505 {
3506     struct dvb_usb_adapter *adap = priv;
3507     struct dib0700_adapter_state *state = adap->priv;
3508
3509     if (command == XC4000_TUNER_RESET) {
3510         /* Reset the tuner */
3511         state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3512         msleep(10);
3513         state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3514     } else {
3515         err("xc4000: unknown tuner callback command: %d\n", command);
3516         return -EINVAL;
3517     }
3518
3519     return 0;
3520 }
3521
3522 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3523     .band_caps = BAND_UHF | BAND_VHF,
3524     .setup = 0x64,
3525     .inv_gain = 0x02c8,
3526     .time_stabiliz = 0x15,
3527     .alpha_level = 0x00,
3528     .thlock = 0x76,
3529     .wbd_inv = 0x01,
3530     .wbd_ref = 0x0b33,
3531     .wbd_sel = 0x00,
3532     .wbd_alpha = 0x02,
3533     .agc1_max = 0x00,
3534     .agc1_min = 0x00,
3535     .agc2_max = 0x9b26,
3536     .agc2_min = 0x26ca,
3537     .agc1_pt1 = 0x00,
3538     .agc1_pt2 = 0x00,
3539     .agc1_pt3 = 0x00,
3540     .agc1_slope1 = 0x00,
3541     .agc1_slope2 = 0x00,
3542     .agc2_pt1 = 0x00,
3543     .agc2_pt2 = 0x80,
3544     .agc2_slope1 = 0x1d,
3545     .agc2_slope2 = 0x1d,
3546     .alpha_mant = 0x11,
3547     .alpha_exp = 0x1b,
3548     .beta_mant = 0x17,
3549     .beta_exp = 0x33,
3550     .perform_agc_softsplit = 0x00,
3551 };
3552
3553 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3554     .internal = 60000,
3555     .sampling = 30000,
3556     .pll_prediv = 1,
3557     .pll_ratio = 8,
3558     .pll_range = 3,
3559     .pll_reset = 1,
3560     .pll_bypass = 0,
3561     .enable_refdiv = 0,
3562     .bypclk_div = 0,
3563     .IO_CLK_en_core = 1,
3564     .ADClkSrc = 1,
3565     .modulo = 0,
3566     .sad_cfg = (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
3567     .ifreq = 39370534,
3568     .timf = 20452225,
3569     .xtal_hz = 30000000
3570 };
3571
3572 /* FIXME: none of these inputs are validated yet */
3573 static struct dib7000p_config pctv_340e_config = {
3574     .output_mpeg2_in_188_bytes = 1,
3575
3576     .agc_config_count = 1,
3577     .agc = &stk7700p_7000p_xc4000_agc_config,
3578     .bw  = &stk7700p_xc4000_pll_config,
3579
3580     .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3581     .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3582     .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3583 };
3584
3585 /* PCTV 340e GPIOs map:
3586    dib0700:
3587    GPIO2  - CX25843 sleep
3588    GPIO3  - CS5340 reset
3589    GPIO5  - IRD
3590    GPIO6  - Power Supply
3591    GPIO8  - LNA (1=off 0=on)
3592    GPIO10 - CX25843 reset
3593    dib7000:
3594    GPIO8  - xc4000 reset
3595  */
3596 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3597 {
3598     struct dib0700_state *st = adap->dev->priv;
3599     struct dib0700_adapter_state *state = adap->priv;
3600
3601     if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3602         return -ENODEV;
3603
3604     /* Power Supply on */
3605     dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
3606     msleep(50);
3607     dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1);
3608     msleep(100); /* Allow power supply to settle before probing */
3609
3610     /* cx25843 reset */
3611     dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 0);
3612     msleep(1); /* cx25843 datasheet say 350us required */
3613     dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 1);
3614
3615     /* LNA off for now */
3616     dib0700_set_gpio(adap->dev, GPIO8,  GPIO_OUT, 1);
3617
3618     /* Put the CX25843 to sleep for now since we're in digital mode */
3619     dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3620
3621     /* FIXME: not verified yet */
3622     dib0700_ctrl_clock(adap->dev, 72, 1);
3623
3624     msleep(500);
3625
3626     if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3627         /* Demodulator not found for some reason? */
3628         dvb_detach(state->dib7000p_ops.set_wbd_ref);
3629         return -ENODEV;
3630     }
3631
3632     adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x12,
3633                   &pctv_340e_config);
3634     st->is_dib7000pc = 1;
3635
3636     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3637 }
3638
3639 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3640     .i2c_address      = 0x61,
3641     .default_pm   = 1,
3642     .dvb_amplitude    = 0,
3643     .set_smoothedcvbs = 0,
3644     .if_khz       = 5400
3645 };
3646
3647 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3648 {
3649     struct i2c_adapter *tun_i2c;
3650     struct dib0700_adapter_state *state = adap->priv;
3651
3652     /* The xc4000 is not on the main i2c bus */
3653     tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
3654                       DIBX000_I2C_INTERFACE_TUNER, 1);
3655     if (tun_i2c == NULL) {
3656         printk(KERN_ERR "Could not reach tuner i2c bus\n");
3657         return 0;
3658     }
3659
3660     /* Setup the reset callback */
3661     adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3662
3663     return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3664               &dib7000p_xc4000_tunerconfig)
3665         == NULL ? -ENODEV : 0;
3666 }
3667
3668 static struct lgdt3305_config hcw_lgdt3305_config = {
3669     .i2c_addr           = 0x0e,
3670     .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
3671     .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
3672     .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
3673     .deny_i2c_rptr      = 0,
3674     .spectral_inversion = 1,
3675     .qam_if_khz         = 6000,
3676     .vsb_if_khz         = 6000,
3677     .usref_8vsb         = 0x0500,
3678 };
3679
3680 static struct mxl5007t_config hcw_mxl5007t_config = {
3681     .xtal_freq_hz = MxL_XTAL_25_MHZ,
3682     .if_freq_hz = MxL_IF_6_MHZ,
3683     .invert_if = 1,
3684 };
3685
3686 /* TIGER-ATSC map:
3687    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
3688    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
3689    GPIO4  - SCL2
3690    GPIO6  - EN_TUNER
3691    GPIO7  - SDA2
3692    GPIO10 - DEM_RST
3693
3694    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
3695  */
3696 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3697 {
3698     struct dib0700_state *st = adap->dev->priv;
3699
3700     /* Make use of the new i2c functions from FW 1.20 */
3701     st->fw_use_new_i2c_api = 1;
3702
3703     st->disable_streaming_master_mode = 1;
3704
3705     /* fe power enable */
3706     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3707     msleep(30);
3708     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3709     msleep(30);
3710
3711     /* demod reset */
3712     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3713     msleep(30);
3714     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3715     msleep(30);
3716     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3717     msleep(30);
3718
3719     adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3720                   &hcw_lgdt3305_config,
3721                   &adap->dev->i2c_adap);
3722
3723     return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3724 }
3725
3726 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3727 {
3728     return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3729               &adap->dev->i2c_adap, 0x60,
3730               &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3731 }
3732
3733 static int xbox_one_attach(struct dvb_usb_adapter *adap)
3734 {
3735     struct dib0700_state *st = adap->dev->priv;
3736     struct i2c_client *client_demod, *client_tuner;
3737     struct dvb_usb_device *d = adap->dev;
3738     struct mn88472_config mn88472_config = { };
3739     struct tda18250_config tda18250_config;
3740     struct i2c_board_info info;
3741
3742     st->fw_use_new_i2c_api = 1;
3743     st->disable_streaming_master_mode = 1;
3744
3745     /* fe power enable */
3746     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3747     msleep(30);
3748     dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3749     msleep(30);
3750
3751     /* demod reset */
3752     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3753     msleep(30);
3754     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3755     msleep(30);
3756     dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3757     msleep(30);
3758
3759     /* attach demod */
3760     mn88472_config.fe = &adap->fe_adap[0].fe;
3761     mn88472_config.i2c_wr_max = 22;
3762     mn88472_config.xtal = 20500000;
3763     mn88472_config.ts_mode = PARALLEL_TS_MODE;
3764     mn88472_config.ts_clock = FIXED_TS_CLOCK;
3765     memset(&info, 0, sizeof(struct i2c_board_info));
3766     strscpy(info.type, "mn88472", I2C_NAME_SIZE);
3767     info.addr = 0x18;
3768     info.platform_data = &mn88472_config;
3769     request_module(info.type);
3770     client_demod = i2c_new_client_device(&d->i2c_adap, &info);
3771     if (!i2c_client_has_driver(client_demod))
3772         goto fail_demod_device;
3773     if (!try_module_get(client_demod->dev.driver->owner))
3774         goto fail_demod_module;
3775
3776     st->i2c_client_demod = client_demod;
3777
3778     adap->fe_adap[0].fe = mn88472_config.get_dvb_frontend(client_demod);
3779
3780     /* attach tuner */
3781     memset(&tda18250_config, 0, sizeof(tda18250_config));
3782     tda18250_config.if_dvbt_6 = 3950;
3783     tda18250_config.if_dvbt_7 = 4450;
3784     tda18250_config.if_dvbt_8 = 4950;
3785     tda18250_config.if_dvbc_6 = 4950;
3786     tda18250_config.if_dvbc_8 = 4950;
3787     tda18250_config.if_atsc = 4079;
3788     tda18250_config.loopthrough = true;
3789     tda18250_config.xtal_freq = TDA18250_XTAL_FREQ_27MHZ;
3790     tda18250_config.fe = adap->fe_adap[0].fe;
3791
3792     memset(&info, 0, sizeof(struct i2c_board_info));
3793     strscpy(info.type, "tda18250", I2C_NAME_SIZE);
3794     info.addr = 0x60;
3795     info.platform_data = &tda18250_config;
3796
3797     request_module(info.type);
3798     client_tuner = i2c_new_client_device(&adap->dev->i2c_adap, &info);
3799     if (!i2c_client_has_driver(client_tuner))
3800         goto fail_tuner_device;
3801     if (!try_module_get(client_tuner->dev.driver->owner))
3802         goto fail_tuner_module;
3803
3804     st->i2c_client_tuner = client_tuner;
3805     return 0;
3806
3807 fail_tuner_module:
3808     i2c_unregister_device(client_tuner);
3809 fail_tuner_device:
3810     module_put(client_demod->dev.driver->owner);
3811 fail_demod_module:
3812     i2c_unregister_device(client_demod);
3813 fail_demod_device:
3814     return -ENODEV;
3815 }
3816
3817
3818 /* DVB-USB and USB stuff follows */
3819 enum {
3820     DIBCOM_STK7700P,
3821     DIBCOM_STK7700P_PC,
3822     HAUPPAUGE_NOVA_T_500,
3823     HAUPPAUGE_NOVA_T_500_2,
3824     HAUPPAUGE_NOVA_T_STICK,
3825     AVERMEDIA_VOLAR,
3826     COMPRO_VIDEOMATE_U500,
3827     UNIWILL_STK7700P,
3828     LEADTEK_WINFAST_DTV_DONGLE_STK7700P,
3829     HAUPPAUGE_NOVA_T_STICK_2,
3830     AVERMEDIA_VOLAR_2,
3831     PINNACLE_PCTV2000E,
3832     TERRATEC_CINERGY_DT_XS_DIVERSITY,
3833     HAUPPAUGE_NOVA_TD_STICK,
3834     DIBCOM_STK7700D,
3835     DIBCOM_STK7070P,
3836     PINNACLE_PCTV_DVB_T_FLASH,
3837     DIBCOM_STK7070PD,
3838     PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T,
3839     COMPRO_VIDEOMATE_U500_PC,
3840     AVERMEDIA_EXPRESS,
3841     GIGABYTE_U7000,
3842     ULTIMA_ARTEC_T14BR,
3843     ASUS_U3000,
3844     ASUS_U3100,
3845     HAUPPAUGE_NOVA_T_STICK_3,
3846     HAUPPAUGE_MYTV_T,
3847     TERRATEC_CINERGY_HT_USB_XE,
3848     PINNACLE_EXPRESSCARD_320CX,
3849     PINNACLE_PCTV72E,
3850     PINNACLE_PCTV73E,
3851     YUAN_EC372S,
3852     TERRATEC_CINERGY_HT_EXPRESS,
3853     TERRATEC_CINERGY_T_XXS,
3854     LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2,
3855     HAUPPAUGE_NOVA_TD_STICK_52009,
3856     HAUPPAUGE_NOVA_T_500_3,
3857     GIGABYTE_U8000,
3858     YUAN_STK7700PH,
3859     ASUS_U3000H,
3860     PINNACLE_PCTV801E,
3861     PINNACLE_PCTV801E_SE,
3862     TERRATEC_CINERGY_T_EXPRESS,
3863     TERRATEC_CINERGY_DT_XS_DIVERSITY_2,
3864     SONY_PLAYTV,
3865     YUAN_PD378S,
3866     HAUPPAUGE_TIGER_ATSC,
3867     HAUPPAUGE_TIGER_ATSC_B210,
3868     YUAN_MC770,
3869     ELGATO_EYETV_DTT,
3870     ELGATO_EYETV_DTT_Dlx,
3871     LEADTEK_WINFAST_DTV_DONGLE_H,
3872     TERRATEC_T3,
3873     TERRATEC_T5,
3874     YUAN_STK7700D,
3875     YUAN_STK7700D_2,
3876     PINNACLE_PCTV73A,
3877     PCTV_PINNACLE_PCTV73ESE,
3878     PCTV_PINNACLE_PCTV282E,
3879     DIBCOM_STK7770P,
3880     TERRATEC_CINERGY_T_XXS_2,
3881     DIBCOM_STK807XPVR,
3882     DIBCOM_STK807XP,
3883     PIXELVIEW_SBTVD,
3884     EVOLUTEPC_TVWAY_PLUS,
3885     PINNACLE_PCTV73ESE,
3886     PINNACLE_PCTV282E,
3887     DIBCOM_STK8096GP,
3888     ELGATO_EYETV_DIVERSITY,
3889     DIBCOM_NIM9090M,
3890     DIBCOM_NIM8096MD,
3891     DIBCOM_NIM9090MD,
3892     DIBCOM_NIM7090,
3893     DIBCOM_TFE7090PVR,
3894     TECHNISAT_AIRSTAR_TELESTICK_2,
3895     MEDION_CREATIX_CTX1921,
3896     PINNACLE_PCTV340E,
3897     PINNACLE_PCTV340E_SE,
3898     DIBCOM_TFE7790P,
3899     DIBCOM_TFE8096P,
3900     ELGATO_EYETV_DTT_2,
3901     PCTV_2002E,
3902     PCTV_2002E_SE,
3903     PCTV_DIBCOM_STK8096PVR,
3904     DIBCOM_STK8096PVR,
3905     HAMA_DVBT_HYBRID,
3906     MICROSOFT_XBOX_ONE_TUNER,
3907 };
3908
3909 struct usb_device_id dib0700_usb_id_table[] = {
3910     DVB_USB_DEV(DIBCOM, DIBCOM_STK7700P),
3911     DVB_USB_DEV(DIBCOM, DIBCOM_STK7700P_PC),
3912     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500),
3913     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500_2),
3914     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK),
3915     DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR),
3916     DVB_USB_DEV(COMPRO, COMPRO_VIDEOMATE_U500),
3917     DVB_USB_DEV(UNIWILL, UNIWILL_STK7700P),
3918     DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_STK7700P),
3919     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK_2),
3920     DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR_2),
3921     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV2000E),
3922     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_DT_XS_DIVERSITY),
3923     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_TD_STICK),
3924     DVB_USB_DEV(DIBCOM, DIBCOM_STK7700D),
3925     DVB_USB_DEV(DIBCOM, DIBCOM_STK7070P),
3926     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_DVB_T_FLASH),
3927     DVB_USB_DEV(DIBCOM, DIBCOM_STK7070PD),
3928     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T),
3929     DVB_USB_DEV(COMPRO, COMPRO_VIDEOMATE_U500_PC),
3930     DVB_USB_DEV(AVERMEDIA, AVERMEDIA_EXPRESS),
3931     DVB_USB_DEV(GIGABYTE, GIGABYTE_U7000),
3932     DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_ARTEC_T14BR),
3933     DVB_USB_DEV(ASUS, ASUS_U3000),
3934     DVB_USB_DEV(ASUS, ASUS_U3100),
3935     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK_3),
3936     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_MYTV_T),
3937     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_HT_USB_XE),
3938     DVB_USB_DEV(PINNACLE, PINNACLE_EXPRESSCARD_320CX),
3939     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV72E),
3940     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73E),
3941     DVB_USB_DEV(YUAN, YUAN_EC372S),
3942     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_HT_EXPRESS),
3943     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_XXS),
3944     DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2),
3945     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_TD_STICK_52009),
3946     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500_3),
3947     DVB_USB_DEV(GIGABYTE, GIGABYTE_U8000),
3948     DVB_USB_DEV(YUAN, YUAN_STK7700PH),
3949     DVB_USB_DEV(ASUS, ASUS_U3000H),
3950     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV801E),
3951     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV801E_SE),
3952     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_EXPRESS),
3953     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_DT_XS_DIVERSITY_2),
3954     DVB_USB_DEV(SONY, SONY_PLAYTV),
3955     DVB_USB_DEV(YUAN, YUAN_PD378S),
3956     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_TIGER_ATSC),
3957     DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_TIGER_ATSC_B210),
3958     DVB_USB_DEV(YUAN, YUAN_MC770),
3959     DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT),
3960     DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT_Dlx),
3961     DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_H),
3962     DVB_USB_DEV(TERRATEC, TERRATEC_T3),
3963     DVB_USB_DEV(TERRATEC, TERRATEC_T5),
3964     DVB_USB_DEV(YUAN, YUAN_STK7700D),
3965     DVB_USB_DEV(YUAN, YUAN_STK7700D_2),
3966     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73A),
3967     DVB_USB_DEV(PCTV, PCTV_PINNACLE_PCTV73ESE),
3968     DVB_USB_DEV(PCTV, PCTV_PINNACLE_PCTV282E),
3969     DVB_USB_DEV(DIBCOM, DIBCOM_STK7770P),
3970     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_XXS_2),
3971     DVB_USB_DEV(DIBCOM, DIBCOM_STK807XPVR),
3972     DVB_USB_DEV(DIBCOM, DIBCOM_STK807XP),
3973     DVB_USB_DEV_VER(PIXELVIEW, PIXELVIEW_SBTVD, 0x000, 0x3f00),
3974     DVB_USB_DEV(EVOLUTEPC, EVOLUTEPC_TVWAY_PLUS),
3975     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73ESE),
3976     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV282E),
3977     DVB_USB_DEV(DIBCOM, DIBCOM_STK8096GP),
3978     DVB_USB_DEV(ELGATO, ELGATO_EYETV_DIVERSITY),
3979     DVB_USB_DEV(DIBCOM, DIBCOM_NIM9090M),
3980     DVB_USB_DEV(DIBCOM, DIBCOM_NIM8096MD),
3981     DVB_USB_DEV(DIBCOM, DIBCOM_NIM9090MD),
3982     DVB_USB_DEV(DIBCOM, DIBCOM_NIM7090),
3983     DVB_USB_DEV(DIBCOM, DIBCOM_TFE7090PVR),
3984     DVB_USB_DEV(TECHNISAT, TECHNISAT_AIRSTAR_TELESTICK_2),
3985     DVB_USB_DEV(MEDION, MEDION_CREATIX_CTX1921),
3986     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV340E),
3987     DVB_USB_DEV(PINNACLE, PINNACLE_PCTV340E_SE),
3988     DVB_USB_DEV(DIBCOM, DIBCOM_TFE7790P),
3989     DVB_USB_DEV(DIBCOM, DIBCOM_TFE8096P),
3990     DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT_2),
3991     DVB_USB_DEV(PCTV, PCTV_2002E),
3992     DVB_USB_DEV(PCTV, PCTV_2002E_SE),
3993     DVB_USB_DEV(PCTV, PCTV_DIBCOM_STK8096PVR),
3994     DVB_USB_DEV(DIBCOM, DIBCOM_STK8096PVR),
3995     DVB_USB_DEV(HAMA, HAMA_DVBT_HYBRID),
3996     DVB_USB_DEV(MICROSOFT, MICROSOFT_XBOX_ONE_TUNER),
3997     { }
3998 };
3999
4000 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
4001
4002 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
4003     .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
4004     .usb_ctrl          = DEVICE_SPECIFIC, \
4005     .firmware          = "dvb-usb-dib0700-1.20.fw", \
4006     .download_firmware = dib0700_download_firmware, \
4007     .no_reconnect      = 1, \
4008     .size_of_priv      = sizeof(struct dib0700_state), \
4009     .i2c_algo          = &dib0700_i2c_algo, \
4010     .identify_state    = dib0700_identify_state
4011
4012 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
4013     .streaming_ctrl   = dib0700_streaming_ctrl, \
4014     .stream = { \
4015         .type = USB_BULK, \
4016         .count = 4, \
4017         .endpoint = ep, \
4018         .u = { \
4019             .bulk = { \
4020                 .buffersize = 39480, \
4021             } \
4022         } \
4023     }
4024
4025 #define DIB0700_NUM_FRONTENDS(n) \
4026     .num_frontends = n, \
4027     .size_of_priv     = sizeof(struct dib0700_adapter_state)
4028
4029 struct dvb_usb_device_properties dib0700_devices[] = {
4030     {
4031         DIB0700_DEFAULT_DEVICE_PROPERTIES,
4032
4033         .num_adapters = 1,
4034         .adapter = {
4035             {
4036             DIB0700_NUM_FRONTENDS(1),
4037             .fe = {{
4038                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4039                 .pid_filter_count = 32,
4040                 .pid_filter       = stk7700p_pid_filter,
4041                 .pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
4042                 .frontend_attach  = stk7700p_frontend_attach,
4043                 .tuner_attach     = stk7700p_tuner_attach,
4044
4045                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4046             }},
4047             },
4048         },
4049
4050         .num_device_descs = 8,
4051         .devices = {
4052             {   "DiBcom STK7700P reference design",
4053                 { &dib0700_usb_id_table[DIBCOM_STK7700P], &dib0700_usb_id_table[DIBCOM_STK7700P_PC] },
4054                 { NULL },
4055             },
4056             {   "Hauppauge Nova-T Stick",
4057                 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK], &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK_2], NULL },
4058                 { NULL },
4059             },
4060             {   "AVerMedia AVerTV DVB-T Volar",
4061                 { &dib0700_usb_id_table[AVERMEDIA_VOLAR], &dib0700_usb_id_table[AVERMEDIA_VOLAR_2] },
4062                 { NULL },
4063             },
4064             {   "Compro Videomate U500",
4065                 { &dib0700_usb_id_table[COMPRO_VIDEOMATE_U500], &dib0700_usb_id_table[COMPRO_VIDEOMATE_U500_PC] },
4066                 { NULL },
4067             },
4068             {   "Uniwill STK7700P based (Hama and others)",
4069                 { &dib0700_usb_id_table[UNIWILL_STK7700P], NULL },
4070                 { NULL },
4071             },
4072             {   "Leadtek Winfast DTV Dongle (STK7700P based)",
4073                 { &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_STK7700P], &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2] },
4074                 { NULL },
4075             },
4076             {   "AVerMedia AVerTV DVB-T Express",
4077                 { &dib0700_usb_id_table[AVERMEDIA_EXPRESS] },
4078                 { NULL },
4079             },
4080             {   "Gigabyte U7000",
4081                 { &dib0700_usb_id_table[GIGABYTE_U7000], NULL },
4082                 { NULL },
4083             }
4084         },
4085
4086         .rc.core = {
4087             .rc_interval      = DEFAULT_RC_INTERVAL,
4088             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4089             .rc_query         = dib0700_rc_query_old_firmware,
4090             .allowed_protos   = RC_PROTO_BIT_RC5 |
4091                         RC_PROTO_BIT_RC6_MCE |
4092                         RC_PROTO_BIT_NEC,
4093             .change_protocol  = dib0700_change_protocol,
4094         },
4095     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4096
4097         .num_adapters = 2,
4098         .adapter = {
4099             {
4100             DIB0700_NUM_FRONTENDS(1),
4101             .fe = {{
4102                 .frontend_attach  = bristol_frontend_attach,
4103                 .tuner_attach     = bristol_tuner_attach,
4104
4105                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4106             }},
4107             }, {
4108             DIB0700_NUM_FRONTENDS(1),
4109             .fe = {{
4110                 .frontend_attach  = bristol_frontend_attach,
4111                 .tuner_attach     = bristol_tuner_attach,
4112
4113                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4114             }},
4115             }
4116         },
4117
4118         .num_device_descs = 1,
4119         .devices = {
4120             {   "Hauppauge Nova-T 500 Dual DVB-T",
4121                 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500], &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500_2], NULL },
4122                 { NULL },
4123             },
4124         },
4125
4126         .rc.core = {
4127             .rc_interval      = DEFAULT_RC_INTERVAL,
4128             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4129             .rc_query         = dib0700_rc_query_old_firmware,
4130             .allowed_protos   = RC_PROTO_BIT_RC5 |
4131                         RC_PROTO_BIT_RC6_MCE |
4132                         RC_PROTO_BIT_NEC,
4133             .change_protocol = dib0700_change_protocol,
4134         },
4135     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4136
4137         .num_adapters = 2,
4138         .adapter = {
4139             {
4140             DIB0700_NUM_FRONTENDS(1),
4141             .fe = {{
4142                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4143                 .pid_filter_count = 32,
4144                 .pid_filter       = stk70x0p_pid_filter,
4145                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4146                 .frontend_attach  = stk7700d_frontend_attach,
4147                 .tuner_attach     = stk7700d_tuner_attach,
4148
4149                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4150             }},
4151             }, {
4152             DIB0700_NUM_FRONTENDS(1),
4153             .fe = {{
4154                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4155                 .pid_filter_count = 32,
4156                 .pid_filter       = stk70x0p_pid_filter,
4157                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4158                 .frontend_attach  = stk7700d_frontend_attach,
4159                 .tuner_attach     = stk7700d_tuner_attach,
4160
4161                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4162             }},
4163             }
4164         },
4165
4166         .num_device_descs = 5,
4167         .devices = {
4168             {   "Pinnacle PCTV 2000e",
4169                 { &dib0700_usb_id_table[PINNACLE_PCTV2000E], NULL },
4170                 { NULL },
4171             },
4172             {   "Terratec Cinergy DT XS Diversity",
4173                 { &dib0700_usb_id_table[TERRATEC_CINERGY_DT_XS_DIVERSITY], NULL },
4174                 { NULL },
4175             },
4176             {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
4177                 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_TD_STICK], NULL },
4178                 { NULL },
4179             },
4180             {   "DiBcom STK7700D reference design",
4181                 { &dib0700_usb_id_table[DIBCOM_STK7700D], NULL },
4182                 { NULL },
4183             },
4184             {   "YUAN High-Tech DiBcom STK7700D",
4185                 { &dib0700_usb_id_table[YUAN_STK7700D_2], NULL },
4186                 { NULL },
4187             },
4188
4189         },
4190
4191         .rc.core = {
4192             .rc_interval      = DEFAULT_RC_INTERVAL,
4193             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4194             .rc_query         = dib0700_rc_query_old_firmware,
4195             .allowed_protos   = RC_PROTO_BIT_RC5 |
4196                         RC_PROTO_BIT_RC6_MCE |
4197                         RC_PROTO_BIT_NEC,
4198             .change_protocol = dib0700_change_protocol,
4199         },
4200     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4201
4202         .num_adapters = 1,
4203         .adapter = {
4204             {
4205             DIB0700_NUM_FRONTENDS(1),
4206             .fe = {{
4207                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4208                 .pid_filter_count = 32,
4209                 .pid_filter       = stk70x0p_pid_filter,
4210                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4211                 .frontend_attach  = stk7700P2_frontend_attach,
4212                 .tuner_attach     = stk7700d_tuner_attach,
4213
4214                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4215             }},
4216             },
4217         },
4218
4219         .num_device_descs = 3,
4220         .devices = {
4221             {   "ASUS My Cinema U3000 Mini DVBT Tuner",
4222                 { &dib0700_usb_id_table[ASUS_U3000], NULL },
4223                 { NULL },
4224             },
4225             {   "Yuan EC372S",
4226                 { &dib0700_usb_id_table[YUAN_EC372S], NULL },
4227                 { NULL },
4228             },
4229             {   "Terratec Cinergy T Express",
4230                 { &dib0700_usb_id_table[TERRATEC_CINERGY_T_EXPRESS], NULL },
4231                 { NULL },
4232             }
4233         },
4234
4235         .rc.core = {
4236             .rc_interval      = DEFAULT_RC_INTERVAL,
4237             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4238             .module_name      = "dib0700",
4239             .rc_query         = dib0700_rc_query_old_firmware,
4240             .allowed_protos   = RC_PROTO_BIT_RC5 |
4241                         RC_PROTO_BIT_RC6_MCE |
4242                         RC_PROTO_BIT_NEC,
4243             .change_protocol = dib0700_change_protocol,
4244         },
4245     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4246
4247         .num_adapters = 1,
4248         .adapter = {
4249             {
4250             DIB0700_NUM_FRONTENDS(1),
4251             .fe = {{
4252                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4253                 .pid_filter_count = 32,
4254                 .pid_filter       = stk70x0p_pid_filter,
4255                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4256                 .frontend_attach  = stk7070p_frontend_attach,
4257                 .tuner_attach     = dib7070p_tuner_attach,
4258
4259                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4260             }},
4261             },
4262         },
4263
4264         .num_device_descs = 12,
4265         .devices = {
4266             {   "DiBcom STK7070P reference design",
4267                 { &dib0700_usb_id_table[DIBCOM_STK7070P], NULL },
4268                 { NULL },
4269             },
4270             {   "Pinnacle PCTV DVB-T Flash Stick",
4271                 { &dib0700_usb_id_table[PINNACLE_PCTV_DVB_T_FLASH], NULL },
4272                 { NULL },
4273             },
4274             {   "Artec T14BR DVB-T",
4275                 { &dib0700_usb_id_table[ULTIMA_ARTEC_T14BR], NULL },
4276                 { NULL },
4277             },
4278             {   "ASUS My Cinema U3100 Mini DVBT Tuner",
4279                 { &dib0700_usb_id_table[ASUS_U3100], NULL },
4280                 { NULL },
4281             },
4282             {   "Hauppauge Nova-T Stick",
4283                 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK_3], NULL },
4284                 { NULL },
4285             },
4286             {   "Hauppauge Nova-T MyTV.t",
4287                 { &dib0700_usb_id_table[HAUPPAUGE_MYTV_T], NULL },
4288                 { NULL },
4289             },
4290             {   "Pinnacle PCTV 72e",
4291                 { &dib0700_usb_id_table[PINNACLE_PCTV72E], NULL },
4292                 { NULL },
4293             },
4294             {   "Pinnacle PCTV 73e",
4295                 { &dib0700_usb_id_table[PINNACLE_PCTV73E], NULL },
4296                 { NULL },
4297             },
4298             {   "Elgato EyeTV DTT",
4299                 { &dib0700_usb_id_table[ELGATO_EYETV_DTT], NULL },
4300                 { NULL },
4301             },
4302             {   "Yuan PD378S",
4303                 { &dib0700_usb_id_table[YUAN_PD378S], NULL },
4304                 { NULL },
4305             },
4306             {   "Elgato EyeTV Dtt Dlx PD378S",
4307                 { &dib0700_usb_id_table[ELGATO_EYETV_DTT_Dlx], NULL },
4308                 { NULL },
4309             },
4310             {   "Elgato EyeTV DTT rev. 2",
4311                 { &dib0700_usb_id_table[ELGATO_EYETV_DTT_2], NULL },
4312                 { NULL },
4313             },
4314         },
4315
4316         .rc.core = {
4317             .rc_interval      = DEFAULT_RC_INTERVAL,
4318             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4319             .module_name      = "dib0700",
4320             .rc_query         = dib0700_rc_query_old_firmware,
4321             .allowed_protos   = RC_PROTO_BIT_RC5 |
4322                         RC_PROTO_BIT_RC6_MCE |
4323                         RC_PROTO_BIT_NEC,
4324             .change_protocol  = dib0700_change_protocol,
4325         },
4326     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4327
4328         .num_adapters = 1,
4329         .adapter = {
4330             {
4331             DIB0700_NUM_FRONTENDS(1),
4332             .fe = {{
4333                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4334                 .pid_filter_count = 32,
4335                 .pid_filter       = stk70x0p_pid_filter,
4336                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4337                 .frontend_attach  = stk7070p_frontend_attach,
4338                 .tuner_attach     = dib7070p_tuner_attach,
4339
4340                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4341             }},
4342             },
4343         },
4344
4345         .num_device_descs = 3,
4346         .devices = {
4347             {   "Pinnacle PCTV 73A",
4348                 { &dib0700_usb_id_table[PINNACLE_PCTV73A], NULL },
4349                 { NULL },
4350             },
4351             {   "Pinnacle PCTV 73e SE",
4352                 { &dib0700_usb_id_table[PCTV_PINNACLE_PCTV73ESE], &dib0700_usb_id_table[PINNACLE_PCTV73ESE], NULL },
4353                 { NULL },
4354             },
4355             {   "Pinnacle PCTV 282e",
4356                 { &dib0700_usb_id_table[PCTV_PINNACLE_PCTV282E], &dib0700_usb_id_table[PINNACLE_PCTV282E], NULL },
4357                 { NULL },
4358             },
4359         },
4360
4361         .rc.core = {
4362             .rc_interval      = DEFAULT_RC_INTERVAL,
4363             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4364             .module_name      = "dib0700",
4365             .rc_query         = dib0700_rc_query_old_firmware,
4366             .allowed_protos   = RC_PROTO_BIT_RC5 |
4367                         RC_PROTO_BIT_RC6_MCE |
4368                         RC_PROTO_BIT_NEC,
4369             .change_protocol  = dib0700_change_protocol,
4370         },
4371     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4372
4373         .num_adapters = 2,
4374         .adapter = {
4375             {
4376             DIB0700_NUM_FRONTENDS(1),
4377             .fe = {{
4378                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4379                 .pid_filter_count = 32,
4380                 .pid_filter       = stk70x0p_pid_filter,
4381                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4382                 .frontend_attach  = novatd_frontend_attach,
4383                 .tuner_attach     = dib7070p_tuner_attach,
4384
4385                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4386             }},
4387             }, {
4388             DIB0700_NUM_FRONTENDS(1),
4389             .fe = {{
4390                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4391                 .pid_filter_count = 32,
4392                 .pid_filter       = stk70x0p_pid_filter,
4393                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4394                 .frontend_attach  = novatd_frontend_attach,
4395                 .tuner_attach     = dib7070p_tuner_attach,
4396
4397                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4398             }},
4399             }
4400         },
4401
4402         .num_device_descs = 3,
4403         .devices = {
4404             {   "Hauppauge Nova-TD Stick (52009)",
4405                 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_TD_STICK_52009], NULL },
4406                 { NULL },
4407             },
4408             {   "PCTV 2002e",
4409                 { &dib0700_usb_id_table[PCTV_2002E], NULL },
4410                 { NULL },
4411             },
4412             {   "PCTV 2002e SE",
4413                 { &dib0700_usb_id_table[PCTV_2002E_SE], NULL },
4414                 { NULL },
4415             },
4416         },
4417
4418         .rc.core = {
4419             .rc_interval      = DEFAULT_RC_INTERVAL,
4420             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4421             .module_name      = "dib0700",
4422             .rc_query         = dib0700_rc_query_old_firmware,
4423             .allowed_protos   = RC_PROTO_BIT_RC5 |
4424                         RC_PROTO_BIT_RC6_MCE |
4425                         RC_PROTO_BIT_NEC,
4426             .change_protocol = dib0700_change_protocol,
4427         },
4428     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4429
4430         .num_adapters = 2,
4431         .adapter = {
4432             {
4433             DIB0700_NUM_FRONTENDS(1),
4434             .fe = {{
4435                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4436                 .pid_filter_count = 32,
4437                 .pid_filter       = stk70x0p_pid_filter,
4438                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4439                 .frontend_attach  = stk7070pd_frontend_attach0,
4440                 .tuner_attach     = dib7070p_tuner_attach,
4441
4442                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4443             }},
4444             }, {
4445             DIB0700_NUM_FRONTENDS(1),
4446             .fe = {{
4447                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4448                 .pid_filter_count = 32,
4449                 .pid_filter       = stk70x0p_pid_filter,
4450                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4451                 .frontend_attach  = stk7070pd_frontend_attach1,
4452                 .tuner_attach     = dib7070p_tuner_attach,
4453
4454                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4455             }},
4456             }
4457         },
4458
4459         .num_device_descs = 5,
4460         .devices = {
4461             {   "DiBcom STK7070PD reference design",
4462                 { &dib0700_usb_id_table[DIBCOM_STK7070PD], NULL },
4463                 { NULL },
4464             },
4465             {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
4466                 { &dib0700_usb_id_table[PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T], NULL },
4467                 { NULL },
4468             },
4469             {   "Hauppauge Nova-TD-500 (84xxx)",
4470                 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500_3], NULL },
4471                 { NULL },
4472             },
4473             {  "Terratec Cinergy DT USB XS Diversity/ T5",
4474                 { &dib0700_usb_id_table[TERRATEC_CINERGY_DT_XS_DIVERSITY_2],
4475                     &dib0700_usb_id_table[TERRATEC_T5], NULL},
4476                 { NULL },
4477             },
4478             {  "Sony PlayTV",
4479                 { &dib0700_usb_id_table[SONY_PLAYTV], NULL },
4480                 { NULL },
4481             },
4482         },
4483
4484         .rc.core = {
4485             .rc_interval      = DEFAULT_RC_INTERVAL,
4486             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4487             .module_name      = "dib0700",
4488             .rc_query         = dib0700_rc_query_old_firmware,
4489             .allowed_protos   = RC_PROTO_BIT_RC5 |
4490                         RC_PROTO_BIT_RC6_MCE |
4491                         RC_PROTO_BIT_NEC,
4492             .change_protocol = dib0700_change_protocol,
4493         },
4494     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4495
4496         .num_adapters = 2,
4497         .adapter = {
4498             {
4499             DIB0700_NUM_FRONTENDS(1),
4500             .fe = {{
4501                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4502                 .pid_filter_count = 32,
4503                 .pid_filter       = stk70x0p_pid_filter,
4504                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4505                 .frontend_attach  = stk7070pd_frontend_attach0,
4506                 .tuner_attach     = dib7070p_tuner_attach,
4507
4508                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4509             }},
4510             }, {
4511             DIB0700_NUM_FRONTENDS(1),
4512             .fe = {{
4513                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4514                 .pid_filter_count = 32,
4515                 .pid_filter       = stk70x0p_pid_filter,
4516                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4517                 .frontend_attach  = stk7070pd_frontend_attach1,
4518                 .tuner_attach     = dib7070p_tuner_attach,
4519
4520                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4521             }},
4522             }
4523         },
4524
4525         .num_device_descs = 1,
4526         .devices = {
4527             {   "Elgato EyeTV Diversity",
4528                 { &dib0700_usb_id_table[ELGATO_EYETV_DIVERSITY], NULL },
4529                 { NULL },
4530             },
4531         },
4532
4533         .rc.core = {
4534             .rc_interval      = DEFAULT_RC_INTERVAL,
4535             .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4536             .module_name      = "dib0700",
4537             .rc_query         = dib0700_rc_query_old_firmware,
4538             .allowed_protos   = RC_PROTO_BIT_RC5 |
4539                         RC_PROTO_BIT_RC6_MCE |
4540                         RC_PROTO_BIT_NEC,
4541             .change_protocol  = dib0700_change_protocol,
4542         },
4543     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4544
4545         .num_adapters = 1,
4546         .adapter = {
4547             {
4548             DIB0700_NUM_FRONTENDS(1),
4549             .fe = {{
4550                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4551                 .pid_filter_count = 32,
4552                 .pid_filter       = stk70x0p_pid_filter,
4553                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4554                 .frontend_attach  = stk7700ph_frontend_attach,
4555                 .tuner_attach     = stk7700ph_tuner_attach,
4556
4557                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4558             }},
4559             },
4560         },
4561
4562         .num_device_descs = 10,
4563         .devices = {
4564             {   "Terratec Cinergy HT USB XE",
4565                 { &dib0700_usb_id_table[TERRATEC_CINERGY_HT_USB_XE], NULL },
4566                 { NULL },
4567             },
4568             {   "Pinnacle Expresscard 320cx",
4569                 { &dib0700_usb_id_table[PINNACLE_EXPRESSCARD_320CX], NULL },
4570                 { NULL },
4571             },
4572             {   "Terratec Cinergy HT Express",
4573                 { &dib0700_usb_id_table[TERRATEC_CINERGY_HT_EXPRESS], NULL },
4574                 { NULL },
4575             },
4576             {   "Gigabyte U8000-RH",
4577                 { &dib0700_usb_id_table[GIGABYTE_U8000], NULL },
4578                 { NULL },
4579             },
4580             {   "YUAN High-Tech STK7700PH",
4581                 { &dib0700_usb_id_table[YUAN_STK7700PH], NULL },
4582                 { NULL },
4583             },
4584             {   "Asus My Cinema-U3000Hybrid",
4585                 { &dib0700_usb_id_table[ASUS_U3000H], NULL },
4586                 { NULL },
4587             },
4588             {   "YUAN High-Tech MC770",
4589                 { &dib0700_usb_id_table[YUAN_MC770], NULL },
4590                 { NULL },
4591             },
4592             {   "Leadtek WinFast DTV Dongle H",
4593                 { &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_H], NULL },
4594                 { NULL },
4595             },
4596             {   "YUAN High-Tech STK7700D",
4597                 { &dib0700_usb_id_table[YUAN_STK7700D], NULL },
4598                 { NULL },
4599             },
4600             {   "Hama DVB=T Hybrid USB Stick",
4601                 { &dib0700_usb_id_table[HAMA_DVBT_HYBRID], NULL },
4602                 { NULL },
4603             },
4604         },
4605
4606         .rc.core = {
4607             .rc_interval      = DEFAULT_RC_INTERVAL,
4608             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4609             .module_name      = "dib0700",
4610             .rc_query         = dib0700_rc_query_old_firmware,
4611             .allowed_protos   = RC_PROTO_BIT_RC5 |
4612                         RC_PROTO_BIT_RC6_MCE |
4613                         RC_PROTO_BIT_NEC,
4614             .change_protocol  = dib0700_change_protocol,
4615         },
4616     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4617         .num_adapters = 1,
4618         .adapter = {
4619             {
4620             DIB0700_NUM_FRONTENDS(1),
4621             .fe = {{
4622                 .frontend_attach  = s5h1411_frontend_attach,
4623                 .tuner_attach     = xc5000_tuner_attach,
4624
4625                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4626             }},
4627             },
4628         },
4629
4630         .num_device_descs = 2,
4631         .devices = {
4632             {   "Pinnacle PCTV HD Pro USB Stick",
4633                 { &dib0700_usb_id_table[PINNACLE_PCTV801E], NULL },
4634                 { NULL },
4635             },
4636             {   "Pinnacle PCTV HD USB Stick",
4637                 { &dib0700_usb_id_table[PINNACLE_PCTV801E_SE], NULL },
4638                 { NULL },
4639             },
4640         },
4641
4642         .rc.core = {
4643             .rc_interval      = DEFAULT_RC_INTERVAL,
4644             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4645             .module_name      = "dib0700",
4646             .rc_query         = dib0700_rc_query_old_firmware,
4647             .allowed_protos   = RC_PROTO_BIT_RC5 |
4648                         RC_PROTO_BIT_RC6_MCE |
4649                         RC_PROTO_BIT_NEC,
4650             .change_protocol  = dib0700_change_protocol,
4651         },
4652     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4653         .num_adapters = 1,
4654         .adapter = {
4655             {
4656             DIB0700_NUM_FRONTENDS(1),
4657             .fe = {{
4658                 .frontend_attach  = lgdt3305_frontend_attach,
4659                 .tuner_attach     = mxl5007t_tuner_attach,
4660
4661                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4662             }},
4663             },
4664         },
4665
4666         .num_device_descs = 2,
4667         .devices = {
4668             {   "Hauppauge ATSC MiniCard (B200)",
4669                 { &dib0700_usb_id_table[HAUPPAUGE_TIGER_ATSC], NULL },
4670                 { NULL },
4671             },
4672             {   "Hauppauge ATSC MiniCard (B210)",
4673                 { &dib0700_usb_id_table[HAUPPAUGE_TIGER_ATSC_B210], NULL },
4674                 { NULL },
4675             },
4676         },
4677     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4678
4679         .num_adapters = 1,
4680         .adapter = {
4681             {
4682             DIB0700_NUM_FRONTENDS(1),
4683             .fe = {{
4684                 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4685                 .pid_filter_count = 32,
4686                 .pid_filter       = stk70x0p_pid_filter,
4687                 .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4688                 .frontend_attach  = stk7770p_frontend_attach,
4689                 .tuner_attach     = dib7770p_tuner_attach,
4690
4691                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4692             }},
4693             },
4694         },
4695
4696         .num_device_descs = 4,
4697         .devices = {
4698             {   "DiBcom STK7770P reference design",
4699                 { &dib0700_usb_id_table[DIBCOM_STK7770P], NULL },
4700                 { NULL },
4701             },
4702             {   "Terratec Cinergy T USB XXS (HD)/ T3",
4703                 { &dib0700_usb_id_table[TERRATEC_CINERGY_T_XXS],
4704                     &dib0700_usb_id_table[TERRATEC_T3],
4705                     &dib0700_usb_id_table[TERRATEC_CINERGY_T_XXS_2], NULL},
4706                 { NULL },
4707             },
4708             {   "TechniSat AirStar TeleStick 2",
4709                 { &dib0700_usb_id_table[TECHNISAT_AIRSTAR_TELESTICK_2], NULL },
4710                 { NULL },
4711             },
4712             {   "Medion CTX1921 DVB-T USB",
4713                 { &dib0700_usb_id_table[MEDION_CREATIX_CTX1921], NULL },
4714                 { NULL },
4715             },
4716         },
4717
4718         .rc.core = {
4719             .rc_interval      = DEFAULT_RC_INTERVAL,
4720             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4721             .module_name      = "dib0700",
4722             .rc_query         = dib0700_rc_query_old_firmware,
4723             .allowed_protos   = RC_PROTO_BIT_RC5 |
4724                         RC_PROTO_BIT_RC6_MCE |
4725                         RC_PROTO_BIT_NEC,
4726             .change_protocol  = dib0700_change_protocol,
4727         },
4728     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4729         .num_adapters = 1,
4730         .adapter = {
4731             {
4732             DIB0700_NUM_FRONTENDS(1),
4733             .fe = {{
4734                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4735                 .pid_filter_count = 32,
4736                 .pid_filter = stk80xx_pid_filter,
4737                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4738                 .frontend_attach  = stk807x_frontend_attach,
4739                 .tuner_attach     = dib807x_tuner_attach,
4740
4741                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4742             }},
4743             },
4744         },
4745
4746         .num_device_descs = 3,
4747         .devices = {
4748             {   "DiBcom STK807xP reference design",
4749                 { &dib0700_usb_id_table[DIBCOM_STK807XP], NULL },
4750                 { NULL },
4751             },
4752             {   "Prolink Pixelview SBTVD",
4753                 { &dib0700_usb_id_table[PIXELVIEW_SBTVD], NULL },
4754                 { NULL },
4755             },
4756             {   "EvolutePC TVWay+",
4757                 { &dib0700_usb_id_table[EVOLUTEPC_TVWAY_PLUS], NULL },
4758                 { NULL },
4759             },
4760         },
4761
4762         .rc.core = {
4763             .rc_interval      = DEFAULT_RC_INTERVAL,
4764             .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4765             .module_name      = "dib0700",
4766             .rc_query         = dib0700_rc_query_old_firmware,
4767             .allowed_protos   = RC_PROTO_BIT_RC5 |
4768                         RC_PROTO_BIT_RC6_MCE |
4769                         RC_PROTO_BIT_NEC,
4770             .change_protocol  = dib0700_change_protocol,
4771         },
4772     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4773         .num_adapters = 2,
4774         .adapter = {
4775             {
4776             DIB0700_NUM_FRONTENDS(1),
4777             .fe = {{
4778                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4779                 .pid_filter_count = 32,
4780                 .pid_filter = stk80xx_pid_filter,
4781                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4782                 .frontend_attach  = stk807xpvr_frontend_attach0,
4783                 .tuner_attach     = dib807x_tuner_attach,
4784
4785                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4786             }},
4787             },
4788             {
4789             DIB0700_NUM_FRONTENDS(1),
4790             .fe = {{
4791                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4792                 .pid_filter_count = 32,
4793                 .pid_filter = stk80xx_pid_filter,
4794                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4795                 .frontend_attach  = stk807xpvr_frontend_attach1,
4796                 .tuner_attach     = dib807x_tuner_attach,
4797
4798                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4799             }},
4800             },
4801         },
4802
4803         .num_device_descs = 1,
4804         .devices = {
4805             {   "DiBcom STK807xPVR reference design",
4806                 { &dib0700_usb_id_table[DIBCOM_STK807XPVR], NULL },
4807                 { NULL },
4808             },
4809         },
4810
4811         .rc.core = {
4812             .rc_interval      = DEFAULT_RC_INTERVAL,
4813             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4814             .module_name      = "dib0700",
4815             .rc_query         = dib0700_rc_query_old_firmware,
4816             .allowed_protos   = RC_PROTO_BIT_RC5 |
4817                         RC_PROTO_BIT_RC6_MCE |
4818                         RC_PROTO_BIT_NEC,
4819             .change_protocol  = dib0700_change_protocol,
4820         },
4821     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4822         .num_adapters = 1,
4823         .adapter = {
4824             {
4825             DIB0700_NUM_FRONTENDS(1),
4826             .fe = {{
4827                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4828                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4829                 .pid_filter_count = 32,
4830                 .pid_filter = stk80xx_pid_filter,
4831                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4832                 .frontend_attach  = stk809x_frontend_attach,
4833                 .tuner_attach     = dib809x_tuner_attach,
4834
4835                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4836             }},
4837             },
4838         },
4839
4840         .num_device_descs = 1,
4841         .devices = {
4842             {   "DiBcom STK8096GP reference design",
4843                 { &dib0700_usb_id_table[DIBCOM_STK8096GP], NULL },
4844                 { NULL },
4845             },
4846         },
4847
4848         .rc.core = {
4849             .rc_interval      = DEFAULT_RC_INTERVAL,
4850             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4851             .module_name      = "dib0700",
4852             .rc_query         = dib0700_rc_query_old_firmware,
4853             .allowed_protos   = RC_PROTO_BIT_RC5 |
4854                         RC_PROTO_BIT_RC6_MCE |
4855                         RC_PROTO_BIT_NEC,
4856             .change_protocol  = dib0700_change_protocol,
4857         },
4858     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4859         .num_adapters = 1,
4860         .adapter = {
4861             {
4862             DIB0700_NUM_FRONTENDS(1),
4863             .fe = {{
4864                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4865                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4866                 .pid_filter_count = 32,
4867                 .pid_filter = dib90x0_pid_filter,
4868                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4869                 .frontend_attach  = stk9090m_frontend_attach,
4870                 .tuner_attach     = dib9090_tuner_attach,
4871
4872                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4873             }},
4874             },
4875         },
4876
4877         .num_device_descs = 1,
4878         .devices = {
4879             {   "DiBcom STK9090M reference design",
4880                 { &dib0700_usb_id_table[DIBCOM_NIM9090M], NULL },
4881                 { NULL },
4882             },
4883         },
4884
4885         .rc.core = {
4886             .rc_interval      = DEFAULT_RC_INTERVAL,
4887             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4888             .module_name      = "dib0700",
4889             .rc_query         = dib0700_rc_query_old_firmware,
4890             .allowed_protos   = RC_PROTO_BIT_RC5 |
4891                         RC_PROTO_BIT_RC6_MCE |
4892                         RC_PROTO_BIT_NEC,
4893             .change_protocol  = dib0700_change_protocol,
4894         },
4895     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4896         .num_adapters = 1,
4897         .adapter = {
4898             {
4899             DIB0700_NUM_FRONTENDS(1),
4900             .fe = {{
4901                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4902                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4903                 .pid_filter_count = 32,
4904                 .pid_filter = stk80xx_pid_filter,
4905                 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4906                 .frontend_attach  = nim8096md_frontend_attach,
4907                 .tuner_attach     = nim8096md_tuner_attach,
4908
4909                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4910             }},
4911             },
4912         },
4913
4914         .num_device_descs = 1,
4915         .devices = {
4916             {   "DiBcom NIM8096MD reference design",
4917                 { &dib0700_usb_id_table[DIBCOM_NIM8096MD], NULL },
4918                 { NULL },
4919             },
4920         },
4921
4922         .rc.core = {
4923             .rc_interval      = DEFAULT_RC_INTERVAL,
4924             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4925             .module_name      = "dib0700",
4926             .rc_query         = dib0700_rc_query_old_firmware,
4927             .allowed_protos   = RC_PROTO_BIT_RC5 |
4928                         RC_PROTO_BIT_RC6_MCE |
4929                         RC_PROTO_BIT_NEC,
4930             .change_protocol  = dib0700_change_protocol,
4931         },
4932     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4933         .num_adapters = 1,
4934         .adapter = {
4935             {
4936             DIB0700_NUM_FRONTENDS(1),
4937             .fe = {{
4938                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4939                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4940                 .pid_filter_count = 32,
4941                 .pid_filter = dib90x0_pid_filter,
4942                 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4943                 .frontend_attach  = nim9090md_frontend_attach,
4944                 .tuner_attach     = nim9090md_tuner_attach,
4945
4946                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4947             }},
4948             },
4949         },
4950
4951         .num_device_descs = 1,
4952         .devices = {
4953             {   "DiBcom NIM9090MD reference design",
4954                 { &dib0700_usb_id_table[DIBCOM_NIM9090MD], NULL },
4955                 { NULL },
4956             },
4957         },
4958
4959         .rc.core = {
4960             .rc_interval      = DEFAULT_RC_INTERVAL,
4961             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4962             .module_name      = "dib0700",
4963             .rc_query         = dib0700_rc_query_old_firmware,
4964             .allowed_protos   = RC_PROTO_BIT_RC5 |
4965                         RC_PROTO_BIT_RC6_MCE |
4966                         RC_PROTO_BIT_NEC,
4967             .change_protocol  = dib0700_change_protocol,
4968         },
4969     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4970         .num_adapters = 1,
4971         .adapter = {
4972             {
4973             DIB0700_NUM_FRONTENDS(1),
4974             .fe = {{
4975                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4976                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4977                 .pid_filter_count = 32,
4978                 .pid_filter = stk70x0p_pid_filter,
4979                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4980                 .frontend_attach  = nim7090_frontend_attach,
4981                 .tuner_attach     = nim7090_tuner_attach,
4982
4983                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4984             }},
4985             },
4986         },
4987
4988         .num_device_descs = 1,
4989         .devices = {
4990             {   "DiBcom NIM7090 reference design",
4991                 { &dib0700_usb_id_table[DIBCOM_NIM7090], NULL },
4992                 { NULL },
4993             },
4994         },
4995
4996         .rc.core = {
4997             .rc_interval      = DEFAULT_RC_INTERVAL,
4998             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4999             .module_name      = "dib0700",
5000             .rc_query         = dib0700_rc_query_old_firmware,
5001             .allowed_protos   = RC_PROTO_BIT_RC5 |
5002                         RC_PROTO_BIT_RC6_MCE |
5003                         RC_PROTO_BIT_NEC,
5004             .change_protocol  = dib0700_change_protocol,
5005         },
5006     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5007         .num_adapters = 2,
5008         .adapter = {
5009             {
5010             DIB0700_NUM_FRONTENDS(1),
5011             .fe = {{
5012                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5013                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5014                 .pid_filter_count = 32,
5015                 .pid_filter = stk70x0p_pid_filter,
5016                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5017                 .frontend_attach  = tfe7090pvr_frontend0_attach,
5018                 .tuner_attach     = tfe7090pvr_tuner0_attach,
5019
5020                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5021             }},
5022             },
5023             {
5024             DIB0700_NUM_FRONTENDS(1),
5025             .fe = {{
5026                 .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5027                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5028                 .pid_filter_count = 32,
5029                 .pid_filter = stk70x0p_pid_filter,
5030                 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5031                 .frontend_attach  = tfe7090pvr_frontend1_attach,
5032                 .tuner_attach     = tfe7090pvr_tuner1_attach,
5033
5034                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5035             }},
5036             },
5037         },
5038
5039         .num_device_descs = 1,
5040         .devices = {
5041             {   "DiBcom TFE7090PVR reference design",
5042                 { &dib0700_usb_id_table[DIBCOM_TFE7090PVR], NULL },
5043                 { NULL },
5044             },
5045         },
5046
5047         .rc.core = {
5048             .rc_interval      = DEFAULT_RC_INTERVAL,
5049             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5050             .module_name      = "dib0700",
5051             .rc_query         = dib0700_rc_query_old_firmware,
5052             .allowed_protos   = RC_PROTO_BIT_RC5 |
5053                         RC_PROTO_BIT_RC6_MCE |
5054                         RC_PROTO_BIT_NEC,
5055             .change_protocol  = dib0700_change_protocol,
5056         },
5057     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5058         .num_adapters = 1,
5059         .adapter = {
5060             {
5061             DIB0700_NUM_FRONTENDS(1),
5062             .fe = {{
5063                 .frontend_attach  = pctv340e_frontend_attach,
5064                 .tuner_attach     = xc4000_tuner_attach,
5065
5066                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5067             }},
5068             },
5069         },
5070
5071         .num_device_descs = 2,
5072         .devices = {
5073             {   "Pinnacle PCTV 340e HD Pro USB Stick",
5074                 { &dib0700_usb_id_table[PINNACLE_PCTV340E], NULL },
5075                 { NULL },
5076             },
5077             {   "Pinnacle PCTV Hybrid Stick Solo",
5078                 { &dib0700_usb_id_table[PINNACLE_PCTV340E_SE], NULL },
5079                 { NULL },
5080             },
5081         },
5082         .rc.core = {
5083             .rc_interval      = DEFAULT_RC_INTERVAL,
5084             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5085             .module_name      = "dib0700",
5086             .rc_query         = dib0700_rc_query_old_firmware,
5087             .allowed_protos   = RC_PROTO_BIT_RC5 |
5088                         RC_PROTO_BIT_RC6_MCE |
5089                         RC_PROTO_BIT_NEC,
5090             .change_protocol  = dib0700_change_protocol,
5091         },
5092     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5093         .num_adapters = 1,
5094         .adapter = {
5095             {
5096                 DIB0700_NUM_FRONTENDS(1),
5097                 .fe = {{
5098                     .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5099                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5100                     .pid_filter_count = 32,
5101                     .pid_filter = stk70x0p_pid_filter,
5102                     .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5103                     .frontend_attach  = tfe7790p_frontend_attach,
5104                     .tuner_attach     = tfe7790p_tuner_attach,
5105
5106                     DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5107                 } },
5108             },
5109         },
5110
5111         .num_device_descs = 1,
5112         .devices = {
5113             {   "DiBcom TFE7790P reference design",
5114                 { &dib0700_usb_id_table[DIBCOM_TFE7790P], NULL },
5115                 { NULL },
5116             },
5117         },
5118
5119         .rc.core = {
5120             .rc_interval      = DEFAULT_RC_INTERVAL,
5121             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5122             .module_name      = "dib0700",
5123             .rc_query         = dib0700_rc_query_old_firmware,
5124             .allowed_protos   = RC_PROTO_BIT_RC5 |
5125                         RC_PROTO_BIT_RC6_MCE |
5126                         RC_PROTO_BIT_NEC,
5127             .change_protocol  = dib0700_change_protocol,
5128         },
5129     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5130         .num_adapters = 1,
5131         .adapter = {
5132             {
5133                 DIB0700_NUM_FRONTENDS(1),
5134                 .fe = {{
5135                     .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5136                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5137                     .pid_filter_count = 32,
5138                     .pid_filter = stk80xx_pid_filter,
5139                     .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5140                     .frontend_attach  = tfe8096p_frontend_attach,
5141                     .tuner_attach     = tfe8096p_tuner_attach,
5142
5143                     DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5144
5145                 } },
5146             },
5147         },
5148
5149         .num_device_descs = 1,
5150         .devices = {
5151             {   "DiBcom TFE8096P reference design",
5152                 { &dib0700_usb_id_table[DIBCOM_TFE8096P], NULL },
5153                 { NULL },
5154             },
5155         },
5156
5157         .rc.core = {
5158             .rc_interval      = DEFAULT_RC_INTERVAL,
5159             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5160             .module_name      = "dib0700",
5161             .rc_query         = dib0700_rc_query_old_firmware,
5162             .allowed_protos   = RC_PROTO_BIT_RC5 |
5163                         RC_PROTO_BIT_RC6_MCE |
5164                         RC_PROTO_BIT_NEC,
5165             .change_protocol  = dib0700_change_protocol,
5166         },
5167     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5168         .num_adapters = 2,
5169         .adapter = {
5170             {
5171                 .num_frontends = 1,
5172                 .fe = {{
5173                     .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5174                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5175                     .pid_filter_count = 32,
5176                     .pid_filter = stk80xx_pid_filter,
5177                     .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5178                     .frontend_attach  = stk809x_frontend_attach,
5179                     .tuner_attach     = dib809x_tuner_attach,
5180
5181                     DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5182                 } },
5183                 .size_of_priv =
5184                     sizeof(struct dib0700_adapter_state),
5185             }, {
5186                 .num_frontends = 1,
5187                 .fe = { {
5188                     .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5189                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5190                     .pid_filter_count = 32,
5191                     .pid_filter = stk80xx_pid_filter,
5192                     .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5193                     .frontend_attach  = stk809x_frontend1_attach,
5194                     .tuner_attach     = dib809x_tuner_attach,
5195
5196                     DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5197                 } },
5198                 .size_of_priv =
5199                     sizeof(struct dib0700_adapter_state),
5200             },
5201         },
5202         .num_device_descs = 1,
5203         .devices = {
5204             {   "DiBcom STK8096-PVR reference design",
5205                 { &dib0700_usb_id_table[PCTV_DIBCOM_STK8096PVR],
5206                     &dib0700_usb_id_table[DIBCOM_STK8096PVR], NULL},
5207                 { NULL },
5208             },
5209         },
5210
5211         .rc.core = {
5212             .rc_interval      = DEFAULT_RC_INTERVAL,
5213             .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5214             .module_name  = "dib0700",
5215             .rc_query         = dib0700_rc_query_old_firmware,
5216             .allowed_protos   = RC_PROTO_BIT_RC5 |
5217                 RC_PROTO_BIT_RC6_MCE |
5218                 RC_PROTO_BIT_NEC,
5219             .change_protocol  = dib0700_change_protocol,
5220         },
5221     }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5222         .num_adapters = 1,
5223         .adapter = {
5224             {
5225                 DIB0700_NUM_FRONTENDS(1),
5226                 .fe = {{
5227                     .frontend_attach = xbox_one_attach,
5228
5229                     DIB0700_DEFAULT_STREAMING_CONFIG(0x82),
5230                 } },
5231             },
5232         },
5233         .num_device_descs = 1,
5234         .devices = {
5235             { "Microsoft Xbox One Digital TV Tuner",
5236                 { &dib0700_usb_id_table[MICROSOFT_XBOX_ONE_TUNER], NULL },
5237                 { NULL },
5238             },
5239         },
5240     },
5241 };
5242
5243 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);