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