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