linux/drivers/media/usb/dvb-usb/dib0700_devices.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/* Linux driver for devices based on the DiBcom DiB0700 USB bridge
   3 *
   4 *  Copyright (C) 2005-9 DiBcom, SA et al
   5 */
   6#include "dib0700.h"
   7
   8#include "dib3000mc.h"
   9#include "dib7000m.h"
  10#include "dib7000p.h"
  11#include "dib8000.h"
  12#include "dib9000.h"
  13#include "mt2060.h"
  14#include "mt2266.h"
  15#include "tuner-xc2028.h"
  16#include "xc5000.h"
  17#include "xc4000.h"
  18#include "s5h1411.h"
  19#include "dib0070.h"
  20#include "dib0090.h"
  21#include "lgdt3305.h"
  22#include "mxl5007t.h"
  23#include "mn88472.h"
  24#include "tda18250.h"
  25
  26
  27static int force_lna_activation;
  28module_param(force_lna_activation, int, 0644);
  29MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifier(s) (LNA), if applicable for the device (default: 0=automatic/off).");
  30
  31struct dib0700_adapter_state {
  32        int (*set_param_save) (struct dvb_frontend *);
  33        const struct firmware *frontend_firmware;
  34        struct dib7000p_ops dib7000p_ops;
  35        struct dib8000_ops dib8000_ops;
  36};
  37
  38/* Hauppauge Nova-T 500 (aka Bristol)
  39 *  has a LNA on GPIO0 which is enabled by setting 1 */
  40static struct mt2060_config bristol_mt2060_config[2] = {
  41        {
  42                .i2c_address = 0x60,
  43                .clock_out   = 3,
  44        }, {
  45                .i2c_address = 0x61,
  46        }
  47};
  48
  49
  50static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  51        .band_caps = BAND_VHF | BAND_UHF,
  52        .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  53
  54        .agc1_max = 42598,
  55        .agc1_min = 17694,
  56        .agc2_max = 45875,
  57        .agc2_min = 0,
  58
  59        .agc1_pt1 = 0,
  60        .agc1_pt2 = 59,
  61
  62        .agc1_slope1 = 0,
  63        .agc1_slope2 = 69,
  64
  65        .agc2_pt1 = 0,
  66        .agc2_pt2 = 59,
  67
  68        .agc2_slope1 = 111,
  69        .agc2_slope2 = 28,
  70};
  71
  72static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  73        {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  74                .max_time     = 0x196,
  75                .ln_adc_level = 0x1cc7,
  76                .output_mpeg2_in_188_bytes = 1,
  77        },
  78        {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  79                .max_time     = 0x196,
  80                .ln_adc_level = 0x1cc7,
  81                .output_mpeg2_in_188_bytes = 1,
  82        }
  83};
  84
  85static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  86{
  87        struct dib0700_state *st = adap->dev->priv;
  88        if (adap->id == 0) {
  89                dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  90                dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  91                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  92                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  93
  94                if (force_lna_activation)
  95                        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  96                else
  97                        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  98
  99                if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
 100                        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
 101                        return -ENODEV;
 102                }
 103        }
 104        st->mt2060_if1[adap->id] = 1220;
 105        return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
 106                (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
 107}
 108
 109static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
 110{
 111        struct i2c_msg msg[2] = {
 112                { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
 113                { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
 114        };
 115        if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
 116        return 0;
 117}
 118
 119static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
 120{
 121        struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 122        struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
 123        s8 a;
 124        int if1=1220;
 125        if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 126                adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
 127                if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
 128        }
 129        return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
 130                          &bristol_mt2060_config[adap->id], if1) == NULL ?
 131                          -ENODEV : 0;
 132}
 133
 134/* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 135
 136/* MT226x */
 137static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 138        {
 139                BAND_UHF,
 140
 141                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
 142                * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 143                (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 144            | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 145
 146                1130,
 147                21,
 148
 149                0,
 150                118,
 151
 152                0,
 153                3530,
 154                1,
 155                0,
 156
 157                65535,
 158                33770,
 159                65535,
 160                23592,
 161
 162                0,
 163                62,
 164                255,
 165                64,
 166                64,
 167                132,
 168                192,
 169                80,
 170                80,
 171
 172                17,
 173                27,
 174                23,
 175                51,
 176
 177                1,
 178        }, {
 179                BAND_VHF | BAND_LBAND,
 180
 181                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
 182                * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 183                (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
 184            | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 185
 186                2372,
 187                21,
 188
 189                0,
 190                118,
 191
 192                0,
 193                3530,
 194                1,
 195                0,
 196
 197                65535,
 198                0,
 199                65535,
 200                23592,
 201
 202                0,
 203                128,
 204                128,
 205                128,
 206                0,
 207                128,
 208                253,
 209                81,
 210                0,
 211
 212                17,
 213                27,
 214                23,
 215                51,
 216
 217                1,
 218        }
 219};
 220
 221static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 222        .internal = 60000,
 223        .sampling = 30000,
 224        .pll_prediv = 1,
 225        .pll_ratio = 8,
 226        .pll_range = 3,
 227        .pll_reset = 1,
 228        .pll_bypass = 0,
 229        .enable_refdiv = 0,
 230        .bypclk_div = 0,
 231        .IO_CLK_en_core = 1,
 232        .ADClkSrc = 1,
 233        .modulo = 2,
 234        .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 235        .ifreq = 0,
 236        .timf = 20452225,
 237};
 238
 239static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 240        {       .output_mpeg2_in_188_bytes = 1,
 241                .hostbus_diversity = 1,
 242                .tuner_is_baseband = 1,
 243
 244                .agc_config_count = 2,
 245                .agc = stk7700d_7000p_mt2266_agc_config,
 246                .bw  = &stk7700d_mt2266_pll_config,
 247
 248                .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 249                .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 250                .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 251        },
 252        {       .output_mpeg2_in_188_bytes = 1,
 253                .hostbus_diversity = 1,
 254                .tuner_is_baseband = 1,
 255
 256                .agc_config_count = 2,
 257                .agc = stk7700d_7000p_mt2266_agc_config,
 258                .bw  = &stk7700d_mt2266_pll_config,
 259
 260                .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 261                .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 262                .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 263        }
 264};
 265
 266static struct mt2266_config stk7700d_mt2266_config[2] = {
 267        {       .i2c_address = 0x60
 268        },
 269        {       .i2c_address = 0x60
 270        }
 271};
 272
 273static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
 274{
 275        struct dib0700_adapter_state *state = adap->priv;
 276
 277        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 278                return -ENODEV;
 279
 280        if (adap->id == 0) {
 281                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 282                msleep(10);
 283                dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 284                dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 285                dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 286                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 287                msleep(10);
 288                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 289                msleep(10);
 290                if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 291                                             stk7700d_dib7000p_mt2266_config)
 292                    != 0) {
 293                        err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
 294                        dvb_detach(state->dib7000p_ops.set_wbd_ref);
 295                        return -ENODEV;
 296                }
 297        }
 298
 299        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
 300                           0x80 + (adap->id << 1),
 301                           &stk7700d_dib7000p_mt2266_config[adap->id]);
 302
 303        return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 304}
 305
 306static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 307{
 308        struct dib0700_adapter_state *state = adap->priv;
 309
 310        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 311                return -ENODEV;
 312
 313        if (adap->id == 0) {
 314                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 315                msleep(10);
 316                dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 317                dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 318                dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 319                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 320                msleep(10);
 321                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 322                msleep(10);
 323                dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 324                if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
 325                                             stk7700d_dib7000p_mt2266_config)
 326                    != 0) {
 327                        err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
 328                        dvb_detach(state->dib7000p_ops.set_wbd_ref);
 329                        return -ENODEV;
 330                }
 331        }
 332
 333        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
 334                           0x80 + (adap->id << 1),
 335                           &stk7700d_dib7000p_mt2266_config[adap->id]);
 336
 337        return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 338}
 339
 340static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 341{
 342        struct i2c_adapter *tun_i2c;
 343        struct dib0700_adapter_state *state = adap->priv;
 344
 345        tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 346                                            DIBX000_I2C_INTERFACE_TUNER, 1);
 347        return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
 348                &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
 349}
 350
 351/* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
 352static struct dibx000_agc_config xc3028_agc_config = {
 353        .band_caps = BAND_VHF | BAND_UHF,
 354        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
 355         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
 356         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 357        .setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 358        .inv_gain = 712,
 359        .time_stabiliz = 21,
 360        .alpha_level = 0,
 361        .thlock = 118,
 362        .wbd_inv = 0,
 363        .wbd_ref = 2867,
 364        .wbd_sel = 0,
 365        .wbd_alpha = 2,
 366        .agc1_max = 0,
 367        .agc1_min = 0,
 368        .agc2_max = 39718,
 369        .agc2_min = 9930,
 370        .agc1_pt1 = 0,
 371        .agc1_pt2 = 0,
 372        .agc1_pt3 = 0,
 373        .agc1_slope1 = 0,
 374        .agc1_slope2 = 0,
 375        .agc2_pt1 = 0,
 376        .agc2_pt2 = 128,
 377        .agc2_slope1 = 29,
 378        .agc2_slope2 = 29,
 379        .alpha_mant = 17,
 380        .alpha_exp = 27,
 381        .beta_mant = 23,
 382        .beta_exp = 51,
 383        .perform_agc_softsplit = 1,
 384};
 385
 386/* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
 387static struct dibx000_bandwidth_config xc3028_bw_config = {
 388        .internal = 60000,
 389        .sampling = 30000,
 390        .pll_prediv = 1,
 391        .pll_ratio = 8,
 392        .pll_range = 3,
 393        .pll_reset = 1,
 394        .pll_bypass = 0,
 395        .enable_refdiv = 0,
 396        .bypclk_div = 0,
 397        .IO_CLK_en_core = 1,
 398        .ADClkSrc = 1,
 399        .modulo = 0,
 400        .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
 401        .ifreq = (1 << 25) | 5816102,  /* ifreq = 5.200000 MHz */
 402        .timf = 20452225,
 403        .xtal_hz = 30000000,
 404};
 405
 406static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
 407        .output_mpeg2_in_188_bytes = 1,
 408        .tuner_is_baseband = 1,
 409
 410        .agc_config_count = 1,
 411        .agc = &xc3028_agc_config,
 412        .bw  = &xc3028_bw_config,
 413
 414        .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 415        .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 416        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 417};
 418
 419static int stk7700ph_xc3028_callback(void *ptr, int component,
 420                                     int command, int arg)
 421{
 422        struct dvb_usb_adapter *adap = ptr;
 423        struct dib0700_adapter_state *state = adap->priv;
 424
 425        switch (command) {
 426        case XC2028_TUNER_RESET:
 427                /* Send the tuner in then out of reset */
 428                state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
 429                msleep(10);
 430                state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
 431                break;
 432        case XC2028_RESET_CLK:
 433        case XC2028_I2C_FLUSH:
 434                break;
 435        default:
 436                err("%s: unknown command %d, arg %d\n", __func__,
 437                        command, arg);
 438                return -EINVAL;
 439        }
 440        return 0;
 441}
 442
 443static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
 444        .fname = XC2028_DEFAULT_FIRMWARE,
 445        .max_len = 64,
 446        .demod = XC3028_FE_DIBCOM52,
 447};
 448
 449static struct xc2028_config stk7700ph_xc3028_config = {
 450        .i2c_addr = 0x61,
 451        .ctrl = &stk7700ph_xc3028_ctrl,
 452};
 453
 454static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 455{
 456        struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 457        struct dib0700_adapter_state *state = adap->priv;
 458
 459        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 460                return -ENODEV;
 461
 462        if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 463            desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
 464                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 465        else
 466                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 467        msleep(20);
 468        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 469        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 470        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 471        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 472        msleep(10);
 473        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 474        msleep(20);
 475        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 476        msleep(10);
 477
 478        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
 479                                     &stk7700ph_dib7700_xc3028_config) != 0) {
 480                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
 481                    __func__);
 482                dvb_detach(state->dib7000p_ops.set_wbd_ref);
 483                return -ENODEV;
 484        }
 485
 486        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
 487                &stk7700ph_dib7700_xc3028_config);
 488
 489        return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 490}
 491
 492static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
 493{
 494        struct i2c_adapter *tun_i2c;
 495        struct dib0700_adapter_state *state = adap->priv;
 496
 497        tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 498                DIBX000_I2C_INTERFACE_TUNER, 1);
 499
 500        stk7700ph_xc3028_config.i2c_adap = tun_i2c;
 501
 502        /* FIXME: generalize & move to common area */
 503        adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
 504
 505        return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
 506                == NULL ? -ENODEV : 0;
 507}
 508
 509#define DEFAULT_RC_INTERVAL 50
 510
 511/*
 512 * This function is used only when firmware is < 1.20 version. Newer
 513 * firmwares use bulk mode, with functions implemented at dib0700_core,
 514 * at dib0700_rc_urb_completion()
 515 */
 516static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
 517{
 518        enum rc_proto protocol;
 519        u32 scancode;
 520        u8 toggle;
 521        int i;
 522        struct dib0700_state *st = d->priv;
 523
 524        if (st->fw_version >= 0x10200) {
 525                /* For 1.20 firmware , We need to keep the RC polling
 526                   callback so we can reuse the input device setup in
 527                   dvb-usb-remote.c.  However, the actual work is being done
 528                   in the bulk URB completion handler. */
 529                return 0;
 530        }
 531
 532        st->buf[0] = REQUEST_POLL_RC;
 533        st->buf[1] = 0;
 534
 535        i = dib0700_ctrl_rd(d, st->buf, 2, st->buf, 4);
 536        if (i <= 0) {
 537                err("RC Query Failed");
 538                return -EIO;
 539        }
 540
 541        /* losing half of KEY_0 events from Philipps rc5 remotes.. */
 542        if (st->buf[0] == 0 && st->buf[1] == 0
 543            && st->buf[2] == 0 && st->buf[3] == 0)
 544                return 0;
 545
 546        /* info("%d: %2X %2X %2X %2X",dvb_usb_dib0700_ir_proto,(int)st->buf[3 - 2],(int)st->buf[3 - 3],(int)st->buf[3 - 1],(int)st->buf[3]);  */
 547
 548        dib0700_rc_setup(d, NULL); /* reset ir sensor data to prevent false events */
 549
 550        switch (d->props.rc.core.protocol) {
 551        case RC_PROTO_BIT_NEC:
 552                /* NEC protocol sends repeat code as 0 0 0 FF */
 553                if ((st->buf[3 - 2] == 0x00) && (st->buf[3 - 3] == 0x00) &&
 554                    (st->buf[3] == 0xff)) {
 555                        rc_repeat(d->rc_dev);
 556                        return 0;
 557                }
 558
 559                protocol = RC_PROTO_NEC;
 560                scancode = RC_SCANCODE_NEC(st->buf[3 - 2], st->buf[3 - 3]);
 561                toggle = 0;
 562                break;
 563
 564        default:
 565                /* RC-5 protocol changes toggle bit on new keypress */
 566                protocol = RC_PROTO_RC5;
 567                scancode = RC_SCANCODE_RC5(st->buf[3 - 2], st->buf[3 - 3]);
 568                toggle = st->buf[3 - 1];
 569                break;
 570        }
 571
 572        rc_keydown(d->rc_dev, protocol, scancode, toggle);
 573        return 0;
 574}
 575
 576/* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 577static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 578        BAND_UHF | BAND_VHF,
 579
 580        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 581         * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 582        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
 583        | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 584
 585        712,
 586        41,
 587
 588        0,
 589        118,
 590
 591        0,
 592        4095,
 593        0,
 594        0,
 595
 596        42598,
 597        17694,
 598        45875,
 599        2621,
 600        0,
 601        76,
 602        139,
 603        52,
 604        59,
 605        107,
 606        172,
 607        57,
 608        70,
 609
 610        21,
 611        25,
 612        28,
 613        48,
 614
 615        1,
 616        {  0,
 617           107,
 618           51800,
 619           24700
 620        },
 621};
 622
 623static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 624        .band_caps = BAND_UHF | BAND_VHF,
 625        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 626         * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
 627        .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
 628        .inv_gain = 712,
 629        .time_stabiliz = 41,
 630        .alpha_level = 0,
 631        .thlock = 118,
 632        .wbd_inv = 0,
 633        .wbd_ref = 4095,
 634        .wbd_sel = 0,
 635        .wbd_alpha = 0,
 636        .agc1_max = 42598,
 637        .agc1_min = 16384,
 638        .agc2_max = 42598,
 639        .agc2_min = 0,
 640        .agc1_pt1 = 0,
 641        .agc1_pt2 = 137,
 642        .agc1_pt3 = 255,
 643        .agc1_slope1 = 0,
 644        .agc1_slope2 = 255,
 645        .agc2_pt1 = 0,
 646        .agc2_pt2 = 0,
 647        .agc2_slope1 = 0,
 648        .agc2_slope2 = 41,
 649        .alpha_mant = 15,
 650        .alpha_exp = 25,
 651        .beta_mant = 28,
 652        .beta_exp = 48,
 653        .perform_agc_softsplit = 0,
 654};
 655
 656static struct dibx000_bandwidth_config stk7700p_pll_config = {
 657        .internal = 60000,
 658        .sampling = 30000,
 659        .pll_prediv = 1,
 660        .pll_ratio = 8,
 661        .pll_range = 3,
 662        .pll_reset = 1,
 663        .pll_bypass = 0,
 664        .enable_refdiv = 0,
 665        .bypclk_div = 0,
 666        .IO_CLK_en_core = 1,
 667        .ADClkSrc = 1,
 668        .modulo = 0,
 669        .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 670        .ifreq = 60258167,
 671        .timf = 20452225,
 672        .xtal_hz = 30000000,
 673};
 674
 675static struct dib7000m_config stk7700p_dib7000m_config = {
 676        .dvbt_mode = 1,
 677        .output_mpeg2_in_188_bytes = 1,
 678        .quartz_direct = 1,
 679
 680        .agc_config_count = 1,
 681        .agc = &stk7700p_7000m_mt2060_agc_config,
 682        .bw  = &stk7700p_pll_config,
 683
 684        .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 685        .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 686        .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 687};
 688
 689static struct dib7000p_config stk7700p_dib7000p_config = {
 690        .output_mpeg2_in_188_bytes = 1,
 691
 692        .agc_config_count = 1,
 693        .agc = &stk7700p_7000p_mt2060_agc_config,
 694        .bw  = &stk7700p_pll_config,
 695
 696        .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 697        .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 698        .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 699};
 700
 701static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 702{
 703        struct dib0700_state *st = adap->dev->priv;
 704        struct dib0700_adapter_state *state = adap->priv;
 705
 706        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 707                return -ENODEV;
 708
 709        /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 710
 711        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 712        dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 713
 714        dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 715        dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 716
 717        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 718        dib0700_ctrl_clock(adap->dev, 72, 1);
 719        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 720
 721        dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 722
 723        st->mt2060_if1[0] = 1220;
 724
 725        if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) {
 726                adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 727                st->is_dib7000pc = 1;
 728        } else {
 729                memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops));
 730                adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 731        }
 732
 733        return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
 734}
 735
 736static struct mt2060_config stk7700p_mt2060_config = {
 737        0x60
 738};
 739
 740static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 741{
 742        struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
 743        struct dib0700_state *st = adap->dev->priv;
 744        struct i2c_adapter *tun_i2c;
 745        struct dib0700_adapter_state *state = adap->priv;
 746        s8 a;
 747        int if1=1220;
 748
 749        if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
 750                adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
 751                if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
 752        }
 753        if (st->is_dib7000pc)
 754                tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 755        else
 756                tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 757
 758        return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
 759                if1) == NULL ? -ENODEV : 0;
 760}
 761
 762/* DIB7070 generic */
 763static struct dibx000_agc_config dib7070_agc_config = {
 764        .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 765        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 766         * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
 767        .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
 768        .inv_gain = 600,
 769        .time_stabiliz = 10,
 770        .alpha_level = 0,
 771        .thlock = 118,
 772        .wbd_inv = 0,
 773        .wbd_ref = 3530,
 774        .wbd_sel = 1,
 775        .wbd_alpha = 5,
 776        .agc1_max = 65535,
 777        .agc1_min = 0,
 778        .agc2_max = 65535,
 779        .agc2_min = 0,
 780        .agc1_pt1 = 0,
 781        .agc1_pt2 = 40,
 782        .agc1_pt3 = 183,
 783        .agc1_slope1 = 206,
 784        .agc1_slope2 = 255,
 785        .agc2_pt1 = 72,
 786        .agc2_pt2 = 152,
 787        .agc2_slope1 = 88,
 788        .agc2_slope2 = 90,
 789        .alpha_mant = 17,
 790        .alpha_exp = 27,
 791        .beta_mant = 23,
 792        .beta_exp = 51,
 793        .perform_agc_softsplit = 0,
 794};
 795
 796static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 797{
 798        struct dvb_usb_adapter *adap = fe->dvb->priv;
 799        struct dib0700_adapter_state *state = adap->priv;
 800
 801        deb_info("reset: %d", onoff);
 802        return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
 803}
 804
 805static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 806{
 807        struct dvb_usb_adapter *adap = fe->dvb->priv;
 808        struct dib0700_adapter_state *state = adap->priv;
 809
 810        deb_info("sleep: %d", onoff);
 811        return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff);
 812}
 813
 814static struct dib0070_config dib7070p_dib0070_config[2] = {
 815        {
 816                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 817                .reset = dib7070_tuner_reset,
 818                .sleep = dib7070_tuner_sleep,
 819                .clock_khz = 12000,
 820                .clock_pad_drive = 4,
 821                .charge_pump = 2,
 822        }, {
 823                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 824                .reset = dib7070_tuner_reset,
 825                .sleep = dib7070_tuner_sleep,
 826                .clock_khz = 12000,
 827                .charge_pump = 2,
 828        }
 829};
 830
 831static struct dib0070_config dib7770p_dib0070_config = {
 832         .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 833         .reset = dib7070_tuner_reset,
 834         .sleep = dib7070_tuner_sleep,
 835         .clock_khz = 12000,
 836         .clock_pad_drive = 0,
 837         .flip_chip = 1,
 838         .charge_pump = 2,
 839};
 840
 841static int dib7070_set_param_override(struct dvb_frontend *fe)
 842{
 843        struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 844        struct dvb_usb_adapter *adap = fe->dvb->priv;
 845        struct dib0700_adapter_state *state = adap->priv;
 846
 847        u16 offset;
 848        u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
 849        switch (band) {
 850                case BAND_VHF: offset = 950; break;
 851                case BAND_UHF:
 852                default: offset = 550; break;
 853        }
 854        deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 855        state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 856        return state->set_param_save(fe);
 857}
 858
 859static int dib7770_set_param_override(struct dvb_frontend *fe)
 860{
 861        struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 862        struct dvb_usb_adapter *adap = fe->dvb->priv;
 863        struct dib0700_adapter_state *state = adap->priv;
 864
 865        u16 offset;
 866        u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
 867        switch (band) {
 868        case BAND_VHF:
 869                state->dib7000p_ops.set_gpio(fe, 0, 0, 1);
 870                offset = 850;
 871                break;
 872        case BAND_UHF:
 873        default:
 874                state->dib7000p_ops.set_gpio(fe, 0, 0, 0);
 875                offset = 250;
 876                break;
 877        }
 878        deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 879        state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 880        return state->set_param_save(fe);
 881}
 882
 883static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
 884{
 885        struct dib0700_adapter_state *st = adap->priv;
 886        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
 887                         DIBX000_I2C_INTERFACE_TUNER, 1);
 888
 889        if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
 890                       &dib7770p_dib0070_config) == NULL)
 891                return -ENODEV;
 892
 893        st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
 894        adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
 895        return 0;
 896}
 897
 898static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 899{
 900        struct dib0700_adapter_state *st = adap->priv;
 901        struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 902
 903        if (adap->id == 0) {
 904                if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
 905                        return -ENODEV;
 906        } else {
 907                if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
 908                        return -ENODEV;
 909        }
 910
 911        st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
 912        adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
 913        return 0;
 914}
 915
 916static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
 917                u16 pid, int onoff)
 918{
 919        struct dib0700_adapter_state *state = adapter->priv;
 920        struct dib0700_state *st = adapter->dev->priv;
 921
 922        if (st->is_dib7000pc)
 923                return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 924        return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 925}
 926
 927static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 928{
 929        struct dib0700_state *st = adapter->dev->priv;
 930        struct dib0700_adapter_state *state = adapter->priv;
 931        if (st->is_dib7000pc)
 932                return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 933        return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 934}
 935
 936static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
 937{
 938        struct dib0700_adapter_state *state = adapter->priv;
 939        return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
 940}
 941
 942static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
 943{
 944        struct dib0700_adapter_state *state = adapter->priv;
 945        return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
 946}
 947
 948static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
 949        .internal = 60000,
 950        .sampling = 15000,
 951        .pll_prediv = 1,
 952        .pll_ratio = 20,
 953        .pll_range = 3,
 954        .pll_reset = 1,
 955        .pll_bypass = 0,
 956        .enable_refdiv = 0,
 957        .bypclk_div = 0,
 958        .IO_CLK_en_core = 1,
 959        .ADClkSrc = 1,
 960        .modulo = 2,
 961        .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
 962        .ifreq = (0 << 25) | 0,
 963        .timf = 20452225,
 964        .xtal_hz = 12000000,
 965};
 966
 967static struct dib7000p_config dib7070p_dib7000p_config = {
 968        .output_mpeg2_in_188_bytes = 1,
 969
 970        .agc_config_count = 1,
 971        .agc = &dib7070_agc_config,
 972        .bw  = &dib7070_bw_config_12_mhz,
 973        .tuner_is_baseband = 1,
 974        .spur_protect = 1,
 975
 976        .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 977        .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 978        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 979
 980        .hostbus_diversity = 1,
 981};
 982
 983/* STK7070P */
 984static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 985{
 986        struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
 987        struct dib0700_adapter_state *state = adap->priv;
 988
 989        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
 990                return -ENODEV;
 991
 992        if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
 993            p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
 994                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
 995        else
 996                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 997        msleep(10);
 998        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 999        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1000        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1001        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1002
1003        dib0700_ctrl_clock(adap->dev, 72, 1);
1004
1005        msleep(10);
1006        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1007        msleep(10);
1008        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1009
1010        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1011                                     &dib7070p_dib7000p_config) != 0) {
1012                err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
1013                    __func__);
1014                dvb_detach(state->dib7000p_ops.set_wbd_ref);
1015                return -ENODEV;
1016        }
1017
1018        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1019                &dib7070p_dib7000p_config);
1020        return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1021}
1022
1023/* STK7770P */
1024static 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
1042static 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 */
1082static 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
1174static 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
1193static 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
1230static 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
1238static 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
1246static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1247    { 240,      7},
1248    { 0xffff,   6},
1249};
1250
1251static 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
1283static 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
1305static 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
1326static 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
1334static 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 */
1343static 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 */
1375static 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
1408static 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 */
1425static 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
1512static 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
1536static 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
1544static 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
1553static 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
1595static 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
1604static 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
1626static 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
1650static 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
1736static 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
1750static 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
1779static 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
1793static 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
1816static 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 */
1858static 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
1950static 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
1969static 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
1988static 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
1996static 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
2027struct 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
2034struct dibx090p_best_adc {
2035        u32 timf;
2036        u32 pll_loopdiv;
2037        u32 pll_prediv;
2038};
2039
2040static 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
2112static 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
2144static 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
2180static 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 */
2201static 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
2206static 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
2211static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2212{
2213        return dib9000_set_gpio(fe, 5, 0, !onoff);
2214}
2215
2216static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2217{
2218        return dib9000_set_gpio(fe, 0, 0, onoff);
2219}
2220
2221static 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
2274static 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
2296static 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
2328static 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
2346static 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
2383static 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
2425static 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
2453static 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
2507static 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 */
2553static 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
2626static 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
2654static 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
2662static 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
2680static 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
2688static 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
2770static 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
2789static 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
2817static 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
2834static 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
2892static 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
2922static 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
2950static 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
2983static 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
3043static 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
3072static 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
3091static 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
3131static 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
3157static 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
3176static 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
3195static 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
3231static 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 */
3254static 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
3286static 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
3301static 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
3325static 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
3336static 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
3353static 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 */
3371static 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 */
3413static 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 */
3434static 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
3469static 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
3488static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3489        .i2c_address      = 0x64,
3490        .if_khz           = 5380,
3491};
3492
3493static 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
3503static 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
3522static 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
3553static 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 */
3573static 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 */
3596static 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
3639static 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
3647static 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
3668static 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
3680static 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 */
3696static 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
3726static 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
3733static 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
3807fail_tuner_module:
3808        i2c_unregister_device(client_tuner);
3809fail_tuner_device:
3810        module_put(client_demod->dev.driver->owner);
3811fail_demod_module:
3812        i2c_unregister_device(client_demod);
3813fail_demod_device:
3814        return -ENODEV;
3815}
3816
3817
3818/* DVB-USB and USB stuff follows */
3819struct usb_device_id dib0700_usb_id_table[] = {
3820/* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
3821        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
3822        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
3823        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
3824        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
3825/* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
3826        { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
3827        { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
3828        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
3829        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
3830/* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
3831        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
3832        { USB_DEVICE(USB_VID_TERRATEC,
3833                        USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
3834        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
3835        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
3836/* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
3837        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
3838        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
3839        { USB_DEVICE(USB_VID_PINNACLE,
3840                        USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
3841        { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
3842/* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
3843        { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
3844        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
3845        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
3846        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
3847/* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
3848        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
3849        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
3850        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
3851        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
3852/* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
3853        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
3854        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
3855        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
3856        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
3857/* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
3858        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
3859        { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
3860        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
3861        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
3862/* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
3863        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
3864        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
3865        { USB_DEVICE(USB_VID_TERRATEC,
3866                        USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
3867        { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
3868/* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
3869        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
3870        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
3871        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
3872        { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
3873/* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
3874        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
3875        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
3876        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
3877        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
3878/* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
3879        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
3880        { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
3881        { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
3882        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
3883/* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
3884        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
3885        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
3886        { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
3887        { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
3888/* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
3889        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
3890        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
3891        { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
3892        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090M) },
3893/* 70 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM8096MD) },
3894        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090MD) },
3895        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM7090) },
3896        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7090PVR) },
3897        { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
3898/* 75 */{ USB_DEVICE(USB_VID_MEDION,    USB_PID_CREATIX_CTX1921) },
3899        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E) },
3900        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E_SE) },
3901        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7790P) },
3902        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE8096P) },
3903/* 80 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_2) },
3904        { USB_DEVICE(USB_VID_PCTV,      USB_PID_PCTV_2002E) },
3905        { USB_DEVICE(USB_VID_PCTV,      USB_PID_PCTV_2002E_SE) },
3906        { USB_DEVICE(USB_VID_PCTV,      USB_PID_DIBCOM_STK8096PVR) },
3907        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096PVR) },
3908/* 85 */{ USB_DEVICE(USB_VID_HAMA,      USB_PID_HAMA_DVBT_HYBRID) },
3909        { USB_DEVICE(USB_VID_MICROSOFT, USB_PID_XBOX_ONE_TUNER) },
3910        { 0 }           /* Terminating entry */
3911};
3912MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
3913
3914#define DIB0700_DEFAULT_DEVICE_PROPERTIES \
3915        .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
3916        .usb_ctrl          = DEVICE_SPECIFIC, \
3917        .firmware          = "dvb-usb-dib0700-1.20.fw", \
3918        .download_firmware = dib0700_download_firmware, \
3919        .no_reconnect      = 1, \
3920        .size_of_priv      = sizeof(struct dib0700_state), \
3921        .i2c_algo          = &dib0700_i2c_algo, \
3922        .identify_state    = dib0700_identify_state
3923
3924#define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
3925        .streaming_ctrl   = dib0700_streaming_ctrl, \
3926        .stream = { \
3927                .type = USB_BULK, \
3928                .count = 4, \
3929                .endpoint = ep, \
3930                .u = { \
3931                        .bulk = { \
3932                                .buffersize = 39480, \
3933                        } \
3934                } \
3935        }
3936
3937#define DIB0700_NUM_FRONTENDS(n) \
3938        .num_frontends = n, \
3939        .size_of_priv     = sizeof(struct dib0700_adapter_state)
3940
3941struct dvb_usb_device_properties dib0700_devices[] = {
3942        {
3943                DIB0700_DEFAULT_DEVICE_PROPERTIES,
3944
3945                .num_adapters = 1,
3946                .adapter = {