drivers/media/usb/dvb-usb/dib0700_devices.c

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