SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/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-7 DiBcom, SA
   8  */
   9 #include "dib0700.h"
  10
  11 #include "dib3000mc.h"
  12 #include "dib7000m.h"
  13 #include "dib7000p.h"
  14 #include "mt2060.h"
  15 #include "mt2266.h"
  16 #include "dib0070.h"
  17
  18 static int force_lna_activation;
  19 module_param(force_lna_activation, int, 0644);
  20 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
  21                 "if applicable for the device (default: 0=automatic/off).");
  22
  23 struct dib0700_adapter_state {
  24         int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
  25 };
  26
  27 /* Hauppauge Nova-T 500 (aka Bristol)
  28  *  has a LNA on GPIO0 which is enabled by setting 1 */
  29 static struct mt2060_config bristol_mt2060_config[2] = {
  30         {
  31                 .i2c_address = 0x60,
  32                 .clock_out   = 3,
  33         }, {
  34                 .i2c_address = 0x61,
  35         }
  36 };
  37
  38 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
  39         .band_caps = BAND_VHF | BAND_UHF,
  40         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
  41
  42         .agc1_max = 42598,
  43         .agc1_min = 17694,
  44         .agc2_max = 45875,
  45         .agc2_min = 0,
  46
  47         .agc1_pt1 = 0,
  48         .agc1_pt2 = 59,
  49
  50         .agc1_slope1 = 0,
  51         .agc1_slope2 = 69,
  52
  53         .agc2_pt1 = 0,
  54         .agc2_pt2 = 59,
  55
  56         .agc2_slope1 = 111,
  57         .agc2_slope2 = 28,
  58 };
  59
  60 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
  61         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  62                 .max_time     = 0x196,
  63                 .ln_adc_level = 0x1cc7,
  64                 .output_mpeg2_in_188_bytes = 1,
  65         },
  66         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
  67                 .max_time     = 0x196,
  68                 .ln_adc_level = 0x1cc7,
  69                 .output_mpeg2_in_188_bytes = 1,
  70         }
  71 };
  72
  73 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
  74 {
  75         struct dib0700_state *st = adap->dev->priv;
  76         if (adap->id == 0) {
  77                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
  78                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
  79                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
  80                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
  81
  82                 if (force_lna_activation)
  83                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
  84                 else
  85                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
  86
  87                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
  88                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
  89                         return -ENODEV;
  90                 }
  91         }
  92         st->mt2060_if1[adap->id] = 1220;
  93         return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
  94                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
  95 }
  96
  97 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
  98 {
  99         struct dib0700_state *st = adap->dev->priv;
 100         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
 101         return dvb_attach(mt2060_attach,adap->fe, tun_i2c, &bristol_mt2060_config[adap->id],
 102                 st->mt2060_if1[adap->id]) == NULL ? -ENODEV : 0;
 103 }
 104
 105 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
 106
 107 /* MT226x */
 108 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
 109         {
 110                 BAND_UHF, // band_caps
 111
 112                 /* 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,
 113                 * 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 */
 114                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
 115
 116                 1130,  // inv_gain
 117                 21,  // time_stabiliz
 118
 119                 0,  // alpha_level
 120                 118,  // thlock
 121
 122                 0,     // wbd_inv
 123                 3530,  // wbd_ref
 124                 1,     // wbd_sel
 125                 0,     // wbd_alpha
 126
 127                 65535,  // agc1_max
 128                 33770,  // agc1_min
 129                 65535,  // agc2_max
 130                 23592,  // agc2_min
 131
 132                 0,    // agc1_pt1
 133                 62,   // agc1_pt2
 134                 255,  // agc1_pt3
 135                 64,   // agc1_slope1
 136                 64,   // agc1_slope2
 137                 132,  // agc2_pt1
 138                 192,  // agc2_pt2
 139                 80,   // agc2_slope1
 140                 80,   // agc2_slope2
 141
 142                 17,  // alpha_mant
 143                 27,  // alpha_exp
 144                 23,  // beta_mant
 145                 51,  // beta_exp
 146
 147                 1,  // perform_agc_softsplit
 148         }, {
 149                 BAND_VHF | BAND_LBAND, // band_caps
 150
 151                 /* 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,
 152                 * 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 */
 153                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
 154
 155                 2372, // inv_gain
 156                 21,   // time_stabiliz
 157
 158                 0,    // alpha_level
 159                 118,  // thlock
 160
 161                 0,    // wbd_inv
 162                 3530, // wbd_ref
 163                 1,     // wbd_sel
 164                 0,    // wbd_alpha
 165
 166                 65535, // agc1_max
 167                 0,     // agc1_min
 168                 65535, // agc2_max
 169                 23592, // agc2_min
 170
 171                 0,    // agc1_pt1
 172                 128,  // agc1_pt2
 173                 128,  // agc1_pt3
 174                 128,  // agc1_slope1
 175                 0,    // agc1_slope2
 176                 128,  // agc2_pt1
 177                 253,  // agc2_pt2
 178                 81,   // agc2_slope1
 179                 0,    // agc2_slope2
 180
 181                 17,  // alpha_mant
 182                 27,  // alpha_exp
 183                 23,  // beta_mant
 184                 51,  // beta_exp
 185
 186                 1,  // perform_agc_softsplit
 187         }
 188 };
 189
 190 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
 191         60000, 30000, // internal, sampling
 192         1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
 193         0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
 194         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
 195         0, // ifreq
 196         20452225, // timf
 197 };
 198
 199 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
 200         {       .output_mpeg2_in_188_bytes = 1,
 201                 .hostbus_diversity = 1,
 202                 .tuner_is_baseband = 1,
 203
 204                 .agc_config_count = 2,
 205                 .agc = stk7700d_7000p_mt2266_agc_config,
 206                 .bw  = &stk7700d_mt2266_pll_config,
 207
 208                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 209                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 210                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 211         },
 212         {       .output_mpeg2_in_188_bytes = 1,
 213                 .hostbus_diversity = 1,
 214                 .tuner_is_baseband = 1,
 215
 216                 .agc_config_count = 2,
 217                 .agc = stk7700d_7000p_mt2266_agc_config,
 218                 .bw  = &stk7700d_mt2266_pll_config,
 219
 220                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 221                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 222                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 223         }
 224 };
 225
 226 static struct mt2266_config stk7700d_mt2266_config[2] = {
 227         {       .i2c_address = 0x60
 228         },
 229         {       .i2c_address = 0x60
 230         }
 231 };
 232
 233 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
 234 {
 235         if (adap->id == 0) {
 236                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 237                 msleep(10);
 238                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 239                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 240                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 241                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 242                 msleep(10);
 243                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 244                 msleep(10);
 245                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 246                 dib7000p_i2c_enumeration(&adap->dev->i2c_adap,2,18,stk7700d_dib7000p_mt2266_config);
 247         }
 248
 249         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
 250                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
 251
 252         return adap->fe == NULL ? -ENODEV : 0;
 253 }
 254
 255 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 256 {
 257         struct i2c_adapter *tun_i2c;
 258         tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 259         return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
 260                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;;
 261 }
 262
 263 #define DEFAULT_RC_INTERVAL 150
 264
 265 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 266
 267 static int dib0700_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
 268 {
 269         u8 key[4];
 270         int i;
 271         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
 272         struct dib0700_state *st = d->priv;
 273         *event = 0;
 274         *state = REMOTE_NO_KEY_PRESSED;
 275         i=dib0700_ctrl_rd(d,rc_request,2,key,4);
 276         if (i<=0) {
 277                 err("RC Query Failed");
 278                 return -1;
 279         }
 280         if (key[0]==0 && key[1]==0 && key[2]==0 && key[3]==0) return 0;
 281         if (key[3-1]!=st->rc_toggle) {
 282                 for (i=0;i<d->props.rc_key_map_size; i++) {
 283                         if (keymap[i].custom == key[3-2] && keymap[i].data == key[3-3]) {
 284                                 *event = keymap[i].event;
 285                                 *state = REMOTE_KEY_PRESSED;
 286                                 st->rc_toggle=key[3-1];
 287                                 return 0;
 288                         }
 289                 }
 290                 err("Unknown remote controller key : %2X %2X",(int)key[3-2],(int)key[3-3]);
 291         }
 292         return 0;
 293 }
 294
 295 static struct dvb_usb_rc_key dib0700_rc_keys[] = {
 296         /* Key codes for the tiny Pinnacle remote*/
 297         { 0x07, 0x00, KEY_MUTE },
 298         { 0x07, 0x01, KEY_MENU }, // Pinnacle logo
 299         { 0x07, 0x39, KEY_POWER },
 300         { 0x07, 0x03, KEY_VOLUMEUP },
 301         { 0x07, 0x09, KEY_VOLUMEDOWN },
 302         { 0x07, 0x06, KEY_CHANNELUP },
 303         { 0x07, 0x0c, KEY_CHANNELDOWN },
 304         { 0x07, 0x0f, KEY_1 },
 305         { 0x07, 0x15, KEY_2 },
 306         { 0x07, 0x10, KEY_3 },
 307         { 0x07, 0x18, KEY_4 },
 308         { 0x07, 0x1b, KEY_5 },
 309         { 0x07, 0x1e, KEY_6 },
 310         { 0x07, 0x11, KEY_7 },
 311         { 0x07, 0x21, KEY_8 },
 312         { 0x07, 0x12, KEY_9 },
 313         { 0x07, 0x27, KEY_0 },
 314         { 0x07, 0x24, KEY_SCREEN }, // 'Square' key
 315         { 0x07, 0x2a, KEY_TEXT },   // 'T' key
 316         { 0x07, 0x2d, KEY_REWIND },
 317         { 0x07, 0x30, KEY_PLAY },
 318         { 0x07, 0x33, KEY_FASTFORWARD },
 319         { 0x07, 0x36, KEY_RECORD },
 320         { 0x07, 0x3c, KEY_STOP },
 321         { 0x07, 0x3f, KEY_CANCEL }, // '?' key
 322         /* Key codes for the Terratec Cinergy DT XS Diversity, similar to cinergyT2.c */
 323         { 0xeb, 0x01, KEY_POWER },
 324         { 0xeb, 0x02, KEY_1 },
 325         { 0xeb, 0x03, KEY_2 },
 326         { 0xeb, 0x04, KEY_3 },
 327         { 0xeb, 0x05, KEY_4 },
 328         { 0xeb, 0x06, KEY_5 },
 329         { 0xeb, 0x07, KEY_6 },
 330         { 0xeb, 0x08, KEY_7 },
 331         { 0xeb, 0x09, KEY_8 },
 332         { 0xeb, 0x0a, KEY_9 },
 333         { 0xeb, 0x0b, KEY_VIDEO },
 334         { 0xeb, 0x0c, KEY_0 },
 335         { 0xeb, 0x0d, KEY_REFRESH },
 336         { 0xeb, 0x0f, KEY_EPG },
 337         { 0xeb, 0x10, KEY_UP },
 338         { 0xeb, 0x11, KEY_LEFT },
 339         { 0xeb, 0x12, KEY_OK },
 340         { 0xeb, 0x13, KEY_RIGHT },
 341         { 0xeb, 0x14, KEY_DOWN },
 342         { 0xeb, 0x16, KEY_INFO },
 343         { 0xeb, 0x17, KEY_RED },
 344         { 0xeb, 0x18, KEY_GREEN },
 345         { 0xeb, 0x19, KEY_YELLOW },
 346         { 0xeb, 0x1a, KEY_BLUE },
 347         { 0xeb, 0x1b, KEY_CHANNELUP },
 348         { 0xeb, 0x1c, KEY_VOLUMEUP },
 349         { 0xeb, 0x1d, KEY_MUTE },
 350         { 0xeb, 0x1e, KEY_VOLUMEDOWN },
 351         { 0xeb, 0x1f, KEY_CHANNELDOWN },
 352         { 0xeb, 0x40, KEY_PAUSE },
 353         { 0xeb, 0x41, KEY_HOME },
 354         { 0xeb, 0x42, KEY_MENU }, /* DVD Menu */
 355         { 0xeb, 0x43, KEY_SUBTITLE },
 356         { 0xeb, 0x44, KEY_TEXT }, /* Teletext */
 357         { 0xeb, 0x45, KEY_DELETE },
 358         { 0xeb, 0x46, KEY_TV },
 359         { 0xeb, 0x47, KEY_DVD },
 360         { 0xeb, 0x48, KEY_STOP },
 361         { 0xeb, 0x49, KEY_VIDEO },
 362         { 0xeb, 0x4a, KEY_AUDIO }, /* Music */
 363         { 0xeb, 0x4b, KEY_SCREEN }, /* Pic */
 364         { 0xeb, 0x4c, KEY_PLAY },
 365         { 0xeb, 0x4d, KEY_BACK },
 366         { 0xeb, 0x4e, KEY_REWIND },
 367         { 0xeb, 0x4f, KEY_FASTFORWARD },
 368         { 0xeb, 0x54, KEY_PREVIOUS },
 369         { 0xeb, 0x58, KEY_RECORD },
 370         { 0xeb, 0x5c, KEY_NEXT },
 371
 372         /* Key codes for the Haupauge WinTV Nova-TD, copied from nova-t-usb2.c (Nova-T USB2) */
 373         { 0x1e, 0x00, KEY_0 },
 374         { 0x1e, 0x01, KEY_1 },
 375         { 0x1e, 0x02, KEY_2 },
 376         { 0x1e, 0x03, KEY_3 },
 377         { 0x1e, 0x04, KEY_4 },
 378         { 0x1e, 0x05, KEY_5 },
 379         { 0x1e, 0x06, KEY_6 },
 380         { 0x1e, 0x07, KEY_7 },
 381         { 0x1e, 0x08, KEY_8 },
 382         { 0x1e, 0x09, KEY_9 },
 383         { 0x1e, 0x0a, KEY_KPASTERISK },
 384         { 0x1e, 0x0b, KEY_RED },
 385         { 0x1e, 0x0c, KEY_RADIO },
 386         { 0x1e, 0x0d, KEY_MENU },
 387         { 0x1e, 0x0e, KEY_GRAVE }, /* # */
 388         { 0x1e, 0x0f, KEY_MUTE },
 389         { 0x1e, 0x10, KEY_VOLUMEUP },
 390         { 0x1e, 0x11, KEY_VOLUMEDOWN },
 391         { 0x1e, 0x12, KEY_CHANNEL },
 392         { 0x1e, 0x14, KEY_UP },
 393         { 0x1e, 0x15, KEY_DOWN },
 394         { 0x1e, 0x16, KEY_LEFT },
 395         { 0x1e, 0x17, KEY_RIGHT },
 396         { 0x1e, 0x18, KEY_VIDEO },
 397         { 0x1e, 0x19, KEY_AUDIO },
 398         { 0x1e, 0x1a, KEY_MEDIA },
 399         { 0x1e, 0x1b, KEY_EPG },
 400         { 0x1e, 0x1c, KEY_TV },
 401         { 0x1e, 0x1e, KEY_NEXT },
 402         { 0x1e, 0x1f, KEY_BACK },
 403         { 0x1e, 0x20, KEY_CHANNELUP },
 404         { 0x1e, 0x21, KEY_CHANNELDOWN },
 405         { 0x1e, 0x24, KEY_LAST }, /* Skip backwards */
 406         { 0x1e, 0x25, KEY_OK },
 407         { 0x1e, 0x29, KEY_BLUE},
 408         { 0x1e, 0x2e, KEY_GREEN },
 409         { 0x1e, 0x30, KEY_PAUSE },
 410         { 0x1e, 0x32, KEY_REWIND },
 411         { 0x1e, 0x34, KEY_FASTFORWARD },
 412         { 0x1e, 0x35, KEY_PLAY },
 413         { 0x1e, 0x36, KEY_STOP },
 414         { 0x1e, 0x37, KEY_RECORD },
 415         { 0x1e, 0x38, KEY_YELLOW },
 416         { 0x1e, 0x3b, KEY_GOTO },
 417         { 0x1e, 0x3d, KEY_POWER },
 418
 419         /* Key codes for the Leadtek Winfast DTV Dongle */
 420         { 0x00, 0x42, KEY_POWER },
 421         { 0x07, 0x7c, KEY_TUNER },
 422         { 0x0f, 0x4e, KEY_PRINT }, /* PREVIEW */
 423         { 0x08, 0x40, KEY_SCREEN }, /* full screen toggle*/
 424         { 0x0f, 0x71, KEY_DOT }, /* frequency */
 425         { 0x07, 0x43, KEY_0 },
 426         { 0x0c, 0x41, KEY_1 },
 427         { 0x04, 0x43, KEY_2 },
 428         { 0x0b, 0x7f, KEY_3 },
 429         { 0x0e, 0x41, KEY_4 },
 430         { 0x06, 0x43, KEY_5 },
 431         { 0x09, 0x7f, KEY_6 },
 432         { 0x0d, 0x7e, KEY_7 },
 433         { 0x05, 0x7c, KEY_8 },
 434         { 0x0a, 0x40, KEY_9 },
 435         { 0x0e, 0x4e, KEY_CLEAR },
 436         { 0x04, 0x7c, KEY_CHANNEL }, /* show channel number */
 437         { 0x0f, 0x41, KEY_LAST }, /* recall */
 438         { 0x03, 0x42, KEY_MUTE },
 439         { 0x06, 0x4c, KEY_RESERVED }, /* PIP button*/
 440         { 0x01, 0x72, KEY_SHUFFLE }, /* SNAPSHOT */
 441         { 0x0c, 0x4e, KEY_PLAYPAUSE }, /* TIMESHIFT */
 442         { 0x0b, 0x70, KEY_RECORD },
 443         { 0x03, 0x7d, KEY_VOLUMEUP },
 444         { 0x01, 0x7d, KEY_VOLUMEDOWN },
 445         { 0x02, 0x42, KEY_CHANNELUP },
 446         { 0x00, 0x7d, KEY_CHANNELDOWN },
 447 };
 448
 449 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
 450 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
 451         BAND_UHF | BAND_VHF,       // band_caps
 452
 453         /* 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,
 454          * 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 */
 455         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
 456
 457         712,  // inv_gain
 458         41,  // time_stabiliz
 459
 460         0,  // alpha_level
 461         118,  // thlock
 462
 463         0,     // wbd_inv
 464         4095,  // wbd_ref
 465         0,     // wbd_sel
 466         0,     // wbd_alpha
 467
 468         42598,  // agc1_max
 469         17694,  // agc1_min
 470         45875,  // agc2_max
 471         2621,  // agc2_min
 472         0,  // agc1_pt1
 473         76,  // agc1_pt2
 474         139,  // agc1_pt3
 475         52,  // agc1_slope1
 476         59,  // agc1_slope2
 477         107,  // agc2_pt1
 478         172,  // agc2_pt2
 479         57,  // agc2_slope1
 480         70,  // agc2_slope2
 481
 482         21,  // alpha_mant
 483         25,  // alpha_exp
 484         28,  // beta_mant
 485         48,  // beta_exp
 486
 487         1,  // perform_agc_softsplit
 488         {  0,     // split_min
 489            107,   // split_max
 490            51800, // global_split_min
 491            24700  // global_split_max
 492         },
 493 };
 494
 495 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
 496         BAND_UHF | BAND_VHF,
 497
 498         /* 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,
 499          * 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 */
 500         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
 501
 502         712, // inv_gain
 503         41,  // time_stabiliz
 504
 505         0,   // alpha_level
 506         118, // thlock
 507
 508         0,    // wbd_inv
 509         4095, // wbd_ref
 510         0,    // wbd_sel
 511         0,    // wbd_alpha
 512
 513         42598, // agc1_max
 514         16384, // agc1_min
 515         42598, // agc2_max
 516             0, // agc2_min
 517
 518           0,   // agc1_pt1
 519         137,   // agc1_pt2
 520         255,   // agc1_pt3
 521
 522           0,   // agc1_slope1
 523         255,   // agc1_slope2
 524
 525         0,     // agc2_pt1
 526         0,     // agc2_pt2
 527
 528          0,    // agc2_slope1
 529         41,    // agc2_slope2
 530
 531         15, // alpha_mant
 532         25, // alpha_exp
 533
 534         28, // beta_mant
 535         48, // beta_exp
 536
 537         0, // perform_agc_softsplit
 538 };
 539
 540 static struct dibx000_bandwidth_config stk7700p_pll_config = {
 541         60000, 30000, // internal, sampling
 542         1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
 543         0, 0, 1, 1, 0, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
 544         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
 545         60258167, // ifreq
 546         20452225, // timf
 547         30000000, // xtal
 548 };
 549
 550 static struct dib7000m_config stk7700p_dib7000m_config = {
 551         .dvbt_mode = 1,
 552         .output_mpeg2_in_188_bytes = 1,
 553         .quartz_direct = 1,
 554
 555         .agc_config_count = 1,
 556         .agc = &stk7700p_7000m_mt2060_agc_config,
 557         .bw  = &stk7700p_pll_config,
 558
 559         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 560         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 561         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 562 };
 563
 564 static struct dib7000p_config stk7700p_dib7000p_config = {
 565         .output_mpeg2_in_188_bytes = 1,
 566
 567         .agc_config_count = 1,
 568         .agc = &stk7700p_7000p_mt2060_agc_config,
 569         .bw  = &stk7700p_pll_config,
 570
 571         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
 572         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
 573         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
 574 };
 575
 576 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
 577 {
 578         struct dib0700_state *st = adap->dev->priv;
 579         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
 580
 581         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 582         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
 583
 584         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
 585         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
 586
 587         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
 588         dib0700_ctrl_clock(adap->dev, 72, 1);
 589         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
 590
 591         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
 592
 593         st->mt2060_if1[0] = 1220;
 594
 595         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
 596                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
 597                 st->is_dib7000pc = 1;
 598         } else
 599                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
 600
 601         return adap->fe == NULL ? -ENODEV : 0;
 602 }
 603
 604 static struct mt2060_config stk7700p_mt2060_config = {
 605         0x60
 606 };
 607
 608 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
 609 {
 610         struct dib0700_state *st = adap->dev->priv;
 611         struct i2c_adapter *tun_i2c;
 612
 613         if (st->is_dib7000pc)
 614                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 615         else
 616                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 617
 618         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
 619                 st->mt2060_if1[0]) == NULL ? -ENODEV : 0;
 620 }
 621
 622 /* DIB7070 generic */
 623 static struct dibx000_agc_config dib7070_agc_config = {
 624         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
 625         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
 626          * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
 627         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
 628
 629         600, // inv_gain
 630         10,  // time_stabiliz
 631
 632         0,  // alpha_level
 633         118,  // thlock
 634
 635         0,     // wbd_inv
 636         3530,  // wbd_ref
 637         1,     // wbd_sel
 638         5,     // wbd_alpha
 639
 640         65535,  // agc1_max
 641                 0,  // agc1_min
 642
 643         65535,  // agc2_max
 644         0,      // agc2_min
 645
 646         0,      // agc1_pt1
 647         40,     // agc1_pt2
 648         183,    // agc1_pt3
 649         206,    // agc1_slope1
 650         255,    // agc1_slope2
 651         72,     // agc2_pt1
 652         152,    // agc2_pt2
 653         88,     // agc2_slope1
 654         90,     // agc2_slope2
 655
 656         17,  // alpha_mant
 657         27,  // alpha_exp
 658         23,  // beta_mant
 659         51,  // beta_exp
 660
 661         0,  // perform_agc_softsplit
 662 };
 663
 664 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 665 {
 666         return dib7000p_set_gpio(fe, 8, 0, !onoff);
 667 }
 668
 669 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 670 {
 671         return dib7000p_set_gpio(fe, 9, 0, onoff);
 672 }
 673
 674 static struct dib0070_config dib7070p_dib0070_config[2] = {
 675         {
 676                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 677                 .reset = dib7070_tuner_reset,
 678                 .sleep = dib7070_tuner_sleep,
 679                 .clock_khz = 12000,
 680                 .clock_pad_drive = 4
 681         }, {
 682                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
 683                 .reset = dib7070_tuner_reset,
 684                 .sleep = dib7070_tuner_sleep,
 685                 .clock_khz = 12000,
 686
 687         }
 688 };
 689
 690 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
 691 {
 692         struct dvb_usb_adapter *adap = fe->dvb->priv;
 693         struct dib0700_adapter_state *state = adap->priv;
 694
 695         u16 offset;
 696         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
 697         switch (band) {
 698                 case BAND_VHF: offset = 950; break;
 699                 case BAND_UHF:
 700                 default: offset = 550; break;
 701         }
 702         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
 703         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
 704         return state->set_param_save(fe, fep);
 705 }
 706
 707 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 708 {
 709         struct dib0700_adapter_state *st = adap->priv;
 710         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
 711
 712         if (adap->id == 0) {
 713                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
 714                         return -ENODEV;
 715         } else {
 716                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
 717                         return -ENODEV;
 718         }
 719
 720         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
 721         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
 722         return 0;
 723 }
 724
 725 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
 726         60000, 15000, // internal, sampling
 727         1, 20, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
 728         0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
 729         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
 730         (0 << 25) | 0, // ifreq = 0.000000 MHz
 731         20452225, // timf
 732         12000000, // xtal_hz
 733 };
 734
 735 static struct dib7000p_config dib7070p_dib7000p_config = {
 736         .output_mpeg2_in_188_bytes = 1,
 737
 738         .agc_config_count = 1,
 739         .agc = &dib7070_agc_config,
 740         .bw  = &dib7070_bw_config_12_mhz,
 741
 742         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 743         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 744         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 745
 746         .hostbus_diversity = 1,
 747 };
 748
 749 /* STK7070P */
 750 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 751 {
 752         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 753         msleep(10);
 754         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 755         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 756         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 757         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 758
 759         dib0700_ctrl_clock(adap->dev, 72, 1);
 760
 761         msleep(10);
 762         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 763         msleep(10);
 764         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 765
 766         dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, &dib7070p_dib7000p_config);
 767
 768         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &dib7070p_dib7000p_config);
 769         return adap->fe == NULL ? -ENODEV : 0;
 770 }
 771
 772 /* STK7070PD */
 773 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
 774         {
 775                 .output_mpeg2_in_188_bytes = 1,
 776
 777                 .agc_config_count = 1,
 778                 .agc = &dib7070_agc_config,
 779                 .bw  = &dib7070_bw_config_12_mhz,
 780
 781                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 782                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 783                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 784
 785                 .hostbus_diversity = 1,
 786         }, {
 787                 .output_mpeg2_in_188_bytes = 1,
 788
 789                 .agc_config_count = 1,
 790                 .agc = &dib7070_agc_config,
 791                 .bw  = &dib7070_bw_config_12_mhz,
 792
 793                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
 794                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
 795                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
 796
 797                 .hostbus_diversity = 1,
 798         }
 799 };
 800
 801 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
 802 {
 803         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
 804         msleep(10);
 805         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
 806         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
 807         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
 808         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
 809
 810         dib0700_ctrl_clock(adap->dev, 72, 1);
 811
 812         msleep(10);
 813         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
 814         msleep(10);
 815         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 816
 817         dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, stk7070pd_dib7000p_config);
 818
 819         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
 820         return adap->fe == NULL ? -ENODEV : 0;
 821 }
 822
 823 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
 824 {
 825         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
 826         return adap->fe == NULL ? -ENODEV : 0;
 827 }
 828
 829 /* DVB-USB and USB stuff follows */
 830 struct usb_device_id dib0700_usb_id_table[] = {
 831 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
 832                 { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
 833
 834                 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
 835                 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
 836                 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
 837 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
 838                 { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
 839                 { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
 840                 { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
 841                 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
 842 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
 843                 { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
 844                 { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
 845                 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
 846                 { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
 847 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
 848                 { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
 849                 { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
 850                 { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
 851                 { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
 852 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
 853 /* 21 */{ USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
 854                 { 0 }           /* Terminating entry */
 855 };
 856 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
 857
 858 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
 859         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
 860         .usb_ctrl          = DEVICE_SPECIFIC, \
 861         .firmware          = "dvb-usb-dib0700-1.10.fw", \
 862         .download_firmware = dib0700_download_firmware, \
 863         .no_reconnect      = 1, \
 864         .size_of_priv      = sizeof(struct dib0700_state), \
 865         .i2c_algo          = &dib0700_i2c_algo, \
 866         .identify_state    = dib0700_identify_state
 867
 868 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
 869         .streaming_ctrl   = dib0700_streaming_ctrl, \
 870         .stream = { \
 871                 .type = USB_BULK, \
 872                 .count = 4, \
 873                 .endpoint = ep, \
 874                 .u = { \
 875                         .bulk = { \
 876                                 .buffersize = 39480, \
 877                         } \
 878                 } \
 879         }
 880
 881 struct dvb_usb_device_properties dib0700_devices[] = {
 882         {
 883                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
 884
 885                 .num_adapters = 1,
 886                 .adapter = {
 887                         {
 888                                 .frontend_attach  = stk7700p_frontend_attach,
 889                                 .tuner_attach     = stk7700p_tuner_attach,
 890
 891                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
 892                         },
 893                 },
 894
 895                 .num_device_descs = 8,
 896                 .devices = {
 897                         {   "DiBcom STK7700P reference design",
 898                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
 899                                 { NULL },
 900                         },
 901                         {   "Hauppauge Nova-T Stick",
 902                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
 903                                 { NULL },
 904                         },
 905                         {   "AVerMedia AVerTV DVB-T Volar",
 906                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
 907                                 { NULL },
 908                         },
 909                         {   "Compro Videomate U500",
 910                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
 911                                 { NULL },
 912                         },
 913                         {   "Uniwill STK7700P based (Hama and others)",
 914                                 { &dib0700_usb_id_table[7], NULL },
 915                                 { NULL },
 916                         },
 917                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
 918                                 { &dib0700_usb_id_table[8], NULL },
 919                                 { NULL },
 920                         },
 921                         {   "AVerMedia AVerTV DVB-T Express",
 922                                 { &dib0700_usb_id_table[20] },
 923                                 { NULL },
 924                         },
 925                         /* dom : pour Gigabyte U7000 */
 926                         {   "Gigabyte U7000",
 927                                 { &dib0700_usb_id_table[21], NULL },
 928                                 { NULL },
 929                         }
 930                 },
 931
 932                 .rc_interval      = DEFAULT_RC_INTERVAL,
 933                 .rc_key_map       = dib0700_rc_keys,
 934                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
 935                 .rc_query         = dib0700_rc_query
 936         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
 937
 938                 .num_adapters = 2,
 939                 .adapter = {
 940                         {
 941                                 .frontend_attach  = bristol_frontend_attach,
 942                                 .tuner_attach     = bristol_tuner_attach,
 943
 944                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
 945                         }, {
 946                                 .frontend_attach  = bristol_frontend_attach,
 947                                 .tuner_attach     = bristol_tuner_attach,
 948
 949                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
 950                         }
 951                 },
 952
 953                 .num_device_descs = 1,
 954                 .devices = {
 955                         {   "Hauppauge Nova-T 500 Dual DVB-T",
 956                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
 957                                 { NULL },
 958                         },
 959                 },
 960
 961                 .rc_interval      = DEFAULT_RC_INTERVAL,
 962                 .rc_key_map       = dib0700_rc_keys,
 963                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
 964                 .rc_query         = dib0700_rc_query
 965         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
 966
 967                 .num_adapters = 2,
 968                 .adapter = {
 969                         {
 970                                 .frontend_attach  = stk7700d_frontend_attach,
 971                                 .tuner_attach     = stk7700d_tuner_attach,
 972
 973                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
 974                         }, {
 975                                 .frontend_attach  = stk7700d_frontend_attach,
 976                                 .tuner_attach     = stk7700d_tuner_attach,
 977
 978                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
 979                         }
 980                 },
 981
 982                 .num_device_descs = 4,
 983                 .devices = {
 984                         {   "Pinnacle PCTV 2000e",
 985                                 { &dib0700_usb_id_table[11], NULL },
 986                                 { NULL },
 987                         },
 988                         {   "Terratec Cinergy DT XS Diversity",
 989                                 { &dib0700_usb_id_table[12], NULL },
 990                                 { NULL },
 991                         },
 992                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
 993                                 { &dib0700_usb_id_table[13], NULL },
 994                                 { NULL },
 995                         },
 996                         {   "DiBcom STK7700D reference design",
 997                                 { &dib0700_usb_id_table[14], NULL },
 998                                 { NULL },
 999                         }
1000                 },
1001
1002                 .rc_interval      = DEFAULT_RC_INTERVAL,
1003                 .rc_key_map       = dib0700_rc_keys,
1004                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1005                 .rc_query         = dib0700_rc_query
1006
1007         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1008
1009                 .num_adapters = 1,
1010                 .adapter = {
1011                         {
1012                                 .frontend_attach  = stk7070p_frontend_attach,
1013                                 .tuner_attach     = dib7070p_tuner_attach,
1014
1015                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1016
1017                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
1018                         },
1019                 },
1020
1021                 .num_device_descs = 2,
1022                 .devices = {
1023                         {   "DiBcom STK7070P reference design",
1024                                 { &dib0700_usb_id_table[15], NULL },
1025                                 { NULL },
1026                         },
1027                         {   "Pinnacle PCTV DVB-T Flash Stick",
1028                                 { &dib0700_usb_id_table[16], NULL },
1029                                 { NULL },
1030                         },
1031                 }
1032         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1033
1034                 .num_adapters = 2,
1035                 .adapter = {
1036                         {
1037                                 .frontend_attach  = stk7070pd_frontend_attach0,
1038                                 .tuner_attach     = dib7070p_tuner_attach,
1039
1040                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1041
1042                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
1043                         }, {
1044                                 .frontend_attach  = stk7070pd_frontend_attach1,
1045                                 .tuner_attach     = dib7070p_tuner_attach,
1046
1047                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1048
1049                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
1050                         }
1051                 },
1052
1053                 .num_device_descs = 2,
1054                 .devices = {
1055                         {   "DiBcom STK7070PD reference design",
1056                                 { &dib0700_usb_id_table[17], NULL },
1057                                 { NULL },
1058                         },
1059                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
1060                                 { &dib0700_usb_id_table[18], NULL },
1061                                 { NULL },
1062                         }
1063                 }
1064         },
1065 };
1066
1067 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);