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