1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge 3 * 4 * Copyright (C) 2005-9 DiBcom, SA et al 5 */ 6 #include "dib0700.h" 7 8 #include "dib3000mc.h" 9 #include "dib7000m.h" 10 #include "dib7000p.h" 11 #include "dib8000.h" 12 #include "dib9000.h" 13 #include "mt2060.h" 14 #include "mt2266.h" 15 #include "xc2028.h" 16 #include "xc5000.h" 17 #include "xc4000.h" 18 #include "s5h1411.h" 19 #include "dib0070.h" 20 #include "dib0090.h" 21 #include "lgdt3305.h" 22 #include "mxl5007t.h" 23 #include "mn88472.h" 24 #include "tda18250.h" 25 26 27 static int force_lna_activation; 28 module_param(force_lna_activation, int, 0644); 29 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifier(s) (LNA), if applicable for the device (default: 0=automatic/off)."); 30 31 struct dib0700_adapter_state { 32 int (*set_param_save) (struct dvb_frontend *); 33 const struct firmware *frontend_firmware; 34 struct dib7000p_ops dib7000p_ops; 35 struct dib8000_ops dib8000_ops; 36 }; 37 38 /* Hauppauge Nova-T 500 (aka Bristol) 39 * has a LNA on GPIO0 which is enabled by setting 1 */ 40 static struct mt2060_config bristol_mt2060_config[2] = { 41 { 42 .i2c_address = 0x60, 43 .clock_out = 3, 44 }, { 45 .i2c_address = 0x61, 46 } 47 }; 48 49 50 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = { 51 .band_caps = BAND_VHF | BAND_UHF, 52 .setup = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0), 53 54 .agc1_max = 42598, 55 .agc1_min = 17694, 56 .agc2_max = 45875, 57 .agc2_min = 0, 58 59 .agc1_pt1 = 0, 60 .agc1_pt2 = 59, 61 62 .agc1_slope1 = 0, 63 .agc1_slope2 = 69, 64 65 .agc2_pt1 = 0, 66 .agc2_pt2 = 59, 67 68 .agc2_slope1 = 111, 69 .agc2_slope2 = 28, 70 }; 71 72 static struct dib3000mc_config bristol_dib3000mc_config[2] = { 73 { .agc = &bristol_dib3000p_mt2060_agc_config, 74 .max_time = 0x196, 75 .ln_adc_level = 0x1cc7, 76 .output_mpeg2_in_188_bytes = 1, 77 }, 78 { .agc = &bristol_dib3000p_mt2060_agc_config, 79 .max_time = 0x196, 80 .ln_adc_level = 0x1cc7, 81 .output_mpeg2_in_188_bytes = 1, 82 } 83 }; 84 85 static int bristol_frontend_attach(struct dvb_usb_adapter *adap) 86 { 87 struct dib0700_state *st = adap->dev->priv; 88 if (adap->id == 0) { 89 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10); 90 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10); 91 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10); 92 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10); 93 94 if (force_lna_activation) 95 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 96 else 97 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0); 98 99 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) { 100 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10); 101 return -ENODEV; 102 } 103 } 104 st->mt2060_if1[adap->id] = 1220; 105 return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap, 106 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0; 107 } 108 109 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval) 110 { 111 struct i2c_msg msg[2] = { 112 { .addr = 0x50, .flags = 0, .buf = &adrs, .len = 1 }, 113 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval, .len = 1 }, 114 }; 115 if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO; 116 return 0; 117 } 118 119 static int bristol_tuner_attach(struct dvb_usb_adapter *adap) 120 { 121 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap; 122 struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1); 123 s8 a; 124 int if1=1220; 125 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) && 126 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) { 127 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a; 128 } 129 return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, 130 &bristol_mt2060_config[adap->id], if1) == NULL ? 131 -ENODEV : 0; 132 } 133 134 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */ 135 136 /* MT226x */ 137 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = { 138 { 139 BAND_UHF, 140 141 /* 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, 142 * 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 */ 143 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) 144 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), 145 146 1130, 147 21, 148 149 0, 150 118, 151 152 0, 153 3530, 154 1, 155 0, 156 157 65535, 158 33770, 159 65535, 160 23592, 161 162 0, 163 62, 164 255, 165 64, 166 64, 167 132, 168 192, 169 80, 170 80, 171 172 17, 173 27, 174 23, 175 51, 176 177 1, 178 }, { 179 BAND_VHF | BAND_LBAND, 180 181 /* 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, 182 * 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 */ 183 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) 184 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), 185 186 2372, 187 21, 188 189 0, 190 118, 191 192 0, 193 3530, 194 1, 195 0, 196 197 65535, 198 0, 199 65535, 200 23592, 201 202 0, 203 128, 204 128, 205 128, 206 0, 207 128, 208 253, 209 81, 210 0, 211 212 17, 213 27, 214 23, 215 51, 216 217 1, 218 } 219 }; 220 221 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = { 222 .internal = 60000, 223 .sampling = 30000, 224 .pll_prediv = 1, 225 .pll_ratio = 8, 226 .pll_range = 3, 227 .pll_reset = 1, 228 .pll_bypass = 0, 229 .enable_refdiv = 0, 230 .bypclk_div = 0, 231 .IO_CLK_en_core = 1, 232 .ADClkSrc = 1, 233 .modulo = 2, 234 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), 235 .ifreq = 0, 236 .timf = 20452225, 237 }; 238 239 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = { 240 { .output_mpeg2_in_188_bytes = 1, 241 .hostbus_diversity = 1, 242 .tuner_is_baseband = 1, 243 244 .agc_config_count = 2, 245 .agc = stk7700d_7000p_mt2266_agc_config, 246 .bw = &stk7700d_mt2266_pll_config, 247 248 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS, 249 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES, 250 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 251 }, 252 { .output_mpeg2_in_188_bytes = 1, 253 .hostbus_diversity = 1, 254 .tuner_is_baseband = 1, 255 256 .agc_config_count = 2, 257 .agc = stk7700d_7000p_mt2266_agc_config, 258 .bw = &stk7700d_mt2266_pll_config, 259 260 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS, 261 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES, 262 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 263 } 264 }; 265 266 static struct mt2266_config stk7700d_mt2266_config[2] = { 267 { .i2c_address = 0x60 268 }, 269 { .i2c_address = 0x60 270 } 271 }; 272 273 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap) 274 { 275 struct dib0700_adapter_state *state = adap->priv; 276 277 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 278 return -ENODEV; 279 280 if (adap->id == 0) { 281 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 282 msleep(10); 283 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 284 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 285 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 286 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 287 msleep(10); 288 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 289 msleep(10); 290 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 291 stk7700d_dib7000p_mt2266_config) 292 != 0) { 293 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); 294 dvb_detach(state->dib7000p_ops.set_wbd_ref); 295 return -ENODEV; 296 } 297 } 298 299 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 300 0x80 + (adap->id << 1), 301 &stk7700d_dib7000p_mt2266_config[adap->id]); 302 303 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 304 } 305 306 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap) 307 { 308 struct dib0700_adapter_state *state = adap->priv; 309 310 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 311 return -ENODEV; 312 313 if (adap->id == 0) { 314 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 315 msleep(10); 316 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 317 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 318 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 319 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 320 msleep(10); 321 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 322 msleep(10); 323 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 324 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 325 stk7700d_dib7000p_mt2266_config) 326 != 0) { 327 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); 328 dvb_detach(state->dib7000p_ops.set_wbd_ref); 329 return -ENODEV; 330 } 331 } 332 333 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 334 0x80 + (adap->id << 1), 335 &stk7700d_dib7000p_mt2266_config[adap->id]); 336 337 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 338 } 339 340 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap) 341 { 342 struct i2c_adapter *tun_i2c; 343 struct dib0700_adapter_state *state = adap->priv; 344 345 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, 346 DIBX000_I2C_INTERFACE_TUNER, 1); 347 return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c, 348 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0; 349 } 350 351 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */ 352 static struct dibx000_agc_config xc3028_agc_config = { 353 .band_caps = BAND_VHF | BAND_UHF, 354 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0, 355 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 356 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */ 357 .setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), 358 .inv_gain = 712, 359 .time_stabiliz = 21, 360 .alpha_level = 0, 361 .thlock = 118, 362 .wbd_inv = 0, 363 .wbd_ref = 2867, 364 .wbd_sel = 0, 365 .wbd_alpha = 2, 366 .agc1_max = 0, 367 .agc1_min = 0, 368 .agc2_max = 39718, 369 .agc2_min = 9930, 370 .agc1_pt1 = 0, 371 .agc1_pt2 = 0, 372 .agc1_pt3 = 0, 373 .agc1_slope1 = 0, 374 .agc1_slope2 = 0, 375 .agc2_pt1 = 0, 376 .agc2_pt2 = 128, 377 .agc2_slope1 = 29, 378 .agc2_slope2 = 29, 379 .alpha_mant = 17, 380 .alpha_exp = 27, 381 .beta_mant = 23, 382 .beta_exp = 51, 383 .perform_agc_softsplit = 1, 384 }; 385 386 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */ 387 static struct dibx000_bandwidth_config xc3028_bw_config = { 388 .internal = 60000, 389 .sampling = 30000, 390 .pll_prediv = 1, 391 .pll_ratio = 8, 392 .pll_range = 3, 393 .pll_reset = 1, 394 .pll_bypass = 0, 395 .enable_refdiv = 0, 396 .bypclk_div = 0, 397 .IO_CLK_en_core = 1, 398 .ADClkSrc = 1, 399 .modulo = 0, 400 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */ 401 .ifreq = (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */ 402 .timf = 20452225, 403 .xtal_hz = 30000000, 404 }; 405 406 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = { 407 .output_mpeg2_in_188_bytes = 1, 408 .tuner_is_baseband = 1, 409 410 .agc_config_count = 1, 411 .agc = &xc3028_agc_config, 412 .bw = &xc3028_bw_config, 413 414 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS, 415 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES, 416 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 417 }; 418 419 static int stk7700ph_xc3028_callback(void *ptr, int component, 420 int command, int arg) 421 { 422 struct dvb_usb_adapter *adap = ptr; 423 struct dib0700_adapter_state *state = adap->priv; 424 425 switch (command) { 426 case XC2028_TUNER_RESET: 427 /* Send the tuner in then out of reset */ 428 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0); 429 msleep(10); 430 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1); 431 break; 432 case XC2028_RESET_CLK: 433 case XC2028_I2C_FLUSH: 434 break; 435 default: 436 err("%s: unknown command %d, arg %d\n", __func__, 437 command, arg); 438 return -EINVAL; 439 } 440 return 0; 441 } 442 443 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = { 444 .fname = XC2028_DEFAULT_FIRMWARE, 445 .max_len = 64, 446 .demod = XC3028_FE_DIBCOM52, 447 }; 448 449 static struct xc2028_config stk7700ph_xc3028_config = { 450 .i2c_addr = 0x61, 451 .ctrl = &stk7700ph_xc3028_ctrl, 452 }; 453 454 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap) 455 { 456 struct usb_device_descriptor *desc = &adap->dev->udev->descriptor; 457 struct dib0700_adapter_state *state = adap->priv; 458 459 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 460 return -ENODEV; 461 462 if (desc->idVendor == cpu_to_le16(USB_VID_PINNACLE) && 463 desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX)) 464 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); 465 else 466 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 467 msleep(20); 468 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 469 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 470 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 471 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 472 msleep(10); 473 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 474 msleep(20); 475 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 476 msleep(10); 477 478 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 479 &stk7700ph_dib7700_xc3028_config) != 0) { 480 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", 481 __func__); 482 dvb_detach(state->dib7000p_ops.set_wbd_ref); 483 return -ENODEV; 484 } 485 486 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, 487 &stk7700ph_dib7700_xc3028_config); 488 489 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 490 } 491 492 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap) 493 { 494 struct i2c_adapter *tun_i2c; 495 struct dib0700_adapter_state *state = adap->priv; 496 497 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, 498 DIBX000_I2C_INTERFACE_TUNER, 1); 499 500 stk7700ph_xc3028_config.i2c_adap = tun_i2c; 501 502 /* FIXME: generalize & move to common area */ 503 adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback; 504 505 return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config) 506 == NULL ? -ENODEV : 0; 507 } 508 509 #define DEFAULT_RC_INTERVAL 50 510 511 /* 512 * This function is used only when firmware is < 1.20 version. Newer 513 * firmwares use bulk mode, with functions implemented at dib0700_core, 514 * at dib0700_rc_urb_completion() 515 */ 516 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d) 517 { 518 enum rc_proto protocol; 519 u32 scancode; 520 u8 toggle; 521 int i; 522 struct dib0700_state *st = d->priv; 523 524 if (st->fw_version >= 0x10200) { 525 /* For 1.20 firmware , We need to keep the RC polling 526 callback so we can reuse the input device setup in 527 dvb-usb-remote.c. However, the actual work is being done 528 in the bulk URB completion handler. */ 529 return 0; 530 } 531 532 st->buf[0] = REQUEST_POLL_RC; 533 st->buf[1] = 0; 534 535 i = dib0700_ctrl_rd(d, st->buf, 2, st->buf, 4); 536 if (i <= 0) { 537 err("RC Query Failed"); 538 return -EIO; 539 } 540 541 /* losing half of KEY_0 events from Philipps rc5 remotes.. */ 542 if (st->buf[0] == 0 && st->buf[1] == 0 543 && st->buf[2] == 0 && st->buf[3] == 0) 544 return 0; 545 546 /* info("%d: %2X %2X %2X %2X",dvb_usb_dib0700_ir_proto,(int)st->buf[3 - 2],(int)st->buf[3 - 3],(int)st->buf[3 - 1],(int)st->buf[3]); */ 547 548 dib0700_rc_setup(d, NULL); /* reset ir sensor data to prevent false events */ 549 550 switch (d->props.rc.core.protocol) { 551 case RC_PROTO_BIT_NEC: 552 /* NEC protocol sends repeat code as 0 0 0 FF */ 553 if ((st->buf[3 - 2] == 0x00) && (st->buf[3 - 3] == 0x00) && 554 (st->buf[3] == 0xff)) { 555 rc_repeat(d->rc_dev); 556 return 0; 557 } 558 559 protocol = RC_PROTO_NEC; 560 scancode = RC_SCANCODE_NEC(st->buf[3 - 2], st->buf[3 - 3]); 561 toggle = 0; 562 break; 563 564 default: 565 /* RC-5 protocol changes toggle bit on new keypress */ 566 protocol = RC_PROTO_RC5; 567 scancode = RC_SCANCODE_RC5(st->buf[3 - 2], st->buf[3 - 3]); 568 toggle = st->buf[3 - 1]; 569 break; 570 } 571 572 rc_keydown(d->rc_dev, protocol, scancode, toggle); 573 return 0; 574 } 575 576 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */ 577 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = { 578 BAND_UHF | BAND_VHF, 579 580 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, 581 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */ 582 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) 583 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), 584 585 712, 586 41, 587 588 0, 589 118, 590 591 0, 592 4095, 593 0, 594 0, 595 596 42598, 597 17694, 598 45875, 599 2621, 600 0, 601 76, 602 139, 603 52, 604 59, 605 107, 606 172, 607 57, 608 70, 609 610 21, 611 25, 612 28, 613 48, 614 615 1, 616 { 0, 617 107, 618 51800, 619 24700 620 }, 621 }; 622 623 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = { 624 .band_caps = BAND_UHF | BAND_VHF, 625 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, 626 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */ 627 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), 628 .inv_gain = 712, 629 .time_stabiliz = 41, 630 .alpha_level = 0, 631 .thlock = 118, 632 .wbd_inv = 0, 633 .wbd_ref = 4095, 634 .wbd_sel = 0, 635 .wbd_alpha = 0, 636 .agc1_max = 42598, 637 .agc1_min = 16384, 638 .agc2_max = 42598, 639 .agc2_min = 0, 640 .agc1_pt1 = 0, 641 .agc1_pt2 = 137, 642 .agc1_pt3 = 255, 643 .agc1_slope1 = 0, 644 .agc1_slope2 = 255, 645 .agc2_pt1 = 0, 646 .agc2_pt2 = 0, 647 .agc2_slope1 = 0, 648 .agc2_slope2 = 41, 649 .alpha_mant = 15, 650 .alpha_exp = 25, 651 .beta_mant = 28, 652 .beta_exp = 48, 653 .perform_agc_softsplit = 0, 654 }; 655 656 static struct dibx000_bandwidth_config stk7700p_pll_config = { 657 .internal = 60000, 658 .sampling = 30000, 659 .pll_prediv = 1, 660 .pll_ratio = 8, 661 .pll_range = 3, 662 .pll_reset = 1, 663 .pll_bypass = 0, 664 .enable_refdiv = 0, 665 .bypclk_div = 0, 666 .IO_CLK_en_core = 1, 667 .ADClkSrc = 1, 668 .modulo = 0, 669 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), 670 .ifreq = 60258167, 671 .timf = 20452225, 672 .xtal_hz = 30000000, 673 }; 674 675 static struct dib7000m_config stk7700p_dib7000m_config = { 676 .dvbt_mode = 1, 677 .output_mpeg2_in_188_bytes = 1, 678 .quartz_direct = 1, 679 680 .agc_config_count = 1, 681 .agc = &stk7700p_7000m_mt2060_agc_config, 682 .bw = &stk7700p_pll_config, 683 684 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS, 685 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES, 686 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS, 687 }; 688 689 static struct dib7000p_config stk7700p_dib7000p_config = { 690 .output_mpeg2_in_188_bytes = 1, 691 692 .agc_config_count = 1, 693 .agc = &stk7700p_7000p_mt2060_agc_config, 694 .bw = &stk7700p_pll_config, 695 696 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS, 697 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES, 698 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS, 699 }; 700 701 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap) 702 { 703 struct dib0700_state *st = adap->dev->priv; 704 struct dib0700_adapter_state *state = adap->priv; 705 706 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 707 return -ENODEV; 708 709 /* unless there is no real power management in DVB - we leave the device on GPIO6 */ 710 711 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 712 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(50); 713 714 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10); 715 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 716 717 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10); 718 dib0700_ctrl_clock(adap->dev, 72, 1); 719 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100); 720 721 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 722 723 st->mt2060_if1[0] = 1220; 724 725 if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) { 726 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config); 727 st->is_dib7000pc = 1; 728 } else { 729 memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops)); 730 adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config); 731 } 732 733 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 734 } 735 736 static struct mt2060_config stk7700p_mt2060_config = { 737 0x60 738 }; 739 740 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap) 741 { 742 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap; 743 struct dib0700_state *st = adap->dev->priv; 744 struct i2c_adapter *tun_i2c; 745 struct dib0700_adapter_state *state = adap->priv; 746 s8 a; 747 int if1=1220; 748 749 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) && 750 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) { 751 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a; 752 } 753 if (st->is_dib7000pc) 754 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1); 755 else 756 tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1); 757 758 return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config, 759 if1) == NULL ? -ENODEV : 0; 760 } 761 762 /* DIB7070 generic */ 763 static struct dibx000_agc_config dib7070_agc_config = { 764 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND, 765 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, 766 * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */ 767 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), 768 .inv_gain = 600, 769 .time_stabiliz = 10, 770 .alpha_level = 0, 771 .thlock = 118, 772 .wbd_inv = 0, 773 .wbd_ref = 3530, 774 .wbd_sel = 1, 775 .wbd_alpha = 5, 776 .agc1_max = 65535, 777 .agc1_min = 0, 778 .agc2_max = 65535, 779 .agc2_min = 0, 780 .agc1_pt1 = 0, 781 .agc1_pt2 = 40, 782 .agc1_pt3 = 183, 783 .agc1_slope1 = 206, 784 .agc1_slope2 = 255, 785 .agc2_pt1 = 72, 786 .agc2_pt2 = 152, 787 .agc2_slope1 = 88, 788 .agc2_slope2 = 90, 789 .alpha_mant = 17, 790 .alpha_exp = 27, 791 .beta_mant = 23, 792 .beta_exp = 51, 793 .perform_agc_softsplit = 0, 794 }; 795 796 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff) 797 { 798 struct dvb_usb_adapter *adap = fe->dvb->priv; 799 struct dib0700_adapter_state *state = adap->priv; 800 801 deb_info("reset: %d", onoff); 802 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff); 803 } 804 805 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff) 806 { 807 struct dvb_usb_adapter *adap = fe->dvb->priv; 808 struct dib0700_adapter_state *state = adap->priv; 809 810 deb_info("sleep: %d", onoff); 811 return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff); 812 } 813 814 static struct dib0070_config dib7070p_dib0070_config[2] = { 815 { 816 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 817 .reset = dib7070_tuner_reset, 818 .sleep = dib7070_tuner_sleep, 819 .clock_khz = 12000, 820 .clock_pad_drive = 4, 821 .charge_pump = 2, 822 }, { 823 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 824 .reset = dib7070_tuner_reset, 825 .sleep = dib7070_tuner_sleep, 826 .clock_khz = 12000, 827 .charge_pump = 2, 828 } 829 }; 830 831 static struct dib0070_config dib7770p_dib0070_config = { 832 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 833 .reset = dib7070_tuner_reset, 834 .sleep = dib7070_tuner_sleep, 835 .clock_khz = 12000, 836 .clock_pad_drive = 0, 837 .flip_chip = 1, 838 .charge_pump = 2, 839 }; 840 841 static int dib7070_set_param_override(struct dvb_frontend *fe) 842 { 843 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 844 struct dvb_usb_adapter *adap = fe->dvb->priv; 845 struct dib0700_adapter_state *state = adap->priv; 846 847 u16 offset; 848 u8 band = BAND_OF_FREQUENCY(p->frequency/1000); 849 switch (band) { 850 case BAND_VHF: offset = 950; break; 851 case BAND_UHF: 852 default: offset = 550; break; 853 } 854 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe)); 855 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe)); 856 return state->set_param_save(fe); 857 } 858 859 static int dib7770_set_param_override(struct dvb_frontend *fe) 860 { 861 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 862 struct dvb_usb_adapter *adap = fe->dvb->priv; 863 struct dib0700_adapter_state *state = adap->priv; 864 865 u16 offset; 866 u8 band = BAND_OF_FREQUENCY(p->frequency/1000); 867 switch (band) { 868 case BAND_VHF: 869 state->dib7000p_ops.set_gpio(fe, 0, 0, 1); 870 offset = 850; 871 break; 872 case BAND_UHF: 873 default: 874 state->dib7000p_ops.set_gpio(fe, 0, 0, 0); 875 offset = 250; 876 break; 877 } 878 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe)); 879 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe)); 880 return state->set_param_save(fe); 881 } 882 883 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap) 884 { 885 struct dib0700_adapter_state *st = adap->priv; 886 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, 887 DIBX000_I2C_INTERFACE_TUNER, 1); 888 889 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, 890 &dib7770p_dib0070_config) == NULL) 891 return -ENODEV; 892 893 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 894 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override; 895 return 0; 896 } 897 898 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap) 899 { 900 struct dib0700_adapter_state *st = adap->priv; 901 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1); 902 903 if (adap->id == 0) { 904 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL) 905 return -ENODEV; 906 } else { 907 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL) 908 return -ENODEV; 909 } 910 911 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 912 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override; 913 return 0; 914 } 915 916 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index, 917 u16 pid, int onoff) 918 { 919 struct dib0700_adapter_state *state = adapter->priv; 920 struct dib0700_state *st = adapter->dev->priv; 921 922 if (st->is_dib7000pc) 923 return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff); 924 return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff); 925 } 926 927 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff) 928 { 929 struct dib0700_state *st = adapter->dev->priv; 930 struct dib0700_adapter_state *state = adapter->priv; 931 if (st->is_dib7000pc) 932 return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff); 933 return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff); 934 } 935 936 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff) 937 { 938 struct dib0700_adapter_state *state = adapter->priv; 939 return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff); 940 } 941 942 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff) 943 { 944 struct dib0700_adapter_state *state = adapter->priv; 945 return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff); 946 } 947 948 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = { 949 .internal = 60000, 950 .sampling = 15000, 951 .pll_prediv = 1, 952 .pll_ratio = 20, 953 .pll_range = 3, 954 .pll_reset = 1, 955 .pll_bypass = 0, 956 .enable_refdiv = 0, 957 .bypclk_div = 0, 958 .IO_CLK_en_core = 1, 959 .ADClkSrc = 1, 960 .modulo = 2, 961 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), 962 .ifreq = (0 << 25) | 0, 963 .timf = 20452225, 964 .xtal_hz = 12000000, 965 }; 966 967 static struct dib7000p_config dib7070p_dib7000p_config = { 968 .output_mpeg2_in_188_bytes = 1, 969 970 .agc_config_count = 1, 971 .agc = &dib7070_agc_config, 972 .bw = &dib7070_bw_config_12_mhz, 973 .tuner_is_baseband = 1, 974 .spur_protect = 1, 975 976 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS, 977 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES, 978 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 979 980 .hostbus_diversity = 1, 981 }; 982 983 /* STK7070P */ 984 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap) 985 { 986 struct usb_device_descriptor *p = &adap->dev->udev->descriptor; 987 struct dib0700_adapter_state *state = adap->priv; 988 989 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 990 return -ENODEV; 991 992 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) && 993 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E)) 994 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); 995 else 996 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 997 msleep(10); 998 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 999 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 1000 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 1001 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 1002 1003 dib0700_ctrl_clock(adap->dev, 72, 1); 1004 1005 msleep(10); 1006 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 1007 msleep(10); 1008 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 1009 1010 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 1011 &dib7070p_dib7000p_config) != 0) { 1012 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", 1013 __func__); 1014 dvb_detach(state->dib7000p_ops.set_wbd_ref); 1015 return -ENODEV; 1016 } 1017 1018 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, 1019 &dib7070p_dib7000p_config); 1020 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1021 } 1022 1023 /* STK7770P */ 1024 static struct dib7000p_config dib7770p_dib7000p_config = { 1025 .output_mpeg2_in_188_bytes = 1, 1026 1027 .agc_config_count = 1, 1028 .agc = &dib7070_agc_config, 1029 .bw = &dib7070_bw_config_12_mhz, 1030 .tuner_is_baseband = 1, 1031 .spur_protect = 1, 1032 1033 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS, 1034 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES, 1035 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 1036 1037 .hostbus_diversity = 1, 1038 .enable_current_mirror = 1, 1039 .disable_sample_and_hold = 0, 1040 }; 1041 1042 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap) 1043 { 1044 struct usb_device_descriptor *p = &adap->dev->udev->descriptor; 1045 struct dib0700_adapter_state *state = adap->priv; 1046 1047 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 1048 return -ENODEV; 1049 1050 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) && 1051 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E)) 1052 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); 1053 else 1054 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 1055 msleep(10); 1056 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 1057 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 1058 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 1059 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 1060 1061 dib0700_ctrl_clock(adap->dev, 72, 1); 1062 1063 msleep(10); 1064 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 1065 msleep(10); 1066 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 1067 1068 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 1069 &dib7770p_dib7000p_config) != 0) { 1070 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", 1071 __func__); 1072 dvb_detach(state->dib7000p_ops.set_wbd_ref); 1073 return -ENODEV; 1074 } 1075 1076 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, 1077 &dib7770p_dib7000p_config); 1078 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1079 } 1080 1081 /* DIB807x generic */ 1082 static struct dibx000_agc_config dib807x_agc_config[2] = { 1083 { 1084 BAND_VHF, 1085 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, 1086 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, 1087 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0, 1088 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, 1089 * P_agc_write=0 */ 1090 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) | 1091 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | 1092 (0 << 0), /* setup*/ 1093 1094 600, /* inv_gain*/ 1095 10, /* time_stabiliz*/ 1096 1097 0, /* alpha_level*/ 1098 118, /* thlock*/ 1099 1100 0, /* wbd_inv*/ 1101 3530, /* wbd_ref*/ 1102 1, /* wbd_sel*/ 1103 5, /* wbd_alpha*/ 1104 1105 65535, /* agc1_max*/ 1106 0, /* agc1_min*/ 1107 1108 65535, /* agc2_max*/ 1109 0, /* agc2_min*/ 1110 1111 0, /* agc1_pt1*/ 1112 40, /* agc1_pt2*/ 1113 183, /* agc1_pt3*/ 1114 206, /* agc1_slope1*/ 1115 255, /* agc1_slope2*/ 1116 72, /* agc2_pt1*/ 1117 152, /* agc2_pt2*/ 1118 88, /* agc2_slope1*/ 1119 90, /* agc2_slope2*/ 1120 1121 17, /* alpha_mant*/ 1122 27, /* alpha_exp*/ 1123 23, /* beta_mant*/ 1124 51, /* beta_exp*/ 1125 1126 0, /* perform_agc_softsplit*/ 1127 }, { 1128 BAND_UHF, 1129 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, 1130 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, 1131 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 1132 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, 1133 * P_agc_write=0 */ 1134 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) | 1135 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | 1136 (0 << 0), /* setup */ 1137 1138 600, /* inv_gain*/ 1139 10, /* time_stabiliz*/ 1140 1141 0, /* alpha_level*/ 1142 118, /* thlock*/ 1143 1144 0, /* wbd_inv*/ 1145 3530, /* wbd_ref*/ 1146 1, /* wbd_sel*/ 1147 5, /* wbd_alpha*/ 1148 1149 65535, /* agc1_max*/ 1150 0, /* agc1_min*/ 1151 1152 65535, /* agc2_max*/ 1153 0, /* agc2_min*/ 1154 1155 0, /* agc1_pt1*/ 1156 40, /* agc1_pt2*/ 1157 183, /* agc1_pt3*/ 1158 206, /* agc1_slope1*/ 1159 255, /* agc1_slope2*/ 1160 72, /* agc2_pt1*/ 1161 152, /* agc2_pt2*/ 1162 88, /* agc2_slope1*/ 1163 90, /* agc2_slope2*/ 1164 1165 17, /* alpha_mant*/ 1166 27, /* alpha_exp*/ 1167 23, /* beta_mant*/ 1168 51, /* beta_exp*/ 1169 1170 0, /* perform_agc_softsplit*/ 1171 } 1172 }; 1173 1174 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = { 1175 .internal = 60000, 1176 .sampling = 15000, 1177 .pll_prediv = 1, 1178 .pll_ratio = 20, 1179 .pll_range = 3, 1180 .pll_reset = 1, 1181 .pll_bypass = 0, 1182 .enable_refdiv = 0, 1183 .bypclk_div = 0, 1184 .IO_CLK_en_core = 1, 1185 .ADClkSrc = 1, 1186 .modulo = 2, 1187 .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/ 1188 .ifreq = (0 << 25) | 0, /* ifreq = 0.000000 MHz*/ 1189 .timf = 18179755, 1190 .xtal_hz = 12000000, 1191 }; 1192 1193 static struct dib8000_config dib807x_dib8000_config[2] = { 1194 { 1195 .output_mpeg2_in_188_bytes = 1, 1196 1197 .agc_config_count = 2, 1198 .agc = dib807x_agc_config, 1199 .pll = &dib807x_bw_config_12_mhz, 1200 .tuner_is_baseband = 1, 1201 1202 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS, 1203 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES, 1204 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS, 1205 1206 .hostbus_diversity = 1, 1207 .div_cfg = 1, 1208 .agc_control = &dib0070_ctrl_agc_filter, 1209 .output_mode = OUTMODE_MPEG2_FIFO, 1210 .drives = 0x2d98, 1211 }, { 1212 .output_mpeg2_in_188_bytes = 1, 1213 1214 .agc_config_count = 2, 1215 .agc = dib807x_agc_config, 1216 .pll = &dib807x_bw_config_12_mhz, 1217 .tuner_is_baseband = 1, 1218 1219 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS, 1220 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES, 1221 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS, 1222 1223 .hostbus_diversity = 1, 1224 .agc_control = &dib0070_ctrl_agc_filter, 1225 .output_mode = OUTMODE_MPEG2_FIFO, 1226 .drives = 0x2d98, 1227 } 1228 }; 1229 1230 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff) 1231 { 1232 struct dvb_usb_adapter *adap = fe->dvb->priv; 1233 struct dib0700_adapter_state *state = adap->priv; 1234 1235 return state->dib8000_ops.set_gpio(fe, 5, 0, !onoff); 1236 } 1237 1238 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff) 1239 { 1240 struct dvb_usb_adapter *adap = fe->dvb->priv; 1241 struct dib0700_adapter_state *state = adap->priv; 1242 1243 return state->dib8000_ops.set_gpio(fe, 0, 0, onoff); 1244 } 1245 1246 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = { 1247 { 240, 7}, 1248 { 0xffff, 6}, 1249 }; 1250 1251 static struct dib0070_config dib807x_dib0070_config[2] = { 1252 { 1253 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 1254 .reset = dib80xx_tuner_reset, 1255 .sleep = dib80xx_tuner_sleep, 1256 .clock_khz = 12000, 1257 .clock_pad_drive = 4, 1258 .vga_filter = 1, 1259 .force_crystal_mode = 1, 1260 .enable_third_order_filter = 1, 1261 .charge_pump = 0, 1262 .wbd_gain = dib8070_wbd_gain_cfg, 1263 .osc_buffer_state = 0, 1264 .freq_offset_khz_uhf = -100, 1265 .freq_offset_khz_vhf = -100, 1266 }, { 1267 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 1268 .reset = dib80xx_tuner_reset, 1269 .sleep = dib80xx_tuner_sleep, 1270 .clock_khz = 12000, 1271 .clock_pad_drive = 2, 1272 .vga_filter = 1, 1273 .force_crystal_mode = 1, 1274 .enable_third_order_filter = 1, 1275 .charge_pump = 0, 1276 .wbd_gain = dib8070_wbd_gain_cfg, 1277 .osc_buffer_state = 0, 1278 .freq_offset_khz_uhf = -25, 1279 .freq_offset_khz_vhf = -25, 1280 } 1281 }; 1282 1283 static int dib807x_set_param_override(struct dvb_frontend *fe) 1284 { 1285 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1286 struct dvb_usb_adapter *adap = fe->dvb->priv; 1287 struct dib0700_adapter_state *state = adap->priv; 1288 1289 u16 offset = dib0070_wbd_offset(fe); 1290 u8 band = BAND_OF_FREQUENCY(p->frequency/1000); 1291 switch (band) { 1292 case BAND_VHF: 1293 offset += 750; 1294 break; 1295 case BAND_UHF: /* fall-thru wanted */ 1296 default: 1297 offset += 250; break; 1298 } 1299 deb_info("WBD for DiB8000: %d\n", offset); 1300 state->dib8000_ops.set_wbd_ref(fe, offset); 1301 1302 return state->set_param_save(fe); 1303 } 1304 1305 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap) 1306 { 1307 struct dib0700_adapter_state *st = adap->priv; 1308 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, 1309 DIBX000_I2C_INTERFACE_TUNER, 1); 1310 1311 if (adap->id == 0) { 1312 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, 1313 &dib807x_dib0070_config[0]) == NULL) 1314 return -ENODEV; 1315 } else { 1316 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, 1317 &dib807x_dib0070_config[1]) == NULL) 1318 return -ENODEV; 1319 } 1320 1321 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 1322 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override; 1323 return 0; 1324 } 1325 1326 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index, 1327 u16 pid, int onoff) 1328 { 1329 struct dib0700_adapter_state *state = adapter->priv; 1330 1331 return state->dib8000_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff); 1332 } 1333 1334 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter, 1335 int onoff) 1336 { 1337 struct dib0700_adapter_state *state = adapter->priv; 1338 1339 return state->dib8000_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff); 1340 } 1341 1342 /* STK807x */ 1343 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap) 1344 { 1345 struct dib0700_adapter_state *state = adap->priv; 1346 1347 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1348 return -ENODEV; 1349 1350 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 1351 msleep(10); 1352 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 1353 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 1354 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 1355 1356 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 1357 1358 dib0700_ctrl_clock(adap->dev, 72, 1); 1359 1360 msleep(10); 1361 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 1362 msleep(10); 1363 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 1364 1365 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 1366 0x80, 0); 1367 1368 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, 1369 &dib807x_dib8000_config[0]); 1370 1371 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1372 } 1373 1374 /* STK807xPVR */ 1375 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap) 1376 { 1377 struct dib0700_adapter_state *state = adap->priv; 1378 1379 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1380 return -ENODEV; 1381 1382 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); 1383 msleep(30); 1384 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 1385 msleep(500); 1386 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 1387 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 1388 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 1389 1390 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 1391 1392 dib0700_ctrl_clock(adap->dev, 72, 1); 1393 1394 msleep(10); 1395 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 1396 msleep(10); 1397 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 1398 1399 /* initialize IC 0 */ 1400 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0); 1401 1402 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, 1403 &dib807x_dib8000_config[0]); 1404 1405 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1406 } 1407 1408 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap) 1409 { 1410 struct dib0700_adapter_state *state = adap->priv; 1411 1412 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1413 return -ENODEV; 1414 1415 /* initialize IC 1 */ 1416 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0); 1417 1418 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, 1419 &dib807x_dib8000_config[1]); 1420 1421 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1422 } 1423 1424 /* STK8096GP */ 1425 static struct dibx000_agc_config dib8090_agc_config[2] = { 1426 { 1427 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND, 1428 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, 1429 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 1430 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */ 1431 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) 1432 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), 1433 1434 .inv_gain = 787, 1435 .time_stabiliz = 10, 1436 1437 .alpha_level = 0, 1438 .thlock = 118, 1439 1440 .wbd_inv = 0, 1441 .wbd_ref = 3530, 1442 .wbd_sel = 1, 1443 .wbd_alpha = 5, 1444 1445 .agc1_max = 65535, 1446 .agc1_min = 0, 1447 1448 .agc2_max = 65535, 1449 .agc2_min = 0, 1450 1451 .agc1_pt1 = 0, 1452 .agc1_pt2 = 32, 1453 .agc1_pt3 = 114, 1454 .agc1_slope1 = 143, 1455 .agc1_slope2 = 144, 1456 .agc2_pt1 = 114, 1457 .agc2_pt2 = 227, 1458 .agc2_slope1 = 116, 1459 .agc2_slope2 = 117, 1460 1461 .alpha_mant = 28, 1462 .alpha_exp = 26, 1463 .beta_mant = 31, 1464 .beta_exp = 51, 1465 1466 .perform_agc_softsplit = 0, 1467 }, 1468 { 1469 .band_caps = BAND_CBAND, 1470 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, 1471 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 1472 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */ 1473 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) 1474 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), 1475 1476 .inv_gain = 787, 1477 .time_stabiliz = 10, 1478 1479 .alpha_level = 0, 1480 .thlock = 118, 1481 1482 .wbd_inv = 0, 1483 .wbd_ref = 3530, 1484 .wbd_sel = 1, 1485 .wbd_alpha = 5, 1486 1487 .agc1_max = 0, 1488 .agc1_min = 0, 1489 1490 .agc2_max = 65535, 1491 .agc2_min = 0, 1492 1493 .agc1_pt1 = 0, 1494 .agc1_pt2 = 32, 1495 .agc1_pt3 = 114, 1496 .agc1_slope1 = 143, 1497 .agc1_slope2 = 144, 1498 .agc2_pt1 = 114, 1499 .agc2_pt2 = 227, 1500 .agc2_slope1 = 116, 1501 .agc2_slope2 = 117, 1502 1503 .alpha_mant = 28, 1504 .alpha_exp = 26, 1505 .beta_mant = 31, 1506 .beta_exp = 51, 1507 1508 .perform_agc_softsplit = 0, 1509 } 1510 }; 1511 1512 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = { 1513 .internal = 54000, 1514 .sampling = 13500, 1515 1516 .pll_prediv = 1, 1517 .pll_ratio = 18, 1518 .pll_range = 3, 1519 .pll_reset = 1, 1520 .pll_bypass = 0, 1521 1522 .enable_refdiv = 0, 1523 .bypclk_div = 0, 1524 .IO_CLK_en_core = 1, 1525 .ADClkSrc = 1, 1526 .modulo = 2, 1527 1528 .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0), 1529 1530 .ifreq = (0 << 25) | 0, 1531 .timf = 20199727, 1532 1533 .xtal_hz = 12000000, 1534 }; 1535 1536 static int dib8090_get_adc_power(struct dvb_frontend *fe) 1537 { 1538 struct dvb_usb_adapter *adap = fe->dvb->priv; 1539 struct dib0700_adapter_state *state = adap->priv; 1540 1541 return state->dib8000_ops.get_adc_power(fe, 1); 1542 } 1543 1544 static void dib8090_agc_control(struct dvb_frontend *fe, u8 restart) 1545 { 1546 deb_info("AGC control callback: %i\n", restart); 1547 dib0090_dcc_freq(fe, restart); 1548 1549 if (restart == 0) /* before AGC startup */ 1550 dib0090_set_dc_servo(fe, 1); 1551 } 1552 1553 static struct dib8000_config dib809x_dib8000_config[2] = { 1554 { 1555 .output_mpeg2_in_188_bytes = 1, 1556 1557 .agc_config_count = 2, 1558 .agc = dib8090_agc_config, 1559 .agc_control = dib8090_agc_control, 1560 .pll = &dib8090_pll_config_12mhz, 1561 .tuner_is_baseband = 1, 1562 1563 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS, 1564 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES, 1565 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS, 1566 1567 .hostbus_diversity = 1, 1568 .div_cfg = 0x31, 1569 .output_mode = OUTMODE_MPEG2_FIFO, 1570 .drives = 0x2d98, 1571 .diversity_delay = 48, 1572 .refclksel = 3, 1573 }, { 1574 .output_mpeg2_in_188_bytes = 1, 1575 1576 .agc_config_count = 2, 1577 .agc = dib8090_agc_config, 1578 .agc_control = dib8090_agc_control, 1579 .pll = &dib8090_pll_config_12mhz, 1580 .tuner_is_baseband = 1, 1581 1582 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS, 1583 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES, 1584 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS, 1585 1586 .hostbus_diversity = 1, 1587 .div_cfg = 0x31, 1588 .output_mode = OUTMODE_DIVERSITY, 1589 .drives = 0x2d08, 1590 .diversity_delay = 1, 1591 .refclksel = 3, 1592 } 1593 }; 1594 1595 static struct dib0090_wbd_slope dib8090_wbd_table[] = { 1596 /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */ 1597 { 120, 0, 500, 0, 500, 4 }, /* CBAND */ 1598 { 170, 0, 450, 0, 450, 4 }, /* CBAND */ 1599 { 380, 48, 373, 28, 259, 6 }, /* VHF */ 1600 { 860, 34, 700, 36, 616, 6 }, /* high UHF */ 1601 { 0xFFFF, 34, 700, 36, 616, 6 }, /* default */ 1602 }; 1603 1604 static struct dib0090_config dib809x_dib0090_config = { 1605 .io.pll_bypass = 1, 1606 .io.pll_range = 1, 1607 .io.pll_prediv = 1, 1608 .io.pll_loopdiv = 20, 1609 .io.adc_clock_ratio = 8, 1610 .io.pll_int_loop_filt = 0, 1611 .io.clock_khz = 12000, 1612 .reset = dib80xx_tuner_reset, 1613 .sleep = dib80xx_tuner_sleep, 1614 .clkouttobamse = 1, 1615 .analog_output = 1, 1616 .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS, 1617 .use_pwm_agc = 1, 1618 .clkoutdrive = 1, 1619 .get_adc_power = dib8090_get_adc_power, 1620 .freq_offset_khz_uhf = -63, 1621 .freq_offset_khz_vhf = -143, 1622 .wbd = dib8090_wbd_table, 1623 .fref_clock_ratio = 6, 1624 }; 1625 1626 static u8 dib8090_compute_pll_parameters(struct dvb_frontend *fe) 1627 { 1628 u8 optimal_pll_ratio = 20; 1629 u32 freq_adc, ratio, rest, max = 0; 1630 u8 pll_ratio; 1631 1632 for (pll_ratio = 17; pll_ratio <= 20; pll_ratio++) { 1633 freq_adc = 12 * pll_ratio * (1 << 8) / 16; 1634 ratio = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) / freq_adc; 1635 rest = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) - ratio * freq_adc; 1636 1637 if (rest > freq_adc / 2) 1638 rest = freq_adc - rest; 1639 deb_info("PLL ratio=%i rest=%i\n", pll_ratio, rest); 1640 if ((rest > max) && (rest > 717)) { 1641 optimal_pll_ratio = pll_ratio; 1642 max = rest; 1643 } 1644 } 1645 deb_info("optimal PLL ratio=%i\n", optimal_pll_ratio); 1646 1647 return optimal_pll_ratio; 1648 } 1649 1650 static int dib8096_set_param_override(struct dvb_frontend *fe) 1651 { 1652 struct dvb_usb_adapter *adap = fe->dvb->priv; 1653 struct dib0700_adapter_state *state = adap->priv; 1654 u8 pll_ratio, band = BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000); 1655 u16 target, ltgain, rf_gain_limit; 1656 u32 timf; 1657 int ret = 0; 1658 enum frontend_tune_state tune_state = CT_SHUTDOWN; 1659 1660 switch (band) { 1661 default: 1662 deb_info("Warning : Rf frequency (%iHz) is not in the supported range, using VHF switch ", fe->dtv_property_cache.frequency); 1663 fallthrough; 1664 case BAND_VHF: 1665 state->dib8000_ops.set_gpio(fe, 3, 0, 1); 1666 break; 1667 case BAND_UHF: 1668 state->dib8000_ops.set_gpio(fe, 3, 0, 0); 1669 break; 1670 } 1671 1672 ret = state->set_param_save(fe); 1673 if (ret < 0) 1674 return ret; 1675 1676 if (fe->dtv_property_cache.bandwidth_hz != 6000000) { 1677 deb_info("only 6MHz bandwidth is supported\n"); 1678 return -EINVAL; 1679 } 1680 1681 /* Update PLL if needed ratio */ 1682 state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0); 1683 1684 /* Get optimize PLL ratio to remove spurious */ 1685 pll_ratio = dib8090_compute_pll_parameters(fe); 1686 if (pll_ratio == 17) 1687 timf = 21387946; 1688 else if (pll_ratio == 18) 1689 timf = 20199727; 1690 else if (pll_ratio == 19) 1691 timf = 19136583; 1692 else 1693 timf = 18179756; 1694 1695 /* Update ratio */ 1696 state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio); 1697 1698 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, timf); 1699 1700 if (band != BAND_CBAND) { 1701 /* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */ 1702 target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2; 1703 state->dib8000_ops.set_wbd_ref(fe, target); 1704 } 1705 1706 if (band == BAND_CBAND) { 1707 deb_info("tuning in CBAND - soft-AGC startup\n"); 1708 dib0090_set_tune_state(fe, CT_AGC_START); 1709 1710 do { 1711 ret = dib0090_gain_control(fe); 1712 msleep(ret); 1713 tune_state = dib0090_get_tune_state(fe); 1714 if (tune_state == CT_AGC_STEP_0) 1715 state->dib8000_ops.set_gpio(fe, 6, 0, 1); 1716 else if (tune_state == CT_AGC_STEP_1) { 1717 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, <gain); 1718 if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */ 1719 state->dib8000_ops.set_gpio(fe, 6, 0, 0); 1720 } 1721 } while (tune_state < CT_AGC_STOP); 1722 1723 deb_info("switching to PWM AGC\n"); 1724 dib0090_pwm_gain_reset(fe); 1725 state->dib8000_ops.pwm_agc_reset(fe); 1726 state->dib8000_ops.set_tune_state(fe, CT_DEMOD_START); 1727 } else { 1728 /* for everything else than CBAND we are using standard AGC */ 1729 deb_info("not tuning in CBAND - standard AGC startup\n"); 1730 dib0090_pwm_gain_reset(fe); 1731 } 1732 1733 return 0; 1734 } 1735 1736 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap) 1737 { 1738 struct dib0700_adapter_state *st = adap->priv; 1739 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1); 1740 1741 /* FIXME: if adap->id != 0, check if it is fe_adap[1] */ 1742 if (!dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config)) 1743 return -ENODEV; 1744 1745 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 1746 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override; 1747 return 0; 1748 } 1749 1750 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap) 1751 { 1752 struct dib0700_adapter_state *state = adap->priv; 1753 1754 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1755 return -ENODEV; 1756 1757 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 1758 msleep(10); 1759 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 1760 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 1761 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 1762 1763 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 1764 1765 dib0700_ctrl_clock(adap->dev, 72, 1); 1766 1767 msleep(10); 1768 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 1769 msleep(10); 1770 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 1771 1772 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0); 1773 1774 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]); 1775 1776 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1777 } 1778 1779 static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap) 1780 { 1781 struct dib0700_adapter_state *state = adap->priv; 1782 1783 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1784 return -ENODEV; 1785 1786 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0); 1787 1788 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]); 1789 1790 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 1791 } 1792 1793 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap) 1794 { 1795 struct dib0700_adapter_state *st = adap->priv; 1796 struct i2c_adapter *tun_i2c; 1797 struct dvb_frontend *fe_slave = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1); 1798 1799 if (fe_slave) { 1800 tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1); 1801 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL) 1802 return -ENODEV; 1803 fe_slave->dvb = adap->fe_adap[0].fe->dvb; 1804 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override; 1805 } 1806 tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1); 1807 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL) 1808 return -ENODEV; 1809 1810 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 1811 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override; 1812 1813 return 0; 1814 } 1815 1816 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap) 1817 { 1818 struct dvb_frontend *fe_slave; 1819 struct dib0700_adapter_state *state = adap->priv; 1820 1821 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1822 return -ENODEV; 1823 1824 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); 1825 msleep(20); 1826 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 1827 msleep(1000); 1828 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 1829 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 1830 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 1831 1832 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 1833 1834 dib0700_ctrl_clock(adap->dev, 72, 1); 1835 1836 msleep(20); 1837 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 1838 msleep(20); 1839 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 1840 1841 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0); 1842 1843 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]); 1844 if (adap->fe_adap[0].fe == NULL) 1845 return -ENODEV; 1846 1847 /* Needed to increment refcount */ 1848 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 1849 return -ENODEV; 1850 1851 fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]); 1852 state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave); 1853 1854 return fe_slave == NULL ? -ENODEV : 0; 1855 } 1856 1857 /* TFE8096P */ 1858 static struct dibx000_agc_config dib8096p_agc_config[2] = { 1859 { 1860 .band_caps = BAND_UHF, 1861 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, 1862 P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, 1863 P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 1864 P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, 1865 P_agc_write=0 */ 1866 .setup = (0 << 15) | (0 << 14) | (5 << 11) 1867 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) 1868 | (0 << 4) | (5 << 1) | (0 << 0), 1869 1870 .inv_gain = 684, 1871 .time_stabiliz = 10, 1872 1873 .alpha_level = 0, 1874 .thlock = 118, 1875 1876 .wbd_inv = 0, 1877 .wbd_ref = 1200, 1878 .wbd_sel = 3, 1879 .wbd_alpha = 5, 1880 1881 .agc1_max = 65535, 1882 .agc1_min = 0, 1883 1884 .agc2_max = 32767, 1885 .agc2_min = 0, 1886 1887 .agc1_pt1 = 0, 1888 .agc1_pt2 = 0, 1889 .agc1_pt3 = 105, 1890 .agc1_slope1 = 0, 1891 .agc1_slope2 = 156, 1892 .agc2_pt1 = 105, 1893 .agc2_pt2 = 255, 1894 .agc2_slope1 = 54, 1895 .agc2_slope2 = 0, 1896 1897 .alpha_mant = 28, 1898 .alpha_exp = 26, 1899 .beta_mant = 31, 1900 .beta_exp = 51, 1901 1902 .perform_agc_softsplit = 0, 1903 } , { 1904 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND, 1905 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, 1906 P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, 1907 P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 1908 P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, 1909 P_agc_write=0 */ 1910 .setup = (0 << 15) | (0 << 14) | (5 << 11) 1911 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) 1912 | (0 << 4) | (5 << 1) | (0 << 0), 1913 1914 .inv_gain = 732, 1915 .time_stabiliz = 10, 1916 1917 .alpha_level = 0, 1918 .thlock = 118, 1919 1920 .wbd_inv = 0, 1921 .wbd_ref = 1200, 1922 .wbd_sel = 3, 1923 .wbd_alpha = 5, 1924 1925 .agc1_max = 65535, 1926 .agc1_min = 0, 1927 1928 .agc2_max = 32767, 1929 .agc2_min = 0, 1930 1931 .agc1_pt1 = 0, 1932 .agc1_pt2 = 0, 1933 .agc1_pt3 = 98, 1934 .agc1_slope1 = 0, 1935 .agc1_slope2 = 167, 1936 .agc2_pt1 = 98, 1937 .agc2_pt2 = 255, 1938 .agc2_slope1 = 52, 1939 .agc2_slope2 = 0, 1940 1941 .alpha_mant = 28, 1942 .alpha_exp = 26, 1943 .beta_mant = 31, 1944 .beta_exp = 51, 1945 1946 .perform_agc_softsplit = 0, 1947 } 1948 }; 1949 1950 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = { 1951 .internal = 108000, 1952 .sampling = 13500, 1953 .pll_prediv = 1, 1954 .pll_ratio = 9, 1955 .pll_range = 1, 1956 .pll_reset = 0, 1957 .pll_bypass = 0, 1958 .enable_refdiv = 0, 1959 .bypclk_div = 0, 1960 .IO_CLK_en_core = 0, 1961 .ADClkSrc = 0, 1962 .modulo = 2, 1963 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), 1964 .ifreq = (0 << 25) | 0, 1965 .timf = 20199729, 1966 .xtal_hz = 12000000, 1967 }; 1968 1969 static struct dib8000_config tfe8096p_dib8000_config = { 1970 .output_mpeg2_in_188_bytes = 1, 1971 .hostbus_diversity = 1, 1972 .update_lna = NULL, 1973 1974 .agc_config_count = 2, 1975 .agc = dib8096p_agc_config, 1976 .pll = &dib8096p_clock_config_12_mhz, 1977 1978 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS, 1979 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES, 1980 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS, 1981 1982 .agc_control = NULL, 1983 .diversity_delay = 48, 1984 .output_mode = OUTMODE_MPEG2_FIFO, 1985 .enMpegOutput = 1, 1986 }; 1987 1988 static struct dib0090_wbd_slope dib8096p_wbd_table[] = { 1989 { 380, 81, 850, 64, 540, 4}, 1990 { 860, 51, 866, 21, 375, 4}, 1991 {1700, 0, 250, 0, 100, 6}, 1992 {2600, 0, 250, 0, 100, 6}, 1993 { 0xFFFF, 0, 0, 0, 0, 0}, 1994 }; 1995 1996 static struct dib0090_config tfe8096p_dib0090_config = { 1997 .io.clock_khz = 12000, 1998 .io.pll_bypass = 0, 1999 .io.pll_range = 0, 2000 .io.pll_prediv = 3, 2001 .io.pll_loopdiv = 6, 2002 .io.adc_clock_ratio = 0, 2003 .io.pll_int_loop_filt = 0, 2004 2005 .freq_offset_khz_uhf = -143, 2006 .freq_offset_khz_vhf = -143, 2007 2008 .get_adc_power = dib8090_get_adc_power, 2009 2010 .clkouttobamse = 1, 2011 .analog_output = 0, 2012 2013 .wbd_vhf_offset = 0, 2014 .wbd_cband_offset = 0, 2015 .use_pwm_agc = 1, 2016 .clkoutdrive = 0, 2017 2018 .fref_clock_ratio = 1, 2019 2020 .ls_cfg_pad_drv = 0, 2021 .data_tx_drv = 0, 2022 .low_if = NULL, 2023 .in_soc = 1, 2024 .force_cband_input = 0, 2025 }; 2026 2027 struct dibx090p_adc { 2028 u32 freq; /* RF freq MHz */ 2029 u32 timf; /* New Timf */ 2030 u32 pll_loopdiv; /* New prediv */ 2031 u32 pll_prediv; /* New loopdiv */ 2032 }; 2033 2034 struct dibx090p_best_adc { 2035 u32 timf; 2036 u32 pll_loopdiv; 2037 u32 pll_prediv; 2038 }; 2039 2040 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc) 2041 { 2042 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1; 2043 u16 xtal = 12000; 2044 u16 fcp_min = 1900; /* PLL, Minimum Frequency of phase comparator (KHz) */ 2045 u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */ 2046 u32 fmem_max = 140000; /* 140MHz max SDRAM freq */ 2047 u32 fdem_min = 66000; 2048 u32 fcp = 0, fs = 0, fdem = 0, fmem = 0; 2049 u32 harmonic_id = 0; 2050 2051 adc->timf = 0; 2052 adc->pll_loopdiv = loopdiv; 2053 adc->pll_prediv = prediv; 2054 2055 deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz); 2056 2057 /* Find Min and Max prediv */ 2058 while ((xtal / max_prediv) >= fcp_min) 2059 max_prediv++; 2060 2061 max_prediv--; 2062 min_prediv = max_prediv; 2063 while ((xtal / min_prediv) <= fcp_max) { 2064 min_prediv--; 2065 if (min_prediv == 1) 2066 break; 2067 } 2068 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv); 2069 2070 min_prediv = 1; 2071 2072 for (prediv = min_prediv; prediv < max_prediv; prediv++) { 2073 fcp = xtal / prediv; 2074 if (fcp > fcp_min && fcp < fcp_max) { 2075 for (loopdiv = 1; loopdiv < 64; loopdiv++) { 2076 fmem = ((xtal/prediv) * loopdiv); 2077 fdem = fmem / 2; 2078 fs = fdem / 4; 2079 2080 /* test min/max system restrictions */ 2081 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) { 2082 spur = 0; 2083 /* test fs harmonics positions */ 2084 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs)); harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) { 2085 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)))) { 2086 spur = 1; 2087 break; 2088 } 2089 } 2090 2091 if (!spur) { 2092 adc->pll_loopdiv = loopdiv; 2093 adc->pll_prediv = prediv; 2094 adc->timf = (4260880253U / fdem) * (1 << 8); 2095 adc->timf += ((4260880253U % fdem) << 8) / fdem; 2096 2097 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); 2098 break; 2099 } 2100 } 2101 } 2102 } 2103 if (!spur) 2104 break; 2105 } 2106 2107 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0) 2108 return -EINVAL; 2109 return 0; 2110 } 2111 2112 static int dib8096p_agc_startup(struct dvb_frontend *fe) 2113 { 2114 struct dvb_usb_adapter *adap = fe->dvb->priv; 2115 struct dib0700_adapter_state *state = adap->priv; 2116 struct dibx000_bandwidth_config pll; 2117 struct dibx090p_best_adc adc; 2118 u16 target; 2119 int ret; 2120 2121 ret = state->set_param_save(fe); 2122 if (ret < 0) 2123 return ret; 2124 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config)); 2125 2126 dib0090_pwm_gain_reset(fe); 2127 /* dib0090_get_wbd_target is returning any possible 2128 temperature compensated wbd-target */ 2129 target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2; 2130 state->dib8000_ops.set_wbd_ref(fe, target); 2131 2132 if (dib8096p_get_best_sampling(fe, &adc) == 0) { 2133 pll.pll_ratio = adc.pll_loopdiv; 2134 pll.pll_prediv = adc.pll_prediv; 2135 2136 dib0700_set_i2c_speed(adap->dev, 200); 2137 state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0); 2138 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf); 2139 dib0700_set_i2c_speed(adap->dev, 1000); 2140 } 2141 return 0; 2142 } 2143 2144 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap) 2145 { 2146 struct dib0700_state *st = adap->dev->priv; 2147 u32 fw_version; 2148 struct dib0700_adapter_state *state = adap->priv; 2149 2150 if (!dvb_attach(dib8000_attach, &state->dib8000_ops)) 2151 return -ENODEV; 2152 2153 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL); 2154 if (fw_version >= 0x10200) 2155 st->fw_use_new_i2c_api = 1; 2156 2157 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 2158 msleep(20); 2159 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 2160 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 2161 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 2162 2163 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 2164 2165 dib0700_ctrl_clock(adap->dev, 72, 1); 2166 2167 msleep(20); 2168 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 2169 msleep(20); 2170 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 2171 2172 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1); 2173 2174 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 2175 0x80, &tfe8096p_dib8000_config); 2176 2177 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 2178 } 2179 2180 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap) 2181 { 2182 struct dib0700_adapter_state *st = adap->priv; 2183 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe); 2184 2185 tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep; 2186 tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep; 2187 tfe8096p_dib0090_config.wbd = dib8096p_wbd_table; 2188 2189 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, 2190 &tfe8096p_dib0090_config) == NULL) 2191 return -ENODEV; 2192 2193 st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1); 2194 2195 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 2196 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup; 2197 return 0; 2198 } 2199 2200 /* STK9090M */ 2201 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff) 2202 { 2203 return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff); 2204 } 2205 2206 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff) 2207 { 2208 return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff); 2209 } 2210 2211 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff) 2212 { 2213 return dib9000_set_gpio(fe, 5, 0, !onoff); 2214 } 2215 2216 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff) 2217 { 2218 return dib9000_set_gpio(fe, 0, 0, onoff); 2219 } 2220 2221 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len) 2222 { 2223 u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 }; 2224 u8 rb[2]; 2225 struct i2c_msg msg[2] = { 2226 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2}, 2227 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2}, 2228 }; 2229 u8 index_data; 2230 2231 dibx000_i2c_set_speed(i2c, 250); 2232 2233 if (i2c_transfer(i2c, msg, 2) != 2) 2234 return -EIO; 2235 2236 switch (rb[0] << 8 | rb[1]) { 2237 case 0: 2238 deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n"); 2239 return -EIO; 2240 case 1: 2241 deb_info("Found DiB0170 rev2"); 2242 break; 2243 case 2: 2244 deb_info("Found DiB0190 rev2"); 2245 break; 2246 default: 2247 deb_info("DiB01x0 not found"); 2248 return -EIO; 2249 } 2250 2251 for (index_data = 0; index_data < len; index_data += 2) { 2252 wb[2] = (data[index_data + 1] >> 8) & 0xff; 2253 wb[3] = (data[index_data + 1]) & 0xff; 2254 2255 if (data[index_data] == 0) { 2256 wb[0] = (data[index_data] >> 8) & 0xff; 2257 wb[1] = (data[index_data]) & 0xff; 2258 msg[0].len = 2; 2259 if (i2c_transfer(i2c, msg, 2) != 2) 2260 return -EIO; 2261 wb[2] |= rb[0]; 2262 wb[3] |= rb[1] & ~(3 << 4); 2263 } 2264 2265 wb[0] = (data[index_data] >> 8)&0xff; 2266 wb[1] = (data[index_data])&0xff; 2267 msg[0].len = 4; 2268 if (i2c_transfer(i2c, &msg[0], 1) != 1) 2269 return -EIO; 2270 } 2271 return 0; 2272 } 2273 2274 static struct dib9000_config stk9090m_config = { 2275 .output_mpeg2_in_188_bytes = 1, 2276 .output_mode = OUTMODE_MPEG2_FIFO, 2277 .vcxo_timer = 279620, 2278 .timing_frequency = 20452225, 2279 .demod_clock_khz = 60000, 2280 .xtal_clock_khz = 30000, 2281 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0), 2282 .subband = { 2283 2, 2284 { 2285 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */ 2286 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */ 2287 { 0 }, 2288 }, 2289 }, 2290 .gpio_function = { 2291 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 }, 2292 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 }, 2293 }, 2294 }; 2295 2296 static struct dib9000_config nim9090md_config[2] = { 2297 { 2298 .output_mpeg2_in_188_bytes = 1, 2299 .output_mode = OUTMODE_MPEG2_FIFO, 2300 .vcxo_timer = 279620, 2301 .timing_frequency = 20452225, 2302 .demod_clock_khz = 60000, 2303 .xtal_clock_khz = 30000, 2304 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0), 2305 }, { 2306 .output_mpeg2_in_188_bytes = 1, 2307 .output_mode = OUTMODE_DIVERSITY, 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 .subband = { 2314 2, 2315 { 2316 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */ 2317 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */ 2318 { 0 }, 2319 }, 2320 }, 2321 .gpio_function = { 2322 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 }, 2323 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 }, 2324 }, 2325 } 2326 }; 2327 2328 static struct dib0090_config dib9090_dib0090_config = { 2329 .io.pll_bypass = 0, 2330 .io.pll_range = 1, 2331 .io.pll_prediv = 1, 2332 .io.pll_loopdiv = 8, 2333 .io.adc_clock_ratio = 8, 2334 .io.pll_int_loop_filt = 0, 2335 .io.clock_khz = 30000, 2336 .reset = dib90x0_tuner_reset, 2337 .sleep = dib90x0_tuner_sleep, 2338 .clkouttobamse = 0, 2339 .analog_output = 0, 2340 .use_pwm_agc = 0, 2341 .clkoutdrive = 0, 2342 .freq_offset_khz_uhf = 0, 2343 .freq_offset_khz_vhf = 0, 2344 }; 2345 2346 static struct dib0090_config nim9090md_dib0090_config[2] = { 2347 { 2348 .io.pll_bypass = 0, 2349 .io.pll_range = 1, 2350 .io.pll_prediv = 1, 2351 .io.pll_loopdiv = 8, 2352 .io.adc_clock_ratio = 8, 2353 .io.pll_int_loop_filt = 0, 2354 .io.clock_khz = 30000, 2355 .reset = dib90x0_tuner_reset, 2356 .sleep = dib90x0_tuner_sleep, 2357 .clkouttobamse = 1, 2358 .analog_output = 0, 2359 .use_pwm_agc = 0, 2360 .clkoutdrive = 0, 2361 .freq_offset_khz_uhf = 0, 2362 .freq_offset_khz_vhf = 0, 2363 }, { 2364 .io.pll_bypass = 0, 2365 .io.pll_range = 1, 2366 .io.pll_prediv = 1, 2367 .io.pll_loopdiv = 8, 2368 .io.adc_clock_ratio = 8, 2369 .io.pll_int_loop_filt = 0, 2370 .io.clock_khz = 30000, 2371 .reset = dib90x0_tuner_reset, 2372 .sleep = dib90x0_tuner_sleep, 2373 .clkouttobamse = 0, 2374 .analog_output = 0, 2375 .use_pwm_agc = 0, 2376 .clkoutdrive = 0, 2377 .freq_offset_khz_uhf = 0, 2378 .freq_offset_khz_vhf = 0, 2379 } 2380 }; 2381 2382 2383 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap) 2384 { 2385 struct dib0700_adapter_state *state = adap->priv; 2386 struct dib0700_state *st = adap->dev->priv; 2387 u32 fw_version; 2388 2389 /* Make use of the new i2c functions from FW 1.20 */ 2390 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL); 2391 if (fw_version >= 0x10200) 2392 st->fw_use_new_i2c_api = 1; 2393 dib0700_set_i2c_speed(adap->dev, 340); 2394 2395 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 2396 msleep(20); 2397 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 2398 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 2399 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 2400 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 2401 2402 dib0700_ctrl_clock(adap->dev, 72, 1); 2403 2404 msleep(20); 2405 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 2406 msleep(20); 2407 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 2408 2409 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80); 2410 2411 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) { 2412 deb_info("%s: Upload failed. (file not found?)\n", __func__); 2413 return -ENODEV; 2414 } else { 2415 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size); 2416 } 2417 stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size; 2418 stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data; 2419 2420 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config); 2421 2422 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0; 2423 } 2424 2425 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap) 2426 { 2427 struct dib0700_adapter_state *state = adap->priv; 2428 struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe); 2429 u16 data_dib190[10] = { 2430 1, 0x1374, 2431 2, 0x01a2, 2432 7, 0x0020, 2433 0, 0x00ef, 2434 8, 0x0486, 2435 }; 2436 2437 if (!IS_ENABLED(CONFIG_DVB_DIB9000)) 2438 return -ENODEV; 2439 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL) 2440 return -ENODEV; 2441 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0); 2442 if (!i2c) 2443 return -ENODEV; 2444 if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0) 2445 return -ENODEV; 2446 dib0700_set_i2c_speed(adap->dev, 1500); 2447 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0) 2448 return -ENODEV; 2449 release_firmware(state->frontend_firmware); 2450 return 0; 2451 } 2452 2453 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap) 2454 { 2455 struct dib0700_adapter_state *state = adap->priv; 2456 struct dib0700_state *st = adap->dev->priv; 2457 struct i2c_adapter *i2c; 2458 struct dvb_frontend *fe_slave; 2459 u32 fw_version; 2460 2461 /* Make use of the new i2c functions from FW 1.20 */ 2462 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL); 2463 if (fw_version >= 0x10200) 2464 st->fw_use_new_i2c_api = 1; 2465 dib0700_set_i2c_speed(adap->dev, 340); 2466 2467 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); 2468 msleep(20); 2469 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1); 2470 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1); 2471 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1); 2472 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); 2473 2474 dib0700_ctrl_clock(adap->dev, 72, 1); 2475 2476 msleep(20); 2477 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); 2478 msleep(20); 2479 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); 2480 2481 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) { 2482 deb_info("%s: Upload failed. (file not found?)\n", __func__); 2483 return -EIO; 2484 } else { 2485 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size); 2486 } 2487 nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size; 2488 nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data; 2489 nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size; 2490 nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data; 2491 2492 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80); 2493 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]); 2494 2495 if (adap->fe_adap[0].fe == NULL) 2496 return -ENODEV; 2497 2498 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0); 2499 dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82); 2500 2501 fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]); 2502 dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave); 2503 2504 return fe_slave == NULL ? -ENODEV : 0; 2505 } 2506 2507 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap) 2508 { 2509 struct dib0700_adapter_state *state = adap->priv; 2510 struct i2c_adapter *i2c; 2511 struct dvb_frontend *fe_slave; 2512 u16 data_dib190[10] = { 2513 1, 0x5374, 2514 2, 0x01ae, 2515 7, 0x0020, 2516 0, 0x00ef, 2517 8, 0x0406, 2518 }; 2519 if (!IS_ENABLED(CONFIG_DVB_DIB9000)) 2520 return -ENODEV; 2521 i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe); 2522 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL) 2523 return -ENODEV; 2524 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0); 2525 if (!i2c) 2526 return -ENODEV; 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_client_device(&d->i2c_adap, &info); 3771 if (!i2c_client_has_driver(client_demod)) 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_client_device(&adap->dev->i2c_adap, &info); 3799 if (!i2c_client_has_driver(client_tuner)) 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 enum { 3820 DIBCOM_STK7700P, 3821 DIBCOM_STK7700P_PC, 3822 HAUPPAUGE_NOVA_T_500, 3823 HAUPPAUGE_NOVA_T_500_2, 3824 HAUPPAUGE_NOVA_T_STICK, 3825 AVERMEDIA_VOLAR, 3826 COMPRO_VIDEOMATE_U500, 3827 UNIWILL_STK7700P, 3828 LEADTEK_WINFAST_DTV_DONGLE_STK7700P, 3829 HAUPPAUGE_NOVA_T_STICK_2, 3830 AVERMEDIA_VOLAR_2, 3831 PINNACLE_PCTV2000E, 3832 TERRATEC_CINERGY_DT_XS_DIVERSITY, 3833 HAUPPAUGE_NOVA_TD_STICK, 3834 DIBCOM_STK7700D, 3835 DIBCOM_STK7070P, 3836 PINNACLE_PCTV_DVB_T_FLASH, 3837 DIBCOM_STK7070PD, 3838 PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T, 3839 COMPRO_VIDEOMATE_U500_PC, 3840 AVERMEDIA_EXPRESS, 3841 GIGABYTE_U7000, 3842 ULTIMA_ARTEC_T14BR, 3843 ASUS_U3000, 3844 ASUS_U3100, 3845 HAUPPAUGE_NOVA_T_STICK_3, 3846 HAUPPAUGE_MYTV_T, 3847 TERRATEC_CINERGY_HT_USB_XE, 3848 PINNACLE_EXPRESSCARD_320CX, 3849 PINNACLE_PCTV72E, 3850 PINNACLE_PCTV73E, 3851 YUAN_EC372S, 3852 TERRATEC_CINERGY_HT_EXPRESS, 3853 TERRATEC_CINERGY_T_XXS, 3854 LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2, 3855 HAUPPAUGE_NOVA_TD_STICK_52009, 3856 HAUPPAUGE_NOVA_T_500_3, 3857 GIGABYTE_U8000, 3858 YUAN_STK7700PH, 3859 ASUS_U3000H, 3860 PINNACLE_PCTV801E, 3861 PINNACLE_PCTV801E_SE, 3862 TERRATEC_CINERGY_T_EXPRESS, 3863 TERRATEC_CINERGY_DT_XS_DIVERSITY_2, 3864 SONY_PLAYTV, 3865 YUAN_PD378S, 3866 HAUPPAUGE_TIGER_ATSC, 3867 HAUPPAUGE_TIGER_ATSC_B210, 3868 YUAN_MC770, 3869 ELGATO_EYETV_DTT, 3870 ELGATO_EYETV_DTT_Dlx, 3871 LEADTEK_WINFAST_DTV_DONGLE_H, 3872 TERRATEC_T3, 3873 TERRATEC_T5, 3874 YUAN_STK7700D, 3875 YUAN_STK7700D_2, 3876 PINNACLE_PCTV73A, 3877 PCTV_PINNACLE_PCTV73ESE, 3878 PCTV_PINNACLE_PCTV282E, 3879 DIBCOM_STK7770P, 3880 TERRATEC_CINERGY_T_XXS_2, 3881 DIBCOM_STK807XPVR, 3882 DIBCOM_STK807XP, 3883 PIXELVIEW_SBTVD, 3884 EVOLUTEPC_TVWAY_PLUS, 3885 PINNACLE_PCTV73ESE, 3886 PINNACLE_PCTV282E, 3887 DIBCOM_STK8096GP, 3888 ELGATO_EYETV_DIVERSITY, 3889 DIBCOM_NIM9090M, 3890 DIBCOM_NIM8096MD, 3891 DIBCOM_NIM9090MD, 3892 DIBCOM_NIM7090, 3893 DIBCOM_TFE7090PVR, 3894 TECHNISAT_AIRSTAR_TELESTICK_2, 3895 MEDION_CREATIX_CTX1921, 3896 PINNACLE_PCTV340E, 3897 PINNACLE_PCTV340E_SE, 3898 DIBCOM_TFE7790P, 3899 DIBCOM_TFE8096P, 3900 ELGATO_EYETV_DTT_2, 3901 PCTV_2002E, 3902 PCTV_2002E_SE, 3903 PCTV_DIBCOM_STK8096PVR, 3904 DIBCOM_STK8096PVR, 3905 HAMA_DVBT_HYBRID, 3906 MICROSOFT_XBOX_ONE_TUNER, 3907 }; 3908 3909 struct usb_device_id dib0700_usb_id_table[] = { 3910 DVB_USB_DEV(DIBCOM, DIBCOM_STK7700P), 3911 DVB_USB_DEV(DIBCOM, DIBCOM_STK7700P_PC), 3912 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500), 3913 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500_2), 3914 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK), 3915 DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR), 3916 DVB_USB_DEV(COMPRO, COMPRO_VIDEOMATE_U500), 3917 DVB_USB_DEV(UNIWILL, UNIWILL_STK7700P), 3918 DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_STK7700P), 3919 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK_2), 3920 DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR_2), 3921 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV2000E), 3922 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_DT_XS_DIVERSITY), 3923 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_TD_STICK), 3924 DVB_USB_DEV(DIBCOM, DIBCOM_STK7700D), 3925 DVB_USB_DEV(DIBCOM, DIBCOM_STK7070P), 3926 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_DVB_T_FLASH), 3927 DVB_USB_DEV(DIBCOM, DIBCOM_STK7070PD), 3928 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T), 3929 DVB_USB_DEV(COMPRO, COMPRO_VIDEOMATE_U500_PC), 3930 DVB_USB_DEV(AVERMEDIA, AVERMEDIA_EXPRESS), 3931 DVB_USB_DEV(GIGABYTE, GIGABYTE_U7000), 3932 DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_ARTEC_T14BR), 3933 DVB_USB_DEV(ASUS, ASUS_U3000), 3934 DVB_USB_DEV(ASUS, ASUS_U3100), 3935 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK_3), 3936 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_MYTV_T), 3937 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_HT_USB_XE), 3938 DVB_USB_DEV(PINNACLE, PINNACLE_EXPRESSCARD_320CX), 3939 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV72E), 3940 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73E), 3941 DVB_USB_DEV(YUAN, YUAN_EC372S), 3942 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_HT_EXPRESS), 3943 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_XXS), 3944 DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2), 3945 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_TD_STICK_52009), 3946 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500_3), 3947 DVB_USB_DEV(GIGABYTE, GIGABYTE_U8000), 3948 DVB_USB_DEV(YUAN, YUAN_STK7700PH), 3949 DVB_USB_DEV(ASUS, ASUS_U3000H), 3950 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV801E), 3951 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV801E_SE), 3952 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_EXPRESS), 3953 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_DT_XS_DIVERSITY_2), 3954 DVB_USB_DEV(SONY, SONY_PLAYTV), 3955 DVB_USB_DEV(YUAN, YUAN_PD378S), 3956 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_TIGER_ATSC), 3957 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_TIGER_ATSC_B210), 3958 DVB_USB_DEV(YUAN, YUAN_MC770), 3959 DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT), 3960 DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT_Dlx), 3961 DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_H), 3962 DVB_USB_DEV(TERRATEC, TERRATEC_T3), 3963 DVB_USB_DEV(TERRATEC, TERRATEC_T5), 3964 DVB_USB_DEV(YUAN, YUAN_STK7700D), 3965 DVB_USB_DEV(YUAN, YUAN_STK7700D_2), 3966 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73A), 3967 DVB_USB_DEV(PCTV, PCTV_PINNACLE_PCTV73ESE), 3968 DVB_USB_DEV(PCTV, PCTV_PINNACLE_PCTV282E), 3969 DVB_USB_DEV(DIBCOM, DIBCOM_STK7770P), 3970 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_XXS_2), 3971 DVB_USB_DEV(DIBCOM, DIBCOM_STK807XPVR), 3972 DVB_USB_DEV(DIBCOM, DIBCOM_STK807XP), 3973 DVB_USB_DEV_VER(PIXELVIEW, PIXELVIEW_SBTVD, 0x000, 0x3f00), 3974 DVB_USB_DEV(EVOLUTEPC, EVOLUTEPC_TVWAY_PLUS), 3975 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73ESE), 3976 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV282E), 3977 DVB_USB_DEV(DIBCOM, DIBCOM_STK8096GP), 3978 DVB_USB_DEV(ELGATO, ELGATO_EYETV_DIVERSITY), 3979 DVB_USB_DEV(DIBCOM, DIBCOM_NIM9090M), 3980 DVB_USB_DEV(DIBCOM, DIBCOM_NIM8096MD), 3981 DVB_USB_DEV(DIBCOM, DIBCOM_NIM9090MD), 3982 DVB_USB_DEV(DIBCOM, DIBCOM_NIM7090), 3983 DVB_USB_DEV(DIBCOM, DIBCOM_TFE7090PVR), 3984 DVB_USB_DEV(TECHNISAT, TECHNISAT_AIRSTAR_TELESTICK_2), 3985 DVB_USB_DEV(MEDION, MEDION_CREATIX_CTX1921), 3986 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV340E), 3987 DVB_USB_DEV(PINNACLE, PINNACLE_PCTV340E_SE), 3988 DVB_USB_DEV(DIBCOM, DIBCOM_TFE7790P), 3989 DVB_USB_DEV(DIBCOM, DIBCOM_TFE8096P), 3990 DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT_2), 3991 DVB_USB_DEV(PCTV, PCTV_2002E), 3992 DVB_USB_DEV(PCTV, PCTV_2002E_SE), 3993 DVB_USB_DEV(PCTV, PCTV_DIBCOM_STK8096PVR), 3994 DVB_USB_DEV(DIBCOM, DIBCOM_STK8096PVR), 3995 DVB_USB_DEV(HAMA, HAMA_DVBT_HYBRID), 3996 DVB_USB_DEV(MICROSOFT, MICROSOFT_XBOX_ONE_TUNER), 3997 { } 3998 }; 3999 4000 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table); 4001 4002 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \ 4003 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \ 4004 .usb_ctrl = DEVICE_SPECIFIC, \ 4005 .firmware = "dvb-usb-dib0700-1.20.fw", \ 4006 .download_firmware = dib0700_download_firmware, \ 4007 .no_reconnect = 1, \ 4008 .size_of_priv = sizeof(struct dib0700_state), \ 4009 .i2c_algo = &dib0700_i2c_algo, \ 4010 .identify_state = dib0700_identify_state 4011 4012 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \ 4013 .streaming_ctrl = dib0700_streaming_ctrl, \ 4014 .stream = { \ 4015 .type = USB_BULK, \ 4016 .count = 4, \ 4017 .endpoint = ep, \ 4018 .u = { \ 4019 .bulk = { \ 4020 .buffersize = 39480, \ 4021 } \ 4022 } \ 4023 } 4024 4025 #define DIB0700_NUM_FRONTENDS(n) \ 4026 .num_frontends = n, \ 4027 .size_of_priv = sizeof(struct dib0700_adapter_state) 4028 4029 struct dvb_usb_device_properties dib0700_devices[] = { 4030 { 4031 DIB0700_DEFAULT_DEVICE_PROPERTIES, 4032 4033 .num_adapters = 1, 4034 .adapter = { 4035 { 4036 DIB0700_NUM_FRONTENDS(1), 4037 .fe = {{ 4038 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4039 .pid_filter_count = 32, 4040 .pid_filter = stk7700p_pid_filter, 4041 .pid_filter_ctrl = stk7700p_pid_filter_ctrl, 4042 .frontend_attach = stk7700p_frontend_attach, 4043 .tuner_attach = stk7700p_tuner_attach, 4044 4045 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4046 }}, 4047 }, 4048 }, 4049 4050 .num_device_descs = 8, 4051 .devices = { 4052 { "DiBcom STK7700P reference design", 4053 { &dib0700_usb_id_table[DIBCOM_STK7700P], &dib0700_usb_id_table[DIBCOM_STK7700P_PC] }, 4054 { NULL }, 4055 }, 4056 { "Hauppauge Nova-T Stick", 4057 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK], &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK_2], NULL }, 4058 { NULL }, 4059 }, 4060 { "AVerMedia AVerTV DVB-T Volar", 4061 { &dib0700_usb_id_table[AVERMEDIA_VOLAR], &dib0700_usb_id_table[AVERMEDIA_VOLAR_2] }, 4062 { NULL }, 4063 }, 4064 { "Compro Videomate U500", 4065 { &dib0700_usb_id_table[COMPRO_VIDEOMATE_U500], &dib0700_usb_id_table[COMPRO_VIDEOMATE_U500_PC] }, 4066 { NULL }, 4067 }, 4068 { "Uniwill STK7700P based (Hama and others)", 4069 { &dib0700_usb_id_table[UNIWILL_STK7700P], NULL }, 4070 { NULL }, 4071 }, 4072 { "Leadtek Winfast DTV Dongle (STK7700P based)", 4073 { &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_STK7700P], &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2] }, 4074 { NULL }, 4075 }, 4076 { "AVerMedia AVerTV DVB-T Express", 4077 { &dib0700_usb_id_table[AVERMEDIA_EXPRESS] }, 4078 { NULL }, 4079 }, 4080 { "Gigabyte U7000", 4081 { &dib0700_usb_id_table[GIGABYTE_U7000], NULL }, 4082 { NULL }, 4083 } 4084 }, 4085 4086 .rc.core = { 4087 .rc_interval = DEFAULT_RC_INTERVAL, 4088 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4089 .rc_query = dib0700_rc_query_old_firmware, 4090 .allowed_protos = RC_PROTO_BIT_RC5 | 4091 RC_PROTO_BIT_RC6_MCE | 4092 RC_PROTO_BIT_NEC, 4093 .change_protocol = dib0700_change_protocol, 4094 }, 4095 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4096 4097 .num_adapters = 2, 4098 .adapter = { 4099 { 4100 DIB0700_NUM_FRONTENDS(1), 4101 .fe = {{ 4102 .frontend_attach = bristol_frontend_attach, 4103 .tuner_attach = bristol_tuner_attach, 4104 4105 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4106 }}, 4107 }, { 4108 DIB0700_NUM_FRONTENDS(1), 4109 .fe = {{ 4110 .frontend_attach = bristol_frontend_attach, 4111 .tuner_attach = bristol_tuner_attach, 4112 4113 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 4114 }}, 4115 } 4116 }, 4117 4118 .num_device_descs = 1, 4119 .devices = { 4120 { "Hauppauge Nova-T 500 Dual DVB-T", 4121 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500], &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500_2], NULL }, 4122 { NULL }, 4123 }, 4124 }, 4125 4126 .rc.core = { 4127 .rc_interval = DEFAULT_RC_INTERVAL, 4128 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4129 .rc_query = dib0700_rc_query_old_firmware, 4130 .allowed_protos = RC_PROTO_BIT_RC5 | 4131 RC_PROTO_BIT_RC6_MCE | 4132 RC_PROTO_BIT_NEC, 4133 .change_protocol = dib0700_change_protocol, 4134 }, 4135 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4136 4137 .num_adapters = 2, 4138 .adapter = { 4139 { 4140 DIB0700_NUM_FRONTENDS(1), 4141 .fe = {{ 4142 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4143 .pid_filter_count = 32, 4144 .pid_filter = stk70x0p_pid_filter, 4145 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4146 .frontend_attach = stk7700d_frontend_attach, 4147 .tuner_attach = stk7700d_tuner_attach, 4148 4149 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4150 }}, 4151 }, { 4152 DIB0700_NUM_FRONTENDS(1), 4153 .fe = {{ 4154 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4155 .pid_filter_count = 32, 4156 .pid_filter = stk70x0p_pid_filter, 4157 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4158 .frontend_attach = stk7700d_frontend_attach, 4159 .tuner_attach = stk7700d_tuner_attach, 4160 4161 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 4162 }}, 4163 } 4164 }, 4165 4166 .num_device_descs = 5, 4167 .devices = { 4168 { "Pinnacle PCTV 2000e", 4169 { &dib0700_usb_id_table[PINNACLE_PCTV2000E], NULL }, 4170 { NULL }, 4171 }, 4172 { "Terratec Cinergy DT XS Diversity", 4173 { &dib0700_usb_id_table[TERRATEC_CINERGY_DT_XS_DIVERSITY], NULL }, 4174 { NULL }, 4175 }, 4176 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity", 4177 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_TD_STICK], NULL }, 4178 { NULL }, 4179 }, 4180 { "DiBcom STK7700D reference design", 4181 { &dib0700_usb_id_table[DIBCOM_STK7700D], NULL }, 4182 { NULL }, 4183 }, 4184 { "YUAN High-Tech DiBcom STK7700D", 4185 { &dib0700_usb_id_table[YUAN_STK7700D_2], NULL }, 4186 { NULL }, 4187 }, 4188 4189 }, 4190 4191 .rc.core = { 4192 .rc_interval = DEFAULT_RC_INTERVAL, 4193 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4194 .rc_query = dib0700_rc_query_old_firmware, 4195 .allowed_protos = RC_PROTO_BIT_RC5 | 4196 RC_PROTO_BIT_RC6_MCE | 4197 RC_PROTO_BIT_NEC, 4198 .change_protocol = dib0700_change_protocol, 4199 }, 4200 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4201 4202 .num_adapters = 1, 4203 .adapter = { 4204 { 4205 DIB0700_NUM_FRONTENDS(1), 4206 .fe = {{ 4207 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4208 .pid_filter_count = 32, 4209 .pid_filter = stk70x0p_pid_filter, 4210 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4211 .frontend_attach = stk7700P2_frontend_attach, 4212 .tuner_attach = stk7700d_tuner_attach, 4213 4214 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4215 }}, 4216 }, 4217 }, 4218 4219 .num_device_descs = 3, 4220 .devices = { 4221 { "ASUS My Cinema U3000 Mini DVBT Tuner", 4222 { &dib0700_usb_id_table[ASUS_U3000], NULL }, 4223 { NULL }, 4224 }, 4225 { "Yuan EC372S", 4226 { &dib0700_usb_id_table[YUAN_EC372S], NULL }, 4227 { NULL }, 4228 }, 4229 { "Terratec Cinergy T Express", 4230 { &dib0700_usb_id_table[TERRATEC_CINERGY_T_EXPRESS], NULL }, 4231 { NULL }, 4232 } 4233 }, 4234 4235 .rc.core = { 4236 .rc_interval = DEFAULT_RC_INTERVAL, 4237 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4238 .module_name = "dib0700", 4239 .rc_query = dib0700_rc_query_old_firmware, 4240 .allowed_protos = RC_PROTO_BIT_RC5 | 4241 RC_PROTO_BIT_RC6_MCE | 4242 RC_PROTO_BIT_NEC, 4243 .change_protocol = dib0700_change_protocol, 4244 }, 4245 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4246 4247 .num_adapters = 1, 4248 .adapter = { 4249 { 4250 DIB0700_NUM_FRONTENDS(1), 4251 .fe = {{ 4252 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4253 .pid_filter_count = 32, 4254 .pid_filter = stk70x0p_pid_filter, 4255 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4256 .frontend_attach = stk7070p_frontend_attach, 4257 .tuner_attach = dib7070p_tuner_attach, 4258 4259 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4260 }}, 4261 }, 4262 }, 4263 4264 .num_device_descs = 12, 4265 .devices = { 4266 { "DiBcom STK7070P reference design", 4267 { &dib0700_usb_id_table[DIBCOM_STK7070P], NULL }, 4268 { NULL }, 4269 }, 4270 { "Pinnacle PCTV DVB-T Flash Stick", 4271 { &dib0700_usb_id_table[PINNACLE_PCTV_DVB_T_FLASH], NULL }, 4272 { NULL }, 4273 }, 4274 { "Artec T14BR DVB-T", 4275 { &dib0700_usb_id_table[ULTIMA_ARTEC_T14BR], NULL }, 4276 { NULL }, 4277 }, 4278 { "ASUS My Cinema U3100 Mini DVBT Tuner", 4279 { &dib0700_usb_id_table[ASUS_U3100], NULL }, 4280 { NULL }, 4281 }, 4282 { "Hauppauge Nova-T Stick", 4283 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK_3], NULL }, 4284 { NULL }, 4285 }, 4286 { "Hauppauge Nova-T MyTV.t", 4287 { &dib0700_usb_id_table[HAUPPAUGE_MYTV_T], NULL }, 4288 { NULL }, 4289 }, 4290 { "Pinnacle PCTV 72e", 4291 { &dib0700_usb_id_table[PINNACLE_PCTV72E], NULL }, 4292 { NULL }, 4293 }, 4294 { "Pinnacle PCTV 73e", 4295 { &dib0700_usb_id_table[PINNACLE_PCTV73E], NULL }, 4296 { NULL }, 4297 }, 4298 { "Elgato EyeTV DTT", 4299 { &dib0700_usb_id_table[ELGATO_EYETV_DTT], NULL }, 4300 { NULL }, 4301 }, 4302 { "Yuan PD378S", 4303 { &dib0700_usb_id_table[YUAN_PD378S], NULL }, 4304 { NULL }, 4305 }, 4306 { "Elgato EyeTV Dtt Dlx PD378S", 4307 { &dib0700_usb_id_table[ELGATO_EYETV_DTT_Dlx], NULL }, 4308 { NULL }, 4309 }, 4310 { "Elgato EyeTV DTT rev. 2", 4311 { &dib0700_usb_id_table[ELGATO_EYETV_DTT_2], NULL }, 4312 { NULL }, 4313 }, 4314 }, 4315 4316 .rc.core = { 4317 .rc_interval = DEFAULT_RC_INTERVAL, 4318 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4319 .module_name = "dib0700", 4320 .rc_query = dib0700_rc_query_old_firmware, 4321 .allowed_protos = RC_PROTO_BIT_RC5 | 4322 RC_PROTO_BIT_RC6_MCE | 4323 RC_PROTO_BIT_NEC, 4324 .change_protocol = dib0700_change_protocol, 4325 }, 4326 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4327 4328 .num_adapters = 1, 4329 .adapter = { 4330 { 4331 DIB0700_NUM_FRONTENDS(1), 4332 .fe = {{ 4333 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4334 .pid_filter_count = 32, 4335 .pid_filter = stk70x0p_pid_filter, 4336 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4337 .frontend_attach = stk7070p_frontend_attach, 4338 .tuner_attach = dib7070p_tuner_attach, 4339 4340 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4341 }}, 4342 }, 4343 }, 4344 4345 .num_device_descs = 3, 4346 .devices = { 4347 { "Pinnacle PCTV 73A", 4348 { &dib0700_usb_id_table[PINNACLE_PCTV73A], NULL }, 4349 { NULL }, 4350 }, 4351 { "Pinnacle PCTV 73e SE", 4352 { &dib0700_usb_id_table[PCTV_PINNACLE_PCTV73ESE], &dib0700_usb_id_table[PINNACLE_PCTV73ESE], NULL }, 4353 { NULL }, 4354 }, 4355 { "Pinnacle PCTV 282e", 4356 { &dib0700_usb_id_table[PCTV_PINNACLE_PCTV282E], &dib0700_usb_id_table[PINNACLE_PCTV282E], NULL }, 4357 { NULL }, 4358 }, 4359 }, 4360 4361 .rc.core = { 4362 .rc_interval = DEFAULT_RC_INTERVAL, 4363 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4364 .module_name = "dib0700", 4365 .rc_query = dib0700_rc_query_old_firmware, 4366 .allowed_protos = RC_PROTO_BIT_RC5 | 4367 RC_PROTO_BIT_RC6_MCE | 4368 RC_PROTO_BIT_NEC, 4369 .change_protocol = dib0700_change_protocol, 4370 }, 4371 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4372 4373 .num_adapters = 2, 4374 .adapter = { 4375 { 4376 DIB0700_NUM_FRONTENDS(1), 4377 .fe = {{ 4378 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4379 .pid_filter_count = 32, 4380 .pid_filter = stk70x0p_pid_filter, 4381 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4382 .frontend_attach = novatd_frontend_attach, 4383 .tuner_attach = dib7070p_tuner_attach, 4384 4385 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4386 }}, 4387 }, { 4388 DIB0700_NUM_FRONTENDS(1), 4389 .fe = {{ 4390 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4391 .pid_filter_count = 32, 4392 .pid_filter = stk70x0p_pid_filter, 4393 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4394 .frontend_attach = novatd_frontend_attach, 4395 .tuner_attach = dib7070p_tuner_attach, 4396 4397 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 4398 }}, 4399 } 4400 }, 4401 4402 .num_device_descs = 3, 4403 .devices = { 4404 { "Hauppauge Nova-TD Stick (52009)", 4405 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_TD_STICK_52009], NULL }, 4406 { NULL }, 4407 }, 4408 { "PCTV 2002e", 4409 { &dib0700_usb_id_table[PCTV_2002E], NULL }, 4410 { NULL }, 4411 }, 4412 { "PCTV 2002e SE", 4413 { &dib0700_usb_id_table[PCTV_2002E_SE], NULL }, 4414 { NULL }, 4415 }, 4416 }, 4417 4418 .rc.core = { 4419 .rc_interval = DEFAULT_RC_INTERVAL, 4420 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4421 .module_name = "dib0700", 4422 .rc_query = dib0700_rc_query_old_firmware, 4423 .allowed_protos = RC_PROTO_BIT_RC5 | 4424 RC_PROTO_BIT_RC6_MCE | 4425 RC_PROTO_BIT_NEC, 4426 .change_protocol = dib0700_change_protocol, 4427 }, 4428 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4429 4430 .num_adapters = 2, 4431 .adapter = { 4432 { 4433 DIB0700_NUM_FRONTENDS(1), 4434 .fe = {{ 4435 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4436 .pid_filter_count = 32, 4437 .pid_filter = stk70x0p_pid_filter, 4438 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4439 .frontend_attach = stk7070pd_frontend_attach0, 4440 .tuner_attach = dib7070p_tuner_attach, 4441 4442 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4443 }}, 4444 }, { 4445 DIB0700_NUM_FRONTENDS(1), 4446 .fe = {{ 4447 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4448 .pid_filter_count = 32, 4449 .pid_filter = stk70x0p_pid_filter, 4450 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4451 .frontend_attach = stk7070pd_frontend_attach1, 4452 .tuner_attach = dib7070p_tuner_attach, 4453 4454 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 4455 }}, 4456 } 4457 }, 4458 4459 .num_device_descs = 5, 4460 .devices = { 4461 { "DiBcom STK7070PD reference design", 4462 { &dib0700_usb_id_table[DIBCOM_STK7070PD], NULL }, 4463 { NULL }, 4464 }, 4465 { "Pinnacle PCTV Dual DVB-T Diversity Stick", 4466 { &dib0700_usb_id_table[PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T], NULL }, 4467 { NULL }, 4468 }, 4469 { "Hauppauge Nova-TD-500 (84xxx)", 4470 { &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500_3], NULL }, 4471 { NULL }, 4472 }, 4473 { "Terratec Cinergy DT USB XS Diversity/ T5", 4474 { &dib0700_usb_id_table[TERRATEC_CINERGY_DT_XS_DIVERSITY_2], 4475 &dib0700_usb_id_table[TERRATEC_T5], NULL}, 4476 { NULL }, 4477 }, 4478 { "Sony PlayTV", 4479 { &dib0700_usb_id_table[SONY_PLAYTV], NULL }, 4480 { NULL }, 4481 }, 4482 }, 4483 4484 .rc.core = { 4485 .rc_interval = DEFAULT_RC_INTERVAL, 4486 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4487 .module_name = "dib0700", 4488 .rc_query = dib0700_rc_query_old_firmware, 4489 .allowed_protos = RC_PROTO_BIT_RC5 | 4490 RC_PROTO_BIT_RC6_MCE | 4491 RC_PROTO_BIT_NEC, 4492 .change_protocol = dib0700_change_protocol, 4493 }, 4494 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4495 4496 .num_adapters = 2, 4497 .adapter = { 4498 { 4499 DIB0700_NUM_FRONTENDS(1), 4500 .fe = {{ 4501 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4502 .pid_filter_count = 32, 4503 .pid_filter = stk70x0p_pid_filter, 4504 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4505 .frontend_attach = stk7070pd_frontend_attach0, 4506 .tuner_attach = dib7070p_tuner_attach, 4507 4508 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4509 }}, 4510 }, { 4511 DIB0700_NUM_FRONTENDS(1), 4512 .fe = {{ 4513 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4514 .pid_filter_count = 32, 4515 .pid_filter = stk70x0p_pid_filter, 4516 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4517 .frontend_attach = stk7070pd_frontend_attach1, 4518 .tuner_attach = dib7070p_tuner_attach, 4519 4520 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 4521 }}, 4522 } 4523 }, 4524 4525 .num_device_descs = 1, 4526 .devices = { 4527 { "Elgato EyeTV Diversity", 4528 { &dib0700_usb_id_table[ELGATO_EYETV_DIVERSITY], NULL }, 4529 { NULL }, 4530 }, 4531 }, 4532 4533 .rc.core = { 4534 .rc_interval = DEFAULT_RC_INTERVAL, 4535 .rc_codes = RC_MAP_DIB0700_NEC_TABLE, 4536 .module_name = "dib0700", 4537 .rc_query = dib0700_rc_query_old_firmware, 4538 .allowed_protos = RC_PROTO_BIT_RC5 | 4539 RC_PROTO_BIT_RC6_MCE | 4540 RC_PROTO_BIT_NEC, 4541 .change_protocol = dib0700_change_protocol, 4542 }, 4543 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4544 4545 .num_adapters = 1, 4546 .adapter = { 4547 { 4548 DIB0700_NUM_FRONTENDS(1), 4549 .fe = {{ 4550 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4551 .pid_filter_count = 32, 4552 .pid_filter = stk70x0p_pid_filter, 4553 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4554 .frontend_attach = stk7700ph_frontend_attach, 4555 .tuner_attach = stk7700ph_tuner_attach, 4556 4557 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4558 }}, 4559 }, 4560 }, 4561 4562 .num_device_descs = 10, 4563 .devices = { 4564 { "Terratec Cinergy HT USB XE", 4565 { &dib0700_usb_id_table[TERRATEC_CINERGY_HT_USB_XE], NULL }, 4566 { NULL }, 4567 }, 4568 { "Pinnacle Expresscard 320cx", 4569 { &dib0700_usb_id_table[PINNACLE_EXPRESSCARD_320CX], NULL }, 4570 { NULL }, 4571 }, 4572 { "Terratec Cinergy HT Express", 4573 { &dib0700_usb_id_table[TERRATEC_CINERGY_HT_EXPRESS], NULL }, 4574 { NULL }, 4575 }, 4576 { "Gigabyte U8000-RH", 4577 { &dib0700_usb_id_table[GIGABYTE_U8000], NULL }, 4578 { NULL }, 4579 }, 4580 { "YUAN High-Tech STK7700PH", 4581 { &dib0700_usb_id_table[YUAN_STK7700PH], NULL }, 4582 { NULL }, 4583 }, 4584 { "Asus My Cinema-U3000Hybrid", 4585 { &dib0700_usb_id_table[ASUS_U3000H], NULL }, 4586 { NULL }, 4587 }, 4588 { "YUAN High-Tech MC770", 4589 { &dib0700_usb_id_table[YUAN_MC770], NULL }, 4590 { NULL }, 4591 }, 4592 { "Leadtek WinFast DTV Dongle H", 4593 { &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_H], NULL }, 4594 { NULL }, 4595 }, 4596 { "YUAN High-Tech STK7700D", 4597 { &dib0700_usb_id_table[YUAN_STK7700D], NULL }, 4598 { NULL }, 4599 }, 4600 { "Hama DVB=T Hybrid USB Stick", 4601 { &dib0700_usb_id_table[HAMA_DVBT_HYBRID], NULL }, 4602 { NULL }, 4603 }, 4604 }, 4605 4606 .rc.core = { 4607 .rc_interval = DEFAULT_RC_INTERVAL, 4608 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4609 .module_name = "dib0700", 4610 .rc_query = dib0700_rc_query_old_firmware, 4611 .allowed_protos = RC_PROTO_BIT_RC5 | 4612 RC_PROTO_BIT_RC6_MCE | 4613 RC_PROTO_BIT_NEC, 4614 .change_protocol = dib0700_change_protocol, 4615 }, 4616 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4617 .num_adapters = 1, 4618 .adapter = { 4619 { 4620 DIB0700_NUM_FRONTENDS(1), 4621 .fe = {{ 4622 .frontend_attach = s5h1411_frontend_attach, 4623 .tuner_attach = xc5000_tuner_attach, 4624 4625 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4626 }}, 4627 }, 4628 }, 4629 4630 .num_device_descs = 2, 4631 .devices = { 4632 { "Pinnacle PCTV HD Pro USB Stick", 4633 { &dib0700_usb_id_table[PINNACLE_PCTV801E], NULL }, 4634 { NULL }, 4635 }, 4636 { "Pinnacle PCTV HD USB Stick", 4637 { &dib0700_usb_id_table[PINNACLE_PCTV801E_SE], NULL }, 4638 { NULL }, 4639 }, 4640 }, 4641 4642 .rc.core = { 4643 .rc_interval = DEFAULT_RC_INTERVAL, 4644 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4645 .module_name = "dib0700", 4646 .rc_query = dib0700_rc_query_old_firmware, 4647 .allowed_protos = RC_PROTO_BIT_RC5 | 4648 RC_PROTO_BIT_RC6_MCE | 4649 RC_PROTO_BIT_NEC, 4650 .change_protocol = dib0700_change_protocol, 4651 }, 4652 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4653 .num_adapters = 1, 4654 .adapter = { 4655 { 4656 DIB0700_NUM_FRONTENDS(1), 4657 .fe = {{ 4658 .frontend_attach = lgdt3305_frontend_attach, 4659 .tuner_attach = mxl5007t_tuner_attach, 4660 4661 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4662 }}, 4663 }, 4664 }, 4665 4666 .num_device_descs = 2, 4667 .devices = { 4668 { "Hauppauge ATSC MiniCard (B200)", 4669 { &dib0700_usb_id_table[HAUPPAUGE_TIGER_ATSC], NULL }, 4670 { NULL }, 4671 }, 4672 { "Hauppauge ATSC MiniCard (B210)", 4673 { &dib0700_usb_id_table[HAUPPAUGE_TIGER_ATSC_B210], NULL }, 4674 { NULL }, 4675 }, 4676 }, 4677 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4678 4679 .num_adapters = 1, 4680 .adapter = { 4681 { 4682 DIB0700_NUM_FRONTENDS(1), 4683 .fe = {{ 4684 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4685 .pid_filter_count = 32, 4686 .pid_filter = stk70x0p_pid_filter, 4687 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4688 .frontend_attach = stk7770p_frontend_attach, 4689 .tuner_attach = dib7770p_tuner_attach, 4690 4691 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4692 }}, 4693 }, 4694 }, 4695 4696 .num_device_descs = 4, 4697 .devices = { 4698 { "DiBcom STK7770P reference design", 4699 { &dib0700_usb_id_table[DIBCOM_STK7770P], NULL }, 4700 { NULL }, 4701 }, 4702 { "Terratec Cinergy T USB XXS (HD)/ T3", 4703 { &dib0700_usb_id_table[TERRATEC_CINERGY_T_XXS], 4704 &dib0700_usb_id_table[TERRATEC_T3], 4705 &dib0700_usb_id_table[TERRATEC_CINERGY_T_XXS_2], NULL}, 4706 { NULL }, 4707 }, 4708 { "TechniSat AirStar TeleStick 2", 4709 { &dib0700_usb_id_table[TECHNISAT_AIRSTAR_TELESTICK_2], NULL }, 4710 { NULL }, 4711 }, 4712 { "Medion CTX1921 DVB-T USB", 4713 { &dib0700_usb_id_table[MEDION_CREATIX_CTX1921], NULL }, 4714 { NULL }, 4715 }, 4716 }, 4717 4718 .rc.core = { 4719 .rc_interval = DEFAULT_RC_INTERVAL, 4720 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4721 .module_name = "dib0700", 4722 .rc_query = dib0700_rc_query_old_firmware, 4723 .allowed_protos = RC_PROTO_BIT_RC5 | 4724 RC_PROTO_BIT_RC6_MCE | 4725 RC_PROTO_BIT_NEC, 4726 .change_protocol = dib0700_change_protocol, 4727 }, 4728 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4729 .num_adapters = 1, 4730 .adapter = { 4731 { 4732 DIB0700_NUM_FRONTENDS(1), 4733 .fe = {{ 4734 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4735 .pid_filter_count = 32, 4736 .pid_filter = stk80xx_pid_filter, 4737 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 4738 .frontend_attach = stk807x_frontend_attach, 4739 .tuner_attach = dib807x_tuner_attach, 4740 4741 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4742 }}, 4743 }, 4744 }, 4745 4746 .num_device_descs = 3, 4747 .devices = { 4748 { "DiBcom STK807xP reference design", 4749 { &dib0700_usb_id_table[DIBCOM_STK807XP], NULL }, 4750 { NULL }, 4751 }, 4752 { "Prolink Pixelview SBTVD", 4753 { &dib0700_usb_id_table[PIXELVIEW_SBTVD], NULL }, 4754 { NULL }, 4755 }, 4756 { "EvolutePC TVWay+", 4757 { &dib0700_usb_id_table[EVOLUTEPC_TVWAY_PLUS], NULL }, 4758 { NULL }, 4759 }, 4760 }, 4761 4762 .rc.core = { 4763 .rc_interval = DEFAULT_RC_INTERVAL, 4764 .rc_codes = RC_MAP_DIB0700_NEC_TABLE, 4765 .module_name = "dib0700", 4766 .rc_query = dib0700_rc_query_old_firmware, 4767 .allowed_protos = RC_PROTO_BIT_RC5 | 4768 RC_PROTO_BIT_RC6_MCE | 4769 RC_PROTO_BIT_NEC, 4770 .change_protocol = dib0700_change_protocol, 4771 }, 4772 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4773 .num_adapters = 2, 4774 .adapter = { 4775 { 4776 DIB0700_NUM_FRONTENDS(1), 4777 .fe = {{ 4778 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4779 .pid_filter_count = 32, 4780 .pid_filter = stk80xx_pid_filter, 4781 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 4782 .frontend_attach = stk807xpvr_frontend_attach0, 4783 .tuner_attach = dib807x_tuner_attach, 4784 4785 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4786 }}, 4787 }, 4788 { 4789 DIB0700_NUM_FRONTENDS(1), 4790 .fe = {{ 4791 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4792 .pid_filter_count = 32, 4793 .pid_filter = stk80xx_pid_filter, 4794 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 4795 .frontend_attach = stk807xpvr_frontend_attach1, 4796 .tuner_attach = dib807x_tuner_attach, 4797 4798 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 4799 }}, 4800 }, 4801 }, 4802 4803 .num_device_descs = 1, 4804 .devices = { 4805 { "DiBcom STK807xPVR reference design", 4806 { &dib0700_usb_id_table[DIBCOM_STK807XPVR], NULL }, 4807 { NULL }, 4808 }, 4809 }, 4810 4811 .rc.core = { 4812 .rc_interval = DEFAULT_RC_INTERVAL, 4813 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4814 .module_name = "dib0700", 4815 .rc_query = dib0700_rc_query_old_firmware, 4816 .allowed_protos = RC_PROTO_BIT_RC5 | 4817 RC_PROTO_BIT_RC6_MCE | 4818 RC_PROTO_BIT_NEC, 4819 .change_protocol = dib0700_change_protocol, 4820 }, 4821 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4822 .num_adapters = 1, 4823 .adapter = { 4824 { 4825 DIB0700_NUM_FRONTENDS(1), 4826 .fe = {{ 4827 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 4828 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4829 .pid_filter_count = 32, 4830 .pid_filter = stk80xx_pid_filter, 4831 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 4832 .frontend_attach = stk809x_frontend_attach, 4833 .tuner_attach = dib809x_tuner_attach, 4834 4835 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4836 }}, 4837 }, 4838 }, 4839 4840 .num_device_descs = 1, 4841 .devices = { 4842 { "DiBcom STK8096GP reference design", 4843 { &dib0700_usb_id_table[DIBCOM_STK8096GP], NULL }, 4844 { NULL }, 4845 }, 4846 }, 4847 4848 .rc.core = { 4849 .rc_interval = DEFAULT_RC_INTERVAL, 4850 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4851 .module_name = "dib0700", 4852 .rc_query = dib0700_rc_query_old_firmware, 4853 .allowed_protos = RC_PROTO_BIT_RC5 | 4854 RC_PROTO_BIT_RC6_MCE | 4855 RC_PROTO_BIT_NEC, 4856 .change_protocol = dib0700_change_protocol, 4857 }, 4858 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4859 .num_adapters = 1, 4860 .adapter = { 4861 { 4862 DIB0700_NUM_FRONTENDS(1), 4863 .fe = {{ 4864 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 4865 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4866 .pid_filter_count = 32, 4867 .pid_filter = dib90x0_pid_filter, 4868 .pid_filter_ctrl = dib90x0_pid_filter_ctrl, 4869 .frontend_attach = stk9090m_frontend_attach, 4870 .tuner_attach = dib9090_tuner_attach, 4871 4872 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4873 }}, 4874 }, 4875 }, 4876 4877 .num_device_descs = 1, 4878 .devices = { 4879 { "DiBcom STK9090M reference design", 4880 { &dib0700_usb_id_table[DIBCOM_NIM9090M], NULL }, 4881 { NULL }, 4882 }, 4883 }, 4884 4885 .rc.core = { 4886 .rc_interval = DEFAULT_RC_INTERVAL, 4887 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4888 .module_name = "dib0700", 4889 .rc_query = dib0700_rc_query_old_firmware, 4890 .allowed_protos = RC_PROTO_BIT_RC5 | 4891 RC_PROTO_BIT_RC6_MCE | 4892 RC_PROTO_BIT_NEC, 4893 .change_protocol = dib0700_change_protocol, 4894 }, 4895 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4896 .num_adapters = 1, 4897 .adapter = { 4898 { 4899 DIB0700_NUM_FRONTENDS(1), 4900 .fe = {{ 4901 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 4902 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4903 .pid_filter_count = 32, 4904 .pid_filter = stk80xx_pid_filter, 4905 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 4906 .frontend_attach = nim8096md_frontend_attach, 4907 .tuner_attach = nim8096md_tuner_attach, 4908 4909 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4910 }}, 4911 }, 4912 }, 4913 4914 .num_device_descs = 1, 4915 .devices = { 4916 { "DiBcom NIM8096MD reference design", 4917 { &dib0700_usb_id_table[DIBCOM_NIM8096MD], NULL }, 4918 { NULL }, 4919 }, 4920 }, 4921 4922 .rc.core = { 4923 .rc_interval = DEFAULT_RC_INTERVAL, 4924 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4925 .module_name = "dib0700", 4926 .rc_query = dib0700_rc_query_old_firmware, 4927 .allowed_protos = RC_PROTO_BIT_RC5 | 4928 RC_PROTO_BIT_RC6_MCE | 4929 RC_PROTO_BIT_NEC, 4930 .change_protocol = dib0700_change_protocol, 4931 }, 4932 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 4933 .num_adapters = 1, 4934 .adapter = { 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 = dib90x0_pid_filter, 4942 .pid_filter_ctrl = dib90x0_pid_filter_ctrl, 4943 .frontend_attach = nim9090md_frontend_attach, 4944 .tuner_attach = nim9090md_tuner_attach, 4945 4946 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4947 }}, 4948 }, 4949 }, 4950 4951 .num_device_descs = 1, 4952 .devices = { 4953 { "DiBcom NIM9090MD reference design", 4954 { &dib0700_usb_id_table[DIBCOM_NIM9090MD], 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 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 4976 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 4977 .pid_filter_count = 32, 4978 .pid_filter = stk70x0p_pid_filter, 4979 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 4980 .frontend_attach = nim7090_frontend_attach, 4981 .tuner_attach = nim7090_tuner_attach, 4982 4983 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 4984 }}, 4985 }, 4986 }, 4987 4988 .num_device_descs = 1, 4989 .devices = { 4990 { "DiBcom NIM7090 reference design", 4991 { &dib0700_usb_id_table[DIBCOM_NIM7090], NULL }, 4992 { NULL }, 4993 }, 4994 }, 4995 4996 .rc.core = { 4997 .rc_interval = DEFAULT_RC_INTERVAL, 4998 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 4999 .module_name = "dib0700", 5000 .rc_query = dib0700_rc_query_old_firmware, 5001 .allowed_protos = RC_PROTO_BIT_RC5 | 5002 RC_PROTO_BIT_RC6_MCE | 5003 RC_PROTO_BIT_NEC, 5004 .change_protocol = dib0700_change_protocol, 5005 }, 5006 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 5007 .num_adapters = 2, 5008 .adapter = { 5009 { 5010 DIB0700_NUM_FRONTENDS(1), 5011 .fe = {{ 5012 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 5013 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 5014 .pid_filter_count = 32, 5015 .pid_filter = stk70x0p_pid_filter, 5016 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 5017 .frontend_attach = tfe7090pvr_frontend0_attach, 5018 .tuner_attach = tfe7090pvr_tuner0_attach, 5019 5020 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 5021 }}, 5022 }, 5023 { 5024 DIB0700_NUM_FRONTENDS(1), 5025 .fe = {{ 5026 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 5027 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 5028 .pid_filter_count = 32, 5029 .pid_filter = stk70x0p_pid_filter, 5030 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 5031 .frontend_attach = tfe7090pvr_frontend1_attach, 5032 .tuner_attach = tfe7090pvr_tuner1_attach, 5033 5034 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 5035 }}, 5036 }, 5037 }, 5038 5039 .num_device_descs = 1, 5040 .devices = { 5041 { "DiBcom TFE7090PVR reference design", 5042 { &dib0700_usb_id_table[DIBCOM_TFE7090PVR], NULL }, 5043 { NULL }, 5044 }, 5045 }, 5046 5047 .rc.core = { 5048 .rc_interval = DEFAULT_RC_INTERVAL, 5049 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 5050 .module_name = "dib0700", 5051 .rc_query = dib0700_rc_query_old_firmware, 5052 .allowed_protos = RC_PROTO_BIT_RC5 | 5053 RC_PROTO_BIT_RC6_MCE | 5054 RC_PROTO_BIT_NEC, 5055 .change_protocol = dib0700_change_protocol, 5056 }, 5057 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 5058 .num_adapters = 1, 5059 .adapter = { 5060 { 5061 DIB0700_NUM_FRONTENDS(1), 5062 .fe = {{ 5063 .frontend_attach = pctv340e_frontend_attach, 5064 .tuner_attach = xc4000_tuner_attach, 5065 5066 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 5067 }}, 5068 }, 5069 }, 5070 5071 .num_device_descs = 2, 5072 .devices = { 5073 { "Pinnacle PCTV 340e HD Pro USB Stick", 5074 { &dib0700_usb_id_table[PINNACLE_PCTV340E], NULL }, 5075 { NULL }, 5076 }, 5077 { "Pinnacle PCTV Hybrid Stick Solo", 5078 { &dib0700_usb_id_table[PINNACLE_PCTV340E_SE], NULL }, 5079 { NULL }, 5080 }, 5081 }, 5082 .rc.core = { 5083 .rc_interval = DEFAULT_RC_INTERVAL, 5084 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 5085 .module_name = "dib0700", 5086 .rc_query = dib0700_rc_query_old_firmware, 5087 .allowed_protos = RC_PROTO_BIT_RC5 | 5088 RC_PROTO_BIT_RC6_MCE | 5089 RC_PROTO_BIT_NEC, 5090 .change_protocol = dib0700_change_protocol, 5091 }, 5092 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 5093 .num_adapters = 1, 5094 .adapter = { 5095 { 5096 DIB0700_NUM_FRONTENDS(1), 5097 .fe = {{ 5098 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 5099 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 5100 .pid_filter_count = 32, 5101 .pid_filter = stk70x0p_pid_filter, 5102 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl, 5103 .frontend_attach = tfe7790p_frontend_attach, 5104 .tuner_attach = tfe7790p_tuner_attach, 5105 5106 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 5107 } }, 5108 }, 5109 }, 5110 5111 .num_device_descs = 1, 5112 .devices = { 5113 { "DiBcom TFE7790P reference design", 5114 { &dib0700_usb_id_table[DIBCOM_TFE7790P], NULL }, 5115 { NULL }, 5116 }, 5117 }, 5118 5119 .rc.core = { 5120 .rc_interval = DEFAULT_RC_INTERVAL, 5121 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 5122 .module_name = "dib0700", 5123 .rc_query = dib0700_rc_query_old_firmware, 5124 .allowed_protos = RC_PROTO_BIT_RC5 | 5125 RC_PROTO_BIT_RC6_MCE | 5126 RC_PROTO_BIT_NEC, 5127 .change_protocol = dib0700_change_protocol, 5128 }, 5129 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 5130 .num_adapters = 1, 5131 .adapter = { 5132 { 5133 DIB0700_NUM_FRONTENDS(1), 5134 .fe = {{ 5135 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 5136 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 5137 .pid_filter_count = 32, 5138 .pid_filter = stk80xx_pid_filter, 5139 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 5140 .frontend_attach = tfe8096p_frontend_attach, 5141 .tuner_attach = tfe8096p_tuner_attach, 5142 5143 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 5144 5145 } }, 5146 }, 5147 }, 5148 5149 .num_device_descs = 1, 5150 .devices = { 5151 { "DiBcom TFE8096P reference design", 5152 { &dib0700_usb_id_table[DIBCOM_TFE8096P], NULL }, 5153 { NULL }, 5154 }, 5155 }, 5156 5157 .rc.core = { 5158 .rc_interval = DEFAULT_RC_INTERVAL, 5159 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 5160 .module_name = "dib0700", 5161 .rc_query = dib0700_rc_query_old_firmware, 5162 .allowed_protos = RC_PROTO_BIT_RC5 | 5163 RC_PROTO_BIT_RC6_MCE | 5164 RC_PROTO_BIT_NEC, 5165 .change_protocol = dib0700_change_protocol, 5166 }, 5167 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 5168 .num_adapters = 2, 5169 .adapter = { 5170 { 5171 .num_frontends = 1, 5172 .fe = {{ 5173 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 5174 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 5175 .pid_filter_count = 32, 5176 .pid_filter = stk80xx_pid_filter, 5177 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 5178 .frontend_attach = stk809x_frontend_attach, 5179 .tuner_attach = dib809x_tuner_attach, 5180 5181 DIB0700_DEFAULT_STREAMING_CONFIG(0x02), 5182 } }, 5183 .size_of_priv = 5184 sizeof(struct dib0700_adapter_state), 5185 }, { 5186 .num_frontends = 1, 5187 .fe = { { 5188 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 5189 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 5190 .pid_filter_count = 32, 5191 .pid_filter = stk80xx_pid_filter, 5192 .pid_filter_ctrl = stk80xx_pid_filter_ctrl, 5193 .frontend_attach = stk809x_frontend1_attach, 5194 .tuner_attach = dib809x_tuner_attach, 5195 5196 DIB0700_DEFAULT_STREAMING_CONFIG(0x03), 5197 } }, 5198 .size_of_priv = 5199 sizeof(struct dib0700_adapter_state), 5200 }, 5201 }, 5202 .num_device_descs = 1, 5203 .devices = { 5204 { "DiBcom STK8096-PVR reference design", 5205 { &dib0700_usb_id_table[PCTV_DIBCOM_STK8096PVR], 5206 &dib0700_usb_id_table[DIBCOM_STK8096PVR], NULL}, 5207 { NULL }, 5208 }, 5209 }, 5210 5211 .rc.core = { 5212 .rc_interval = DEFAULT_RC_INTERVAL, 5213 .rc_codes = RC_MAP_DIB0700_RC5_TABLE, 5214 .module_name = "dib0700", 5215 .rc_query = dib0700_rc_query_old_firmware, 5216 .allowed_protos = RC_PROTO_BIT_RC5 | 5217 RC_PROTO_BIT_RC6_MCE | 5218 RC_PROTO_BIT_NEC, 5219 .change_protocol = dib0700_change_protocol, 5220 }, 5221 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, 5222 .num_adapters = 1, 5223 .adapter = { 5224 { 5225 DIB0700_NUM_FRONTENDS(1), 5226 .fe = {{ 5227 .frontend_attach = xbox_one_attach, 5228 5229 DIB0700_DEFAULT_STREAMING_CONFIG(0x82), 5230 } }, 5231 }, 5232 }, 5233 .num_device_descs = 1, 5234 .devices = { 5235 { "Microsoft Xbox One Digital TV Tuner", 5236 { &dib0700_usb_id_table[MICROSOFT_XBOX_ONE_TUNER], NULL }, 5237 { NULL }, 5238 }, 5239 }, 5240 }, 5241 }; 5242 5243 int dib0700_device_count = ARRAY_SIZE(dib0700_devices); 5244