1 /* 2 * Linux-DVB Driver for DiBcom's DiB0090 base-band RF Tuner. 3 * 4 * Copyright (C) 2005-9 DiBcom (http://www.dibcom.fr/) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation; either version 2 of the 9 * License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * 21 * 22 * This code is more or less generated from another driver, please 23 * excuse some codingstyle oddities. 24 * 25 */ 26 27 #include <linux/kernel.h> 28 #include <linux/slab.h> 29 #include <linux/i2c.h> 30 #include <linux/mutex.h> 31 32 #include "dvb_frontend.h" 33 34 #include "dib0090.h" 35 #include "dibx000_common.h" 36 37 static int debug; 38 module_param(debug, int, 0644); 39 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)"); 40 41 #define dprintk(args...) do { \ 42 if (debug) { \ 43 printk(KERN_DEBUG "DiB0090: "); \ 44 printk(args); \ 45 printk("\n"); \ 46 } \ 47 } while (0) 48 49 #define CONFIG_SYS_DVBT 50 #define CONFIG_SYS_ISDBT 51 #define CONFIG_BAND_CBAND 52 #define CONFIG_BAND_VHF 53 #define CONFIG_BAND_UHF 54 #define CONFIG_DIB0090_USE_PWM_AGC 55 56 #define EN_LNA0 0x8000 57 #define EN_LNA1 0x4000 58 #define EN_LNA2 0x2000 59 #define EN_LNA3 0x1000 60 #define EN_MIX0 0x0800 61 #define EN_MIX1 0x0400 62 #define EN_MIX2 0x0200 63 #define EN_MIX3 0x0100 64 #define EN_IQADC 0x0040 65 #define EN_PLL 0x0020 66 #define EN_TX 0x0010 67 #define EN_BB 0x0008 68 #define EN_LO 0x0004 69 #define EN_BIAS 0x0001 70 71 #define EN_IQANA 0x0002 72 #define EN_DIGCLK 0x0080 /* not in the 0x24 reg, only in 0x1b */ 73 #define EN_CRYSTAL 0x0002 74 75 #define EN_UHF 0x22E9 76 #define EN_VHF 0x44E9 77 #define EN_LBD 0x11E9 78 #define EN_SBD 0x44E9 79 #define EN_CAB 0x88E9 80 81 /* Calibration defines */ 82 #define DC_CAL 0x1 83 #define WBD_CAL 0x2 84 #define TEMP_CAL 0x4 85 #define CAPTRIM_CAL 0x8 86 87 #define KROSUS_PLL_LOCKED 0x800 88 #define KROSUS 0x2 89 90 /* Use those defines to identify SOC version */ 91 #define SOC 0x02 92 #define SOC_7090_P1G_11R1 0x82 93 #define SOC_7090_P1G_21R1 0x8a 94 #define SOC_8090_P1G_11R1 0x86 95 #define SOC_8090_P1G_21R1 0x8e 96 97 /* else use thos ones to check */ 98 #define P1A_B 0x0 99 #define P1C 0x1 100 #define P1D_E_F 0x3 101 #define P1G 0x7 102 #define P1G_21R2 0xf 103 104 #define MP001 0x1 /* Single 9090/8096 */ 105 #define MP005 0x4 /* Single Sband */ 106 #define MP008 0x6 /* Dual diversity VHF-UHF-LBAND */ 107 #define MP009 0x7 /* Dual diversity 29098 CBAND-UHF-LBAND-SBAND */ 108 109 #define pgm_read_word(w) (*w) 110 111 struct dc_calibration; 112 113 struct dib0090_tuning { 114 u32 max_freq; /* for every frequency less than or equal to that field: this information is correct */ 115 u8 switch_trim; 116 u8 lna_tune; 117 u16 lna_bias; 118 u16 v2i; 119 u16 mix; 120 u16 load; 121 u16 tuner_enable; 122 }; 123 124 struct dib0090_pll { 125 u32 max_freq; /* for every frequency less than or equal to that field: this information is correct */ 126 u8 vco_band; 127 u8 hfdiv_code; 128 u8 hfdiv; 129 u8 topresc; 130 }; 131 132 struct dib0090_identity { 133 u8 version; 134 u8 product; 135 u8 p1g; 136 u8 in_soc; 137 }; 138 139 struct dib0090_state { 140 struct i2c_adapter *i2c; 141 struct dvb_frontend *fe; 142 const struct dib0090_config *config; 143 144 u8 current_band; 145 enum frontend_tune_state tune_state; 146 u32 current_rf; 147 148 u16 wbd_offset; 149 s16 wbd_target; /* in dB */ 150 151 s16 rf_gain_limit; /* take-over-point: where to split between bb and rf gain */ 152 s16 current_gain; /* keeps the currently programmed gain */ 153 u8 agc_step; /* new binary search */ 154 155 u16 gain[2]; /* for channel monitoring */ 156 157 const u16 *rf_ramp; 158 const u16 *bb_ramp; 159 160 /* for the software AGC ramps */ 161 u16 bb_1_def; 162 u16 rf_lt_def; 163 u16 gain_reg[4]; 164 165 /* for the captrim/dc-offset search */ 166 s8 step; 167 s16 adc_diff; 168 s16 min_adc_diff; 169 170 s8 captrim; 171 s8 fcaptrim; 172 173 const struct dc_calibration *dc; 174 u16 bb6, bb7; 175 176 const struct dib0090_tuning *current_tune_table_index; 177 const struct dib0090_pll *current_pll_table_index; 178 179 u8 tuner_is_tuned; 180 u8 agc_freeze; 181 182 struct dib0090_identity identity; 183 184 u32 rf_request; 185 u8 current_standard; 186 187 u8 calibrate; 188 u32 rest; 189 u16 bias; 190 s16 temperature; 191 192 u8 wbd_calibration_gain; 193 const struct dib0090_wbd_slope *current_wbd_table; 194 u16 wbdmux; 195 196 /* for the I2C transfer */ 197 struct i2c_msg msg[2]; 198 u8 i2c_write_buffer[3]; 199 u8 i2c_read_buffer[2]; 200 struct mutex i2c_buffer_lock; 201 }; 202 203 struct dib0090_fw_state { 204 struct i2c_adapter *i2c; 205 struct dvb_frontend *fe; 206 struct dib0090_identity identity; 207 const struct dib0090_config *config; 208 209 /* for the I2C transfer */ 210 struct i2c_msg msg; 211 u8 i2c_write_buffer[2]; 212 u8 i2c_read_buffer[2]; 213 struct mutex i2c_buffer_lock; 214 }; 215 216 static u16 dib0090_read_reg(struct dib0090_state *state, u8 reg) 217 { 218 u16 ret; 219 220 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) { 221 dprintk("could not acquire lock"); 222 return 0; 223 } 224 225 state->i2c_write_buffer[0] = reg; 226 227 memset(state->msg, 0, 2 * sizeof(struct i2c_msg)); 228 state->msg[0].addr = state->config->i2c_address; 229 state->msg[0].flags = 0; 230 state->msg[0].buf = state->i2c_write_buffer; 231 state->msg[0].len = 1; 232 state->msg[1].addr = state->config->i2c_address; 233 state->msg[1].flags = I2C_M_RD; 234 state->msg[1].buf = state->i2c_read_buffer; 235 state->msg[1].len = 2; 236 237 if (i2c_transfer(state->i2c, state->msg, 2) != 2) { 238 printk(KERN_WARNING "DiB0090 I2C read failed\n"); 239 ret = 0; 240 } else 241 ret = (state->i2c_read_buffer[0] << 8) 242 | state->i2c_read_buffer[1]; 243 244 mutex_unlock(&state->i2c_buffer_lock); 245 return ret; 246 } 247 248 static int dib0090_write_reg(struct dib0090_state *state, u32 reg, u16 val) 249 { 250 int ret; 251 252 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) { 253 dprintk("could not acquire lock"); 254 return -EINVAL; 255 } 256 257 state->i2c_write_buffer[0] = reg & 0xff; 258 state->i2c_write_buffer[1] = val >> 8; 259 state->i2c_write_buffer[2] = val & 0xff; 260 261 memset(state->msg, 0, sizeof(struct i2c_msg)); 262 state->msg[0].addr = state->config->i2c_address; 263 state->msg[0].flags = 0; 264 state->msg[0].buf = state->i2c_write_buffer; 265 state->msg[0].len = 3; 266 267 if (i2c_transfer(state->i2c, state->msg, 1) != 1) { 268 printk(KERN_WARNING "DiB0090 I2C write failed\n"); 269 ret = -EREMOTEIO; 270 } else 271 ret = 0; 272 273 mutex_unlock(&state->i2c_buffer_lock); 274 return ret; 275 } 276 277 static u16 dib0090_fw_read_reg(struct dib0090_fw_state *state, u8 reg) 278 { 279 u16 ret; 280 281 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) { 282 dprintk("could not acquire lock"); 283 return 0; 284 } 285 286 state->i2c_write_buffer[0] = reg; 287 288 memset(&state->msg, 0, sizeof(struct i2c_msg)); 289 state->msg.addr = reg; 290 state->msg.flags = I2C_M_RD; 291 state->msg.buf = state->i2c_read_buffer; 292 state->msg.len = 2; 293 if (i2c_transfer(state->i2c, &state->msg, 1) != 1) { 294 printk(KERN_WARNING "DiB0090 I2C read failed\n"); 295 ret = 0; 296 } else 297 ret = (state->i2c_read_buffer[0] << 8) 298 | state->i2c_read_buffer[1]; 299 300 mutex_unlock(&state->i2c_buffer_lock); 301 return ret; 302 } 303 304 static int dib0090_fw_write_reg(struct dib0090_fw_state *state, u8 reg, u16 val) 305 { 306 int ret; 307 308 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) { 309 dprintk("could not acquire lock"); 310 return -EINVAL; 311 } 312 313 state->i2c_write_buffer[0] = val >> 8; 314 state->i2c_write_buffer[1] = val & 0xff; 315 316 memset(&state->msg, 0, sizeof(struct i2c_msg)); 317 state->msg.addr = reg; 318 state->msg.flags = 0; 319 state->msg.buf = state->i2c_write_buffer; 320 state->msg.len = 2; 321 if (i2c_transfer(state->i2c, &state->msg, 1) != 1) { 322 printk(KERN_WARNING "DiB0090 I2C write failed\n"); 323 ret = -EREMOTEIO; 324 } else 325 ret = 0; 326 327 mutex_unlock(&state->i2c_buffer_lock); 328 return ret; 329 } 330 331 #define HARD_RESET(state) do { if (cfg->reset) { if (cfg->sleep) cfg->sleep(fe, 0); msleep(10); cfg->reset(fe, 1); msleep(10); cfg->reset(fe, 0); msleep(10); } } while (0) 332 #define ADC_TARGET -220 333 #define GAIN_ALPHA 5 334 #define WBD_ALPHA 6 335 #define LPF 100 336 static void dib0090_write_regs(struct dib0090_state *state, u8 r, const u16 * b, u8 c) 337 { 338 do { 339 dib0090_write_reg(state, r++, *b++); 340 } while (--c); 341 } 342 343 static int dib0090_identify(struct dvb_frontend *fe) 344 { 345 struct dib0090_state *state = fe->tuner_priv; 346 u16 v; 347 struct dib0090_identity *identity = &state->identity; 348 349 v = dib0090_read_reg(state, 0x1a); 350 351 identity->p1g = 0; 352 identity->in_soc = 0; 353 354 dprintk("Tuner identification (Version = 0x%04x)", v); 355 356 /* without PLL lock info */ 357 v &= ~KROSUS_PLL_LOCKED; 358 359 identity->version = v & 0xff; 360 identity->product = (v >> 8) & 0xf; 361 362 if (identity->product != KROSUS) 363 goto identification_error; 364 365 if ((identity->version & 0x3) == SOC) { 366 identity->in_soc = 1; 367 switch (identity->version) { 368 case SOC_8090_P1G_11R1: 369 dprintk("SOC 8090 P1-G11R1 Has been detected"); 370 identity->p1g = 1; 371 break; 372 case SOC_8090_P1G_21R1: 373 dprintk("SOC 8090 P1-G21R1 Has been detected"); 374 identity->p1g = 1; 375 break; 376 case SOC_7090_P1G_11R1: 377 dprintk("SOC 7090 P1-G11R1 Has been detected"); 378 identity->p1g = 1; 379 break; 380 case SOC_7090_P1G_21R1: 381 dprintk("SOC 7090 P1-G21R1 Has been detected"); 382 identity->p1g = 1; 383 break; 384 default: 385 goto identification_error; 386 } 387 } else { 388 switch ((identity->version >> 5) & 0x7) { 389 case MP001: 390 dprintk("MP001 : 9090/8096"); 391 break; 392 case MP005: 393 dprintk("MP005 : Single Sband"); 394 break; 395 case MP008: 396 dprintk("MP008 : diversity VHF-UHF-LBAND"); 397 break; 398 case MP009: 399 dprintk("MP009 : diversity 29098 CBAND-UHF-LBAND-SBAND"); 400 break; 401 default: 402 goto identification_error; 403 } 404 405 switch (identity->version & 0x1f) { 406 case P1G_21R2: 407 dprintk("P1G_21R2 detected"); 408 identity->p1g = 1; 409 break; 410 case P1G: 411 dprintk("P1G detected"); 412 identity->p1g = 1; 413 break; 414 case P1D_E_F: 415 dprintk("P1D/E/F detected"); 416 break; 417 case P1C: 418 dprintk("P1C detected"); 419 break; 420 case P1A_B: 421 dprintk("P1-A/B detected: driver is deactivated - not available"); 422 goto identification_error; 423 break; 424 default: 425 goto identification_error; 426 } 427 } 428 429 return 0; 430 431 identification_error: 432 return -EIO; 433 } 434 435 static int dib0090_fw_identify(struct dvb_frontend *fe) 436 { 437 struct dib0090_fw_state *state = fe->tuner_priv; 438 struct dib0090_identity *identity = &state->identity; 439 440 u16 v = dib0090_fw_read_reg(state, 0x1a); 441 identity->p1g = 0; 442 identity->in_soc = 0; 443 444 dprintk("FE: Tuner identification (Version = 0x%04x)", v); 445 446 /* without PLL lock info */ 447 v &= ~KROSUS_PLL_LOCKED; 448 449 identity->version = v & 0xff; 450 identity->product = (v >> 8) & 0xf; 451 452 if (identity->product != KROSUS) 453 goto identification_error; 454 455 if ((identity->version & 0x3) == SOC) { 456 identity->in_soc = 1; 457 switch (identity->version) { 458 case SOC_8090_P1G_11R1: 459 dprintk("SOC 8090 P1-G11R1 Has been detected"); 460 identity->p1g = 1; 461 break; 462 case SOC_8090_P1G_21R1: 463 dprintk("SOC 8090 P1-G21R1 Has been detected"); 464 identity->p1g = 1; 465 break; 466 case SOC_7090_P1G_11R1: 467 dprintk("SOC 7090 P1-G11R1 Has been detected"); 468 identity->p1g = 1; 469 break; 470 case SOC_7090_P1G_21R1: 471 dprintk("SOC 7090 P1-G21R1 Has been detected"); 472 identity->p1g = 1; 473 break; 474 default: 475 goto identification_error; 476 } 477 } else { 478 switch ((identity->version >> 5) & 0x7) { 479 case MP001: 480 dprintk("MP001 : 9090/8096"); 481 break; 482 case MP005: 483 dprintk("MP005 : Single Sband"); 484 break; 485 case MP008: 486 dprintk("MP008 : diversity VHF-UHF-LBAND"); 487 break; 488 case MP009: 489 dprintk("MP009 : diversity 29098 CBAND-UHF-LBAND-SBAND"); 490 break; 491 default: 492 goto identification_error; 493 } 494 495 switch (identity->version & 0x1f) { 496 case P1G_21R2: 497 dprintk("P1G_21R2 detected"); 498 identity->p1g = 1; 499 break; 500 case P1G: 501 dprintk("P1G detected"); 502 identity->p1g = 1; 503 break; 504 case P1D_E_F: 505 dprintk("P1D/E/F detected"); 506 break; 507 case P1C: 508 dprintk("P1C detected"); 509 break; 510 case P1A_B: 511 dprintk("P1-A/B detected: driver is deactivated - not available"); 512 goto identification_error; 513 break; 514 default: 515 goto identification_error; 516 } 517 } 518 519 return 0; 520 521 identification_error: 522 return -EIO; 523 } 524 525 static void dib0090_reset_digital(struct dvb_frontend *fe, const struct dib0090_config *cfg) 526 { 527 struct dib0090_state *state = fe->tuner_priv; 528 u16 PllCfg, i, v; 529 530 HARD_RESET(state); 531 dib0090_write_reg(state, 0x24, EN_PLL | EN_CRYSTAL); 532 if (cfg->in_soc) 533 return; 534 535 dib0090_write_reg(state, 0x1b, EN_DIGCLK | EN_PLL | EN_CRYSTAL); /* PLL, DIG_CLK and CRYSTAL remain */ 536 /* adcClkOutRatio=8->7, release reset */ 537 dib0090_write_reg(state, 0x20, ((cfg->io.adc_clock_ratio - 1) << 11) | (0 << 10) | (1 << 9) | (1 << 8) | (0 << 4) | 0); 538 if (cfg->clkoutdrive != 0) 539 dib0090_write_reg(state, 0x23, (0 << 15) | ((!cfg->analog_output) << 14) | (2 << 10) | (1 << 9) | (0 << 8) 540 | (cfg->clkoutdrive << 5) | (cfg->clkouttobamse << 4) | (0 << 2) | (0)); 541 else 542 dib0090_write_reg(state, 0x23, (0 << 15) | ((!cfg->analog_output) << 14) | (2 << 10) | (1 << 9) | (0 << 8) 543 | (7 << 5) | (cfg->clkouttobamse << 4) | (0 << 2) | (0)); 544 545 /* Read Pll current config * */ 546 PllCfg = dib0090_read_reg(state, 0x21); 547 548 /** Reconfigure PLL if current setting is different from default setting **/ 549 if ((PllCfg & 0x1FFF) != ((cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv)) && (!cfg->in_soc) 550 && !cfg->io.pll_bypass) { 551 552 /* Set Bypass mode */ 553 PllCfg |= (1 << 15); 554 dib0090_write_reg(state, 0x21, PllCfg); 555 556 /* Set Reset Pll */ 557 PllCfg &= ~(1 << 13); 558 dib0090_write_reg(state, 0x21, PllCfg); 559 560 /*** Set new Pll configuration in bypass and reset state ***/ 561 PllCfg = (1 << 15) | (0 << 13) | (cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv); 562 dib0090_write_reg(state, 0x21, PllCfg); 563 564 /* Remove Reset Pll */ 565 PllCfg |= (1 << 13); 566 dib0090_write_reg(state, 0x21, PllCfg); 567 568 /*** Wait for PLL lock ***/ 569 i = 100; 570 do { 571 v = !!(dib0090_read_reg(state, 0x1a) & 0x800); 572 if (v) 573 break; 574 } while (--i); 575 576 if (i == 0) { 577 dprintk("Pll: Unable to lock Pll"); 578 return; 579 } 580 581 /* Finally Remove Bypass mode */ 582 PllCfg &= ~(1 << 15); 583 dib0090_write_reg(state, 0x21, PllCfg); 584 } 585 586 if (cfg->io.pll_bypass) { 587 PllCfg |= (cfg->io.pll_bypass << 15); 588 dib0090_write_reg(state, 0x21, PllCfg); 589 } 590 } 591 592 static int dib0090_fw_reset_digital(struct dvb_frontend *fe, const struct dib0090_config *cfg) 593 { 594 struct dib0090_fw_state *state = fe->tuner_priv; 595 u16 PllCfg; 596 u16 v; 597 int i; 598 599 dprintk("fw reset digital"); 600 HARD_RESET(state); 601 602 dib0090_fw_write_reg(state, 0x24, EN_PLL | EN_CRYSTAL); 603 dib0090_fw_write_reg(state, 0x1b, EN_DIGCLK | EN_PLL | EN_CRYSTAL); /* PLL, DIG_CLK and CRYSTAL remain */ 604 605 dib0090_fw_write_reg(state, 0x20, 606 ((cfg->io.adc_clock_ratio - 1) << 11) | (0 << 10) | (1 << 9) | (1 << 8) | (cfg->data_tx_drv << 4) | cfg->ls_cfg_pad_drv); 607 608 v = (0 << 15) | ((!cfg->analog_output) << 14) | (1 << 9) | (0 << 8) | (cfg->clkouttobamse << 4) | (0 << 2) | (0); 609 if (cfg->clkoutdrive != 0) 610 v |= cfg->clkoutdrive << 5; 611 else 612 v |= 7 << 5; 613 614 v |= 2 << 10; 615 dib0090_fw_write_reg(state, 0x23, v); 616 617 /* Read Pll current config * */ 618 PllCfg = dib0090_fw_read_reg(state, 0x21); 619 620 /** Reconfigure PLL if current setting is different from default setting **/ 621 if ((PllCfg & 0x1FFF) != ((cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv)) && !cfg->io.pll_bypass) { 622 623 /* Set Bypass mode */ 624 PllCfg |= (1 << 15); 625 dib0090_fw_write_reg(state, 0x21, PllCfg); 626 627 /* Set Reset Pll */ 628 PllCfg &= ~(1 << 13); 629 dib0090_fw_write_reg(state, 0x21, PllCfg); 630 631 /*** Set new Pll configuration in bypass and reset state ***/ 632 PllCfg = (1 << 15) | (0 << 13) | (cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv); 633 dib0090_fw_write_reg(state, 0x21, PllCfg); 634 635 /* Remove Reset Pll */ 636 PllCfg |= (1 << 13); 637 dib0090_fw_write_reg(state, 0x21, PllCfg); 638 639 /*** Wait for PLL lock ***/ 640 i = 100; 641 do { 642 v = !!(dib0090_fw_read_reg(state, 0x1a) & 0x800); 643 if (v) 644 break; 645 } while (--i); 646 647 if (i == 0) { 648 dprintk("Pll: Unable to lock Pll"); 649 return -EIO; 650 } 651 652 /* Finally Remove Bypass mode */ 653 PllCfg &= ~(1 << 15); 654 dib0090_fw_write_reg(state, 0x21, PllCfg); 655 } 656 657 if (cfg->io.pll_bypass) { 658 PllCfg |= (cfg->io.pll_bypass << 15); 659 dib0090_fw_write_reg(state, 0x21, PllCfg); 660 } 661 662 return dib0090_fw_identify(fe); 663 } 664 665 static int dib0090_wakeup(struct dvb_frontend *fe) 666 { 667 struct dib0090_state *state = fe->tuner_priv; 668 if (state->config->sleep) 669 state->config->sleep(fe, 0); 670 671 /* enable dataTX in case we have been restarted in the wrong moment */ 672 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14)); 673 return 0; 674 } 675 676 static int dib0090_sleep(struct dvb_frontend *fe) 677 { 678 struct dib0090_state *state = fe->tuner_priv; 679 if (state->config->sleep) 680 state->config->sleep(fe, 1); 681 return 0; 682 } 683 684 void dib0090_dcc_freq(struct dvb_frontend *fe, u8 fast) 685 { 686 struct dib0090_state *state = fe->tuner_priv; 687 if (fast) 688 dib0090_write_reg(state, 0x04, 0); 689 else 690 dib0090_write_reg(state, 0x04, 1); 691 } 692 693 EXPORT_SYMBOL(dib0090_dcc_freq); 694 695 static const u16 bb_ramp_pwm_normal_socs[] = { 696 550, /* max BB gain in 10th of dB */ 697 (1<<9) | 8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */ 698 440, 699 (4 << 9) | 0, /* BB_RAMP3 = 26dB */ 700 (0 << 9) | 208, /* BB_RAMP4 */ 701 (4 << 9) | 208, /* BB_RAMP5 = 29dB */ 702 (0 << 9) | 440, /* BB_RAMP6 */ 703 }; 704 705 static const u16 rf_ramp_pwm_cband_7090p[] = { 706 280, /* max RF gain in 10th of dB */ 707 18, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 708 504, /* ramp_max = maximum X used on the ramp */ 709 (29 << 10) | 364, /* RF_RAMP5, LNA 1 = 8dB */ 710 (0 << 10) | 504, /* RF_RAMP6, LNA 1 */ 711 (60 << 10) | 228, /* RF_RAMP7, LNA 2 = 7.7dB */ 712 (0 << 10) | 364, /* RF_RAMP8, LNA 2 */ 713 (34 << 10) | 109, /* GAIN_4_1, LNA 3 = 6.8dB */ 714 (0 << 10) | 228, /* GAIN_4_2, LNA 3 */ 715 (37 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ 716 (0 << 10) | 109, /* RF_RAMP4, LNA 4 */ 717 }; 718 719 static const u16 rf_ramp_pwm_cband_7090e_sensitivity[] = { 720 186, /* max RF gain in 10th of dB */ 721 40, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 722 746, /* ramp_max = maximum X used on the ramp */ 723 (10 << 10) | 345, /* RF_RAMP5, LNA 1 = 10dB */ 724 (0 << 10) | 746, /* RF_RAMP6, LNA 1 */ 725 (0 << 10) | 0, /* RF_RAMP7, LNA 2 = 0 dB */ 726 (0 << 10) | 0, /* RF_RAMP8, LNA 2 */ 727 (28 << 10) | 200, /* GAIN_4_1, LNA 3 = 6.8dB */ /* 3.61 dB */ 728 (0 << 10) | 345, /* GAIN_4_2, LNA 3 */ 729 (20 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ /* 4.96 dB */ 730 (0 << 10) | 200, /* RF_RAMP4, LNA 4 */ 731 }; 732 733 static const u16 rf_ramp_pwm_cband_7090e_aci[] = { 734 86, /* max RF gain in 10th of dB */ 735 40, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 736 345, /* ramp_max = maximum X used on the ramp */ 737 (0 << 10) | 0, /* RF_RAMP5, LNA 1 = 8dB */ /* 7.47 dB */ 738 (0 << 10) | 0, /* RF_RAMP6, LNA 1 */ 739 (0 << 10) | 0, /* RF_RAMP7, LNA 2 = 0 dB */ 740 (0 << 10) | 0, /* RF_RAMP8, LNA 2 */ 741 (28 << 10) | 200, /* GAIN_4_1, LNA 3 = 6.8dB */ /* 3.61 dB */ 742 (0 << 10) | 345, /* GAIN_4_2, LNA 3 */ 743 (20 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ /* 4.96 dB */ 744 (0 << 10) | 200, /* RF_RAMP4, LNA 4 */ 745 }; 746 747 static const u16 rf_ramp_pwm_cband_8090[] = { 748 345, /* max RF gain in 10th of dB */ 749 29, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 750 1000, /* ramp_max = maximum X used on the ramp */ 751 (35 << 10) | 772, /* RF_RAMP3, LNA 1 = 8dB */ 752 (0 << 10) | 1000, /* RF_RAMP4, LNA 1 */ 753 (58 << 10) | 496, /* RF_RAMP5, LNA 2 = 9.5dB */ 754 (0 << 10) | 772, /* RF_RAMP6, LNA 2 */ 755 (27 << 10) | 200, /* RF_RAMP7, LNA 3 = 10.5dB */ 756 (0 << 10) | 496, /* RF_RAMP8, LNA 3 */ 757 (40 << 10) | 0, /* GAIN_4_1, LNA 4 = 7dB */ 758 (0 << 10) | 200, /* GAIN_4_2, LNA 4 */ 759 }; 760 761 static const u16 rf_ramp_pwm_uhf_7090[] = { 762 407, /* max RF gain in 10th of dB */ 763 13, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 764 529, /* ramp_max = maximum X used on the ramp */ 765 (23 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.7dB */ 766 (0 << 10) | 176, /* RF_RAMP4, LNA 1 */ 767 (63 << 10) | 400, /* RF_RAMP5, LNA 2 = 8dB */ 768 (0 << 10) | 529, /* RF_RAMP6, LNA 2 */ 769 (48 << 10) | 316, /* RF_RAMP7, LNA 3 = 6.8dB */ 770 (0 << 10) | 400, /* RF_RAMP8, LNA 3 */ 771 (29 << 10) | 176, /* GAIN_4_1, LNA 4 = 11.5dB */ 772 (0 << 10) | 316, /* GAIN_4_2, LNA 4 */ 773 }; 774 775 static const u16 rf_ramp_pwm_uhf_8090[] = { 776 388, /* max RF gain in 10th of dB */ 777 26, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 778 1008, /* ramp_max = maximum X used on the ramp */ 779 (11 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.7dB */ 780 (0 << 10) | 369, /* RF_RAMP4, LNA 1 */ 781 (41 << 10) | 809, /* RF_RAMP5, LNA 2 = 8dB */ 782 (0 << 10) | 1008, /* RF_RAMP6, LNA 2 */ 783 (27 << 10) | 659, /* RF_RAMP7, LNA 3 = 6dB */ 784 (0 << 10) | 809, /* RF_RAMP8, LNA 3 */ 785 (14 << 10) | 369, /* GAIN_4_1, LNA 4 = 11.5dB */ 786 (0 << 10) | 659, /* GAIN_4_2, LNA 4 */ 787 }; 788 789 /* GENERAL PWM ramp definition for all other Krosus */ 790 static const u16 bb_ramp_pwm_normal[] = { 791 500, /* max BB gain in 10th of dB */ 792 8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */ 793 400, 794 (2 << 9) | 0, /* BB_RAMP3 = 21dB */ 795 (0 << 9) | 168, /* BB_RAMP4 */ 796 (2 << 9) | 168, /* BB_RAMP5 = 29dB */ 797 (0 << 9) | 400, /* BB_RAMP6 */ 798 }; 799 800 static const u16 bb_ramp_pwm_boost[] = { 801 550, /* max BB gain in 10th of dB */ 802 8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */ 803 440, 804 (2 << 9) | 0, /* BB_RAMP3 = 26dB */ 805 (0 << 9) | 208, /* BB_RAMP4 */ 806 (2 << 9) | 208, /* BB_RAMP5 = 29dB */ 807 (0 << 9) | 440, /* BB_RAMP6 */ 808 }; 809 810 static const u16 rf_ramp_pwm_cband[] = { 811 314, /* max RF gain in 10th of dB */ 812 33, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 813 1023, /* ramp_max = maximum X used on the ramp */ 814 (8 << 10) | 743, /* RF_RAMP3, LNA 1 = 0dB */ 815 (0 << 10) | 1023, /* RF_RAMP4, LNA 1 */ 816 (15 << 10) | 469, /* RF_RAMP5, LNA 2 = 0dB */ 817 (0 << 10) | 742, /* RF_RAMP6, LNA 2 */ 818 (9 << 10) | 234, /* RF_RAMP7, LNA 3 = 0dB */ 819 (0 << 10) | 468, /* RF_RAMP8, LNA 3 */ 820 (9 << 10) | 0, /* GAIN_4_1, LNA 4 = 0dB */ 821 (0 << 10) | 233, /* GAIN_4_2, LNA 4 */ 822 }; 823 824 static const u16 rf_ramp_pwm_vhf[] = { 825 398, /* max RF gain in 10th of dB */ 826 24, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 827 954, /* ramp_max = maximum X used on the ramp */ 828 (7 << 10) | 0, /* RF_RAMP3, LNA 1 = 13.2dB */ 829 (0 << 10) | 290, /* RF_RAMP4, LNA 1 */ 830 (16 << 10) | 699, /* RF_RAMP5, LNA 2 = 10.5dB */ 831 (0 << 10) | 954, /* RF_RAMP6, LNA 2 */ 832 (17 << 10) | 580, /* RF_RAMP7, LNA 3 = 5dB */ 833 (0 << 10) | 699, /* RF_RAMP8, LNA 3 */ 834 (7 << 10) | 290, /* GAIN_4_1, LNA 4 = 12.5dB */ 835 (0 << 10) | 580, /* GAIN_4_2, LNA 4 */ 836 }; 837 838 static const u16 rf_ramp_pwm_uhf[] = { 839 398, /* max RF gain in 10th of dB */ 840 24, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 841 954, /* ramp_max = maximum X used on the ramp */ 842 (7 << 10) | 0, /* RF_RAMP3, LNA 1 = 13.2dB */ 843 (0 << 10) | 290, /* RF_RAMP4, LNA 1 */ 844 (16 << 10) | 699, /* RF_RAMP5, LNA 2 = 10.5dB */ 845 (0 << 10) | 954, /* RF_RAMP6, LNA 2 */ 846 (17 << 10) | 580, /* RF_RAMP7, LNA 3 = 5dB */ 847 (0 << 10) | 699, /* RF_RAMP8, LNA 3 */ 848 (7 << 10) | 290, /* GAIN_4_1, LNA 4 = 12.5dB */ 849 (0 << 10) | 580, /* GAIN_4_2, LNA 4 */ 850 }; 851 852 static const u16 rf_ramp_pwm_sband[] = { 853 253, /* max RF gain in 10th of dB */ 854 38, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */ 855 961, 856 (4 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.1dB */ 857 (0 << 10) | 508, /* RF_RAMP4, LNA 1 */ 858 (9 << 10) | 508, /* RF_RAMP5, LNA 2 = 11.2dB */ 859 (0 << 10) | 961, /* RF_RAMP6, LNA 2 */ 860 (0 << 10) | 0, /* RF_RAMP7, LNA 3 = 0dB */ 861 (0 << 10) | 0, /* RF_RAMP8, LNA 3 */ 862 (0 << 10) | 0, /* GAIN_4_1, LNA 4 = 0dB */ 863 (0 << 10) | 0, /* GAIN_4_2, LNA 4 */ 864 }; 865 866 struct slope { 867 s16 range; 868 s16 slope; 869 }; 870 static u16 slopes_to_scale(const struct slope *slopes, u8 num, s16 val) 871 { 872 u8 i; 873 u16 rest; 874 u16 ret = 0; 875 for (i = 0; i < num; i++) { 876 if (val > slopes[i].range) 877 rest = slopes[i].range; 878 else 879 rest = val; 880 ret += (rest * slopes[i].slope) / slopes[i].range; 881 val -= rest; 882 } 883 return ret; 884 } 885 886 static const struct slope dib0090_wbd_slopes[3] = { 887 {66, 120}, /* -64,-52: offset - 65 */ 888 {600, 170}, /* -52,-35: 65 - 665 */ 889 {170, 250}, /* -45,-10: 665 - 835 */ 890 }; 891 892 static s16 dib0090_wbd_to_db(struct dib0090_state *state, u16 wbd) 893 { 894 wbd &= 0x3ff; 895 if (wbd < state->wbd_offset) 896 wbd = 0; 897 else 898 wbd -= state->wbd_offset; 899 /* -64dB is the floor */ 900 return -640 + (s16) slopes_to_scale(dib0090_wbd_slopes, ARRAY_SIZE(dib0090_wbd_slopes), wbd); 901 } 902 903 static void dib0090_wbd_target(struct dib0090_state *state, u32 rf) 904 { 905 u16 offset = 250; 906 907 /* TODO : DAB digital N+/-1 interferer perfs : offset = 10 */ 908 909 if (state->current_band == BAND_VHF) 910 offset = 650; 911 #ifndef FIRMWARE_FIREFLY 912 if (state->current_band == BAND_VHF) 913 offset = state->config->wbd_vhf_offset; 914 if (state->current_band == BAND_CBAND) 915 offset = state->config->wbd_cband_offset; 916 #endif 917 918 state->wbd_target = dib0090_wbd_to_db(state, state->wbd_offset + offset); 919 dprintk("wbd-target: %d dB", (u32) state->wbd_target); 920 } 921 922 static const int gain_reg_addr[4] = { 923 0x08, 0x0a, 0x0f, 0x01 924 }; 925 926 static void dib0090_gain_apply(struct dib0090_state *state, s16 gain_delta, s16 top_delta, u8 force) 927 { 928 u16 rf, bb, ref; 929 u16 i, v, gain_reg[4] = { 0 }, gain; 930 const u16 *g; 931 932 if (top_delta < -511) 933 top_delta = -511; 934 if (top_delta > 511) 935 top_delta = 511; 936 937 if (force) { 938 top_delta *= (1 << WBD_ALPHA); 939 gain_delta *= (1 << GAIN_ALPHA); 940 } 941 942 if (top_delta >= ((s16) (state->rf_ramp[0] << WBD_ALPHA) - state->rf_gain_limit)) /* overflow */ 943 state->rf_gain_limit = state->rf_ramp[0] << WBD_ALPHA; 944 else 945 state->rf_gain_limit += top_delta; 946 947 if (state->rf_gain_limit < 0) /*underflow */ 948 state->rf_gain_limit = 0; 949 950 /* use gain as a temporary variable and correct current_gain */ 951 gain = ((state->rf_gain_limit >> WBD_ALPHA) + state->bb_ramp[0]) << GAIN_ALPHA; 952 if (gain_delta >= ((s16) gain - state->current_gain)) /* overflow */ 953 state->current_gain = gain; 954 else 955 state->current_gain += gain_delta; 956 /* cannot be less than 0 (only if gain_delta is less than 0 we can have current_gain < 0) */ 957 if (state->current_gain < 0) 958 state->current_gain = 0; 959 960 /* now split total gain to rf and bb gain */ 961 gain = state->current_gain >> GAIN_ALPHA; 962 963 /* requested gain is bigger than rf gain limit - ACI/WBD adjustment */ 964 if (gain > (state->rf_gain_limit >> WBD_ALPHA)) { 965 rf = state->rf_gain_limit >> WBD_ALPHA; 966 bb = gain - rf; 967 if (bb > state->bb_ramp[0]) 968 bb = state->bb_ramp[0]; 969 } else { /* high signal level -> all gains put on RF */ 970 rf = gain; 971 bb = 0; 972 } 973 974 state->gain[0] = rf; 975 state->gain[1] = bb; 976 977 /* software ramp */ 978 /* Start with RF gains */ 979 g = state->rf_ramp + 1; /* point on RF LNA1 max gain */ 980 ref = rf; 981 for (i = 0; i < 7; i++) { /* Go over all amplifiers => 5RF amps + 2 BB amps = 7 amps */ 982 if (g[0] == 0 || ref < (g[1] - g[0])) /* if total gain of the current amp is null or this amp is not concerned because it starts to work from an higher gain value */ 983 v = 0; /* force the gain to write for the current amp to be null */ 984 else if (ref >= g[1]) /* Gain to set is higher than the high working point of this amp */ 985 v = g[2]; /* force this amp to be full gain */ 986 else /* compute the value to set to this amp because we are somewhere in his range */ 987 v = ((ref - (g[1] - g[0])) * g[2]) / g[0]; 988 989 if (i == 0) /* LNA 1 reg mapping */ 990 gain_reg[0] = v; 991 else if (i == 1) /* LNA 2 reg mapping */ 992 gain_reg[0] |= v << 7; 993 else if (i == 2) /* LNA 3 reg mapping */ 994 gain_reg[1] = v; 995 else if (i == 3) /* LNA 4 reg mapping */ 996 gain_reg[1] |= v << 7; 997 else if (i == 4) /* CBAND LNA reg mapping */ 998 gain_reg[2] = v | state->rf_lt_def; 999 else if (i == 5) /* BB gain 1 reg mapping */ 1000 gain_reg[3] = v << 3; 1001 else if (i == 6) /* BB gain 2 reg mapping */ 1002 gain_reg[3] |= v << 8; 1003 1004 g += 3; /* go to next gain bloc */ 1005 1006 /* When RF is finished, start with BB */ 1007 if (i == 4) { 1008 g = state->bb_ramp + 1; /* point on BB gain 1 max gain */ 1009 ref = bb; 1010 } 1011 } 1012 gain_reg[3] |= state->bb_1_def; 1013 gain_reg[3] |= ((bb % 10) * 100) / 125; 1014 1015 #ifdef DEBUG_AGC 1016 dprintk("GA CALC: DB: %3d(rf) + %3d(bb) = %3d gain_reg[0]=%04x gain_reg[1]=%04x gain_reg[2]=%04x gain_reg[0]=%04x", rf, bb, rf + bb, 1017 gain_reg[0], gain_reg[1], gain_reg[2], gain_reg[3]); 1018 #endif 1019 1020 /* Write the amplifier regs */ 1021 for (i = 0; i < 4; i++) { 1022 v = gain_reg[i]; 1023 if (force || state->gain_reg[i] != v) { 1024 state->gain_reg[i] = v; 1025 dib0090_write_reg(state, gain_reg_addr[i], v); 1026 } 1027 } 1028 } 1029 1030 static void dib0090_set_boost(struct dib0090_state *state, int onoff) 1031 { 1032 state->bb_1_def &= 0xdfff; 1033 state->bb_1_def |= onoff << 13; 1034 } 1035 1036 static void dib0090_set_rframp(struct dib0090_state *state, const u16 * cfg) 1037 { 1038 state->rf_ramp = cfg; 1039 } 1040 1041 static void dib0090_set_rframp_pwm(struct dib0090_state *state, const u16 * cfg) 1042 { 1043 state->rf_ramp = cfg; 1044 1045 dib0090_write_reg(state, 0x2a, 0xffff); 1046 1047 dprintk("total RF gain: %ddB, step: %d", (u32) cfg[0], dib0090_read_reg(state, 0x2a)); 1048 1049 dib0090_write_regs(state, 0x2c, cfg + 3, 6); 1050 dib0090_write_regs(state, 0x3e, cfg + 9, 2); 1051 } 1052 1053 static void dib0090_set_bbramp(struct dib0090_state *state, const u16 * cfg) 1054 { 1055 state->bb_ramp = cfg; 1056 dib0090_set_boost(state, cfg[0] > 500); /* we want the boost if the gain is higher that 50dB */ 1057 } 1058 1059 static void dib0090_set_bbramp_pwm(struct dib0090_state *state, const u16 * cfg) 1060 { 1061 state->bb_ramp = cfg; 1062 1063 dib0090_set_boost(state, cfg[0] > 500); /* we want the boost if the gain is higher that 50dB */ 1064 1065 dib0090_write_reg(state, 0x33, 0xffff); 1066 dprintk("total BB gain: %ddB, step: %d", (u32) cfg[0], dib0090_read_reg(state, 0x33)); 1067 dib0090_write_regs(state, 0x35, cfg + 3, 4); 1068 } 1069 1070 void dib0090_pwm_gain_reset(struct dvb_frontend *fe) 1071 { 1072 struct dib0090_state *state = fe->tuner_priv; 1073 u16 *bb_ramp = (u16 *)&bb_ramp_pwm_normal; /* default baseband config */ 1074 u16 *rf_ramp = NULL; 1075 u8 en_pwm_rf_mux = 1; 1076 1077 /* reset the AGC */ 1078 if (state->config->use_pwm_agc) { 1079 if (state->current_band == BAND_CBAND) { 1080 if (state->identity.in_soc) { 1081 bb_ramp = (u16 *)&bb_ramp_pwm_normal_socs; 1082 if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1) 1083 rf_ramp = (u16 *)&rf_ramp_pwm_cband_8090; 1084 else if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1) { 1085 if (state->config->is_dib7090e) { 1086 if (state->rf_ramp == NULL) 1087 rf_ramp = (u16 *)&rf_ramp_pwm_cband_7090e_sensitivity; 1088 else 1089 rf_ramp = (u16 *)state->rf_ramp; 1090 } else 1091 rf_ramp = (u16 *)&rf_ramp_pwm_cband_7090p; 1092 } 1093 } else 1094 rf_ramp = (u16 *)&rf_ramp_pwm_cband; 1095 } else 1096 1097 if (state->current_band == BAND_VHF) { 1098 if (state->identity.in_soc) { 1099 bb_ramp = (u16 *)&bb_ramp_pwm_normal_socs; 1100 /* rf_ramp = &rf_ramp_pwm_vhf_socs; */ /* TODO */ 1101 } else 1102 rf_ramp = (u16 *)&rf_ramp_pwm_vhf; 1103 } else if (state->current_band == BAND_UHF) { 1104 if (state->identity.in_soc) { 1105 bb_ramp = (u16 *)&bb_ramp_pwm_normal_socs; 1106 if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1) 1107 rf_ramp = (u16 *)&rf_ramp_pwm_uhf_8090; 1108 else if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1) 1109 rf_ramp = (u16 *)&rf_ramp_pwm_uhf_7090; 1110 } else 1111 rf_ramp = (u16 *)&rf_ramp_pwm_uhf; 1112 } 1113 if (rf_ramp) 1114 dib0090_set_rframp_pwm(state, rf_ramp); 1115 dib0090_set_bbramp_pwm(state, bb_ramp); 1116 1117 /* activate the ramp generator using PWM control */ 1118 dprintk("ramp RF gain = %d BAND = %s version = %d", state->rf_ramp[0], (state->current_band == BAND_CBAND) ? "CBAND" : "NOT CBAND", state->identity.version & 0x1f); 1119 1120 if ((state->rf_ramp[0] == 0) || (state->current_band == BAND_CBAND && (state->identity.version & 0x1f) <= P1D_E_F)) { 1121 dprintk("DE-Engage mux for direct gain reg control"); 1122 en_pwm_rf_mux = 0; 1123 } else 1124 dprintk("Engage mux for PWM control"); 1125 1126 dib0090_write_reg(state, 0x32, (en_pwm_rf_mux << 12) | (en_pwm_rf_mux << 11)); 1127 1128 /* Set fast servo cutoff to start AGC; 0 = 1KHz ; 1 = 50Hz ; 2 = 150Hz ; 3 = 50KHz ; 4 = servo fast*/ 1129 if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1) 1130 dib0090_write_reg(state, 0x04, 3); 1131 else 1132 dib0090_write_reg(state, 0x04, 1); 1133 dib0090_write_reg(state, 0x39, (1 << 10)); /* 0 gain by default */ 1134 } 1135 } 1136 EXPORT_SYMBOL(dib0090_pwm_gain_reset); 1137 1138 void dib0090_set_dc_servo(struct dvb_frontend *fe, u8 DC_servo_cutoff) 1139 { 1140 struct dib0090_state *state = fe->tuner_priv; 1141 if (DC_servo_cutoff < 4) 1142 dib0090_write_reg(state, 0x04, DC_servo_cutoff); 1143 } 1144 EXPORT_SYMBOL(dib0090_set_dc_servo); 1145 1146 static u32 dib0090_get_slow_adc_val(struct dib0090_state *state) 1147 { 1148 u16 adc_val = dib0090_read_reg(state, 0x1d); 1149 if (state->identity.in_soc) 1150 adc_val >>= 2; 1151 return adc_val; 1152 } 1153 1154 int dib0090_gain_control(struct dvb_frontend *fe) 1155 { 1156 struct dib0090_state *state = fe->tuner_priv; 1157 enum frontend_tune_state *tune_state = &state->tune_state; 1158 int ret = 10; 1159 1160 u16 wbd_val = 0; 1161 u8 apply_gain_immediatly = 1; 1162 s16 wbd_error = 0, adc_error = 0; 1163 1164 if (*tune_state == CT_AGC_START) { 1165 state->agc_freeze = 0; 1166 dib0090_write_reg(state, 0x04, 0x0); 1167 1168 #ifdef CONFIG_BAND_SBAND 1169 if (state->current_band == BAND_SBAND) { 1170 dib0090_set_rframp(state, rf_ramp_sband); 1171 dib0090_set_bbramp(state, bb_ramp_boost); 1172 } else 1173 #endif 1174 #ifdef CONFIG_BAND_VHF 1175 if (state->current_band == BAND_VHF && !state->identity.p1g) { 1176 dib0090_set_rframp(state, rf_ramp_pwm_vhf); 1177 dib0090_set_bbramp(state, bb_ramp_pwm_normal); 1178 } else 1179 #endif 1180 #ifdef CONFIG_BAND_CBAND 1181 if (state->current_band == BAND_CBAND && !state->identity.p1g) { 1182 dib0090_set_rframp(state, rf_ramp_pwm_cband); 1183 dib0090_set_bbramp(state, bb_ramp_pwm_normal); 1184 } else 1185 #endif 1186 if ((state->current_band == BAND_CBAND || state->current_band == BAND_VHF) && state->identity.p1g) { 1187 dib0090_set_rframp(state, rf_ramp_pwm_cband_7090p); 1188 dib0090_set_bbramp(state, bb_ramp_pwm_normal_socs); 1189 } else { 1190 dib0090_set_rframp(state, rf_ramp_pwm_uhf); 1191 dib0090_set_bbramp(state, bb_ramp_pwm_normal); 1192 } 1193 1194 dib0090_write_reg(state, 0x32, 0); 1195 dib0090_write_reg(state, 0x39, 0); 1196 1197 dib0090_wbd_target(state, state->current_rf); 1198 1199 state->rf_gain_limit = state->rf_ramp[0] << WBD_ALPHA; 1200 state->current_gain = ((state->rf_ramp[0] + state->bb_ramp[0]) / 2) << GAIN_ALPHA; 1201 1202 *tune_state = CT_AGC_STEP_0; 1203 } else if (!state->agc_freeze) { 1204 s16 wbd = 0, i, cnt; 1205 1206 int adc; 1207 wbd_val = dib0090_get_slow_adc_val(state); 1208 1209 if (*tune_state == CT_AGC_STEP_0) 1210 cnt = 5; 1211 else 1212 cnt = 1; 1213 1214 for (i = 0; i < cnt; i++) { 1215 wbd_val = dib0090_get_slow_adc_val(state); 1216 wbd += dib0090_wbd_to_db(state, wbd_val); 1217 } 1218 wbd /= cnt; 1219 wbd_error = state->wbd_target - wbd; 1220 1221 if (*tune_state == CT_AGC_STEP_0) { 1222 if (wbd_error < 0 && state->rf_gain_limit > 0 && !state->identity.p1g) { 1223 #ifdef CONFIG_BAND_CBAND 1224 /* in case of CBAND tune reduce first the lt_gain2 before adjusting the RF gain */ 1225 u8 ltg2 = (state->rf_lt_def >> 10) & 0x7; 1226 if (state->current_band == BAND_CBAND && ltg2) { 1227 ltg2 >>= 1; 1228 state->rf_lt_def &= ltg2 << 10; /* reduce in 3 steps from 7 to 0 */ 1229 } 1230 #endif 1231 } else { 1232 state->agc_step = 0; 1233 *tune_state = CT_AGC_STEP_1; 1234 } 1235 } else { 1236 /* calc the adc power */ 1237 adc = state->config->get_adc_power(fe); 1238 adc = (adc * ((s32) 355774) + (((s32) 1) << 20)) >> 21; /* included in [0:-700] */ 1239 1240 adc_error = (s16) (((s32) ADC_TARGET) - adc); 1241 #ifdef CONFIG_STANDARD_DAB 1242 if (state->fe->dtv_property_cache.delivery_system == STANDARD_DAB) 1243 adc_error -= 10; 1244 #endif 1245 #ifdef CONFIG_STANDARD_DVBT 1246 if (state->fe->dtv_property_cache.delivery_system == STANDARD_DVBT && 1247 (state->fe->dtv_property_cache.modulation == QAM_64 || state->fe->dtv_property_cache.modulation == QAM_16)) 1248 adc_error += 60; 1249 #endif 1250 #ifdef CONFIG_SYS_ISDBT 1251 if ((state->fe->dtv_property_cache.delivery_system == SYS_ISDBT) && (((state->fe->dtv_property_cache.layer[0].segment_count > 1252 0) 1253 && 1254 ((state->fe->dtv_property_cache.layer[0].modulation == 1255 QAM_64) 1256 || (state->fe->dtv_property_cache. 1257 layer[0].modulation == QAM_16))) 1258 || 1259 ((state->fe->dtv_property_cache.layer[1].segment_count > 1260 0) 1261 && 1262 ((state->fe->dtv_property_cache.layer[1].modulation == 1263 QAM_64) 1264 || (state->fe->dtv_property_cache. 1265 layer[1].modulation == QAM_16))) 1266 || 1267 ((state->fe->dtv_property_cache.layer[2].segment_count > 1268 0) 1269 && 1270 ((state->fe->dtv_property_cache.layer[2].modulation == 1271 QAM_64) 1272 || (state->fe->dtv_property_cache. 1273 layer[2].modulation == QAM_16))) 1274 ) 1275 ) 1276 adc_error += 60; 1277 #endif 1278 1279 if (*tune_state == CT_AGC_STEP_1) { /* quickly go to the correct range of the ADC power */ 1280 if (ABS(adc_error) < 50 || state->agc_step++ > 5) { 1281 1282 #ifdef CONFIG_STANDARD_DAB 1283 if (state->fe->dtv_property_cache.delivery_system == STANDARD_DAB) { 1284 dib0090_write_reg(state, 0x02, (1 << 15) | (15 << 11) | (31 << 6) | (63)); /* cap value = 63 : narrow BB filter : Fc = 1.8MHz */ 1285 dib0090_write_reg(state, 0x04, 0x0); 1286 } else 1287 #endif 1288 { 1289 dib0090_write_reg(state, 0x02, (1 << 15) | (3 << 11) | (6 << 6) | (32)); 1290 dib0090_write_reg(state, 0x04, 0x01); /*0 = 1KHz ; 1 = 150Hz ; 2 = 50Hz ; 3 = 50KHz ; 4 = servo fast */ 1291 } 1292 1293 *tune_state = CT_AGC_STOP; 1294 } 1295 } else { 1296 /* everything higher than or equal to CT_AGC_STOP means tracking */ 1297 ret = 100; /* 10ms interval */ 1298 apply_gain_immediatly = 0; 1299 } 1300 } 1301 #ifdef DEBUG_AGC 1302 dprintk 1303 ("tune state %d, ADC = %3ddB (ADC err %3d) WBD %3ddB (WBD err %3d, WBD val SADC: %4d), RFGainLimit (TOP): %3d, signal: %3ddBm", 1304 (u32) *tune_state, (u32) adc, (u32) adc_error, (u32) wbd, (u32) wbd_error, (u32) wbd_val, 1305 (u32) state->rf_gain_limit >> WBD_ALPHA, (s32) 200 + adc - (state->current_gain >> GAIN_ALPHA)); 1306 #endif 1307 } 1308 1309 /* apply gain */ 1310 if (!state->agc_freeze) 1311 dib0090_gain_apply(state, adc_error, wbd_error, apply_gain_immediatly); 1312 return ret; 1313 } 1314 1315 EXPORT_SYMBOL(dib0090_gain_control); 1316 1317 void dib0090_get_current_gain(struct dvb_frontend *fe, u16 * rf, u16 * bb, u16 * rf_gain_limit, u16 * rflt) 1318 { 1319 struct dib0090_state *state = fe->tuner_priv; 1320 if (rf) 1321 *rf = state->gain[0]; 1322 if (bb) 1323 *bb = state->gain[1]; 1324 if (rf_gain_limit) 1325 *rf_gain_limit = state->rf_gain_limit; 1326 if (rflt) 1327 *rflt = (state->rf_lt_def >> 10) & 0x7; 1328 } 1329 1330 EXPORT_SYMBOL(dib0090_get_current_gain); 1331 1332 u16 dib0090_get_wbd_target(struct dvb_frontend *fe) 1333 { 1334 struct dib0090_state *state = fe->tuner_priv; 1335 u32 f_MHz = state->fe->dtv_property_cache.frequency / 1000000; 1336 s32 current_temp = state->temperature; 1337 s32 wbd_thot, wbd_tcold; 1338 const struct dib0090_wbd_slope *wbd = state->current_wbd_table; 1339 1340 while (f_MHz > wbd->max_freq) 1341 wbd++; 1342 1343 dprintk("using wbd-table-entry with max freq %d", wbd->max_freq); 1344 1345 if (current_temp < 0) 1346 current_temp = 0; 1347 if (current_temp > 128) 1348 current_temp = 128; 1349 1350 state->wbdmux &= ~(7 << 13); 1351 if (wbd->wbd_gain != 0) 1352 state->wbdmux |= (wbd->wbd_gain << 13); 1353 else 1354 state->wbdmux |= (4 << 13); 1355 1356 dib0090_write_reg(state, 0x10, state->wbdmux); 1357 1358 wbd_thot = wbd->offset_hot - (((u32) wbd->slope_hot * f_MHz) >> 6); 1359 wbd_tcold = wbd->offset_cold - (((u32) wbd->slope_cold * f_MHz) >> 6); 1360 1361 wbd_tcold += ((wbd_thot - wbd_tcold) * current_temp) >> 7; 1362 1363 state->wbd_target = dib0090_wbd_to_db(state, state->wbd_offset + wbd_tcold); 1364 dprintk("wbd-target: %d dB", (u32) state->wbd_target); 1365 dprintk("wbd offset applied is %d", wbd_tcold); 1366 1367 return state->wbd_offset + wbd_tcold; 1368 } 1369 EXPORT_SYMBOL(dib0090_get_wbd_target); 1370 1371 u16 dib0090_get_wbd_offset(struct dvb_frontend *fe) 1372 { 1373 struct dib0090_state *state = fe->tuner_priv; 1374 return state->wbd_offset; 1375 } 1376 EXPORT_SYMBOL(dib0090_get_wbd_offset); 1377 1378 int dib0090_set_switch(struct dvb_frontend *fe, u8 sw1, u8 sw2, u8 sw3) 1379 { 1380 struct dib0090_state *state = fe->tuner_priv; 1381 1382 dib0090_write_reg(state, 0x0b, (dib0090_read_reg(state, 0x0b) & 0xfff8) 1383 | ((sw3 & 1) << 2) | ((sw2 & 1) << 1) | (sw1 & 1)); 1384 1385 return 0; 1386 } 1387 EXPORT_SYMBOL(dib0090_set_switch); 1388 1389 int dib0090_set_vga(struct dvb_frontend *fe, u8 onoff) 1390 { 1391 struct dib0090_state *state = fe->tuner_priv; 1392 1393 dib0090_write_reg(state, 0x09, (dib0090_read_reg(state, 0x09) & 0x7fff) 1394 | ((onoff & 1) << 15)); 1395 return 0; 1396 } 1397 EXPORT_SYMBOL(dib0090_set_vga); 1398 1399 int dib0090_update_rframp_7090(struct dvb_frontend *fe, u8 cfg_sensitivity) 1400 { 1401 struct dib0090_state *state = fe->tuner_priv; 1402 1403 if ((!state->identity.p1g) || (!state->identity.in_soc) 1404 || ((state->identity.version != SOC_7090_P1G_21R1) 1405 && (state->identity.version != SOC_7090_P1G_11R1))) { 1406 dprintk("%s() function can only be used for dib7090P", __func__); 1407 return -ENODEV; 1408 } 1409 1410 if (cfg_sensitivity) 1411 state->rf_ramp = (const u16 *)&rf_ramp_pwm_cband_7090e_sensitivity; 1412 else 1413 state->rf_ramp = (const u16 *)&rf_ramp_pwm_cband_7090e_aci; 1414 dib0090_pwm_gain_reset(fe); 1415 1416 return 0; 1417 } 1418 EXPORT_SYMBOL(dib0090_update_rframp_7090); 1419 1420 static const u16 dib0090_defaults[] = { 1421 1422 25, 0x01, 1423 0x0000, 1424 0x99a0, 1425 0x6008, 1426 0x0000, 1427 0x8bcb, 1428 0x0000, 1429 0x0405, 1430 0x0000, 1431 0x0000, 1432 0x0000, 1433 0xb802, 1434 0x0300, 1435 0x2d12, 1436 0xbac0, 1437 0x7c00, 1438 0xdbb9, 1439 0x0954, 1440 0x0743, 1441 0x8000, 1442 0x0001, 1443 0x0040, 1444 0x0100, 1445 0x0000, 1446 0xe910, 1447 0x149e, 1448 1449 1, 0x1c, 1450 0xff2d, 1451 1452 1, 0x39, 1453 0x0000, 1454 1455 2, 0x1e, 1456 0x07FF, 1457 0x0007, 1458 1459 1, 0x24, 1460 EN_UHF | EN_CRYSTAL, 1461 1462 2, 0x3c, 1463 0x3ff, 1464 0x111, 1465 0 1466 }; 1467 1468 static const u16 dib0090_p1g_additionnal_defaults[] = { 1469 1, 0x05, 1470 0xabcd, 1471 1472 1, 0x11, 1473 0x00b4, 1474 1475 1, 0x1c, 1476 0xfffd, 1477 1478 1, 0x40, 1479 0x108, 1480 0 1481 }; 1482 1483 static void dib0090_set_default_config(struct dib0090_state *state, const u16 * n) 1484 { 1485 u16 l, r; 1486 1487 l = pgm_read_word(n++); 1488 while (l) { 1489 r = pgm_read_word(n++); 1490 do { 1491 dib0090_write_reg(state, r, pgm_read_word(n++)); 1492 r++; 1493 } while (--l); 1494 l = pgm_read_word(n++); 1495 } 1496 } 1497 1498 #define CAP_VALUE_MIN (u8) 9 1499 #define CAP_VALUE_MAX (u8) 40 1500 #define HR_MIN (u8) 25 1501 #define HR_MAX (u8) 40 1502 #define POLY_MIN (u8) 0 1503 #define POLY_MAX (u8) 8 1504 1505 static void dib0090_set_EFUSE(struct dib0090_state *state) 1506 { 1507 u8 c, h, n; 1508 u16 e2, e4; 1509 u16 cal; 1510 1511 e2 = dib0090_read_reg(state, 0x26); 1512 e4 = dib0090_read_reg(state, 0x28); 1513 1514 if ((state->identity.version == P1D_E_F) || 1515 (state->identity.version == P1G) || (e2 == 0xffff)) { 1516 1517 dib0090_write_reg(state, 0x22, 0x10); 1518 cal = (dib0090_read_reg(state, 0x22) >> 6) & 0x3ff; 1519 1520 if ((cal < 670) || (cal == 1023)) 1521 cal = 850; 1522 n = 165 - ((cal * 10)>>6) ; 1523 e2 = e4 = (3<<12) | (34<<6) | (n); 1524 } 1525 1526 if (e2 != e4) 1527 e2 &= e4; /* Remove the redundancy */ 1528 1529 if (e2 != 0xffff) { 1530 c = e2 & 0x3f; 1531 n = (e2 >> 12) & 0xf; 1532 h = (e2 >> 6) & 0x3f; 1533 1534 if ((c >= CAP_VALUE_MAX) || (c <= CAP_VALUE_MIN)) 1535 c = 32; 1536 else 1537 c += 14; 1538 if ((h >= HR_MAX) || (h <= HR_MIN)) 1539 h = 34; 1540 if ((n >= POLY_MAX) || (n <= POLY_MIN)) 1541 n = 3; 1542 1543 dib0090_write_reg(state, 0x13, (h << 10)); 1544 e2 = (n << 11) | ((h >> 2)<<6) | c; 1545 dib0090_write_reg(state, 0x2, e2); /* Load the BB_2 */ 1546 } 1547 } 1548 1549 static int dib0090_reset(struct dvb_frontend *fe) 1550 { 1551 struct dib0090_state *state = fe->tuner_priv; 1552 1553 dib0090_reset_digital(fe, state->config); 1554 if (dib0090_identify(fe) < 0) 1555 return -EIO; 1556 1557 #ifdef CONFIG_TUNER_DIB0090_P1B_SUPPORT 1558 if (!(state->identity.version & 0x1)) /* it is P1B - reset is already done */ 1559 return 0; 1560 #endif 1561 1562 if (!state->identity.in_soc) { 1563 if ((dib0090_read_reg(state, 0x1a) >> 5) & 0x2) 1564 dib0090_write_reg(state, 0x1b, (EN_IQADC | EN_BB | EN_BIAS | EN_DIGCLK | EN_PLL | EN_CRYSTAL)); 1565 else 1566 dib0090_write_reg(state, 0x1b, (EN_DIGCLK | EN_PLL | EN_CRYSTAL)); 1567 } 1568 1569 dib0090_set_default_config(state, dib0090_defaults); 1570 1571 if (state->identity.in_soc) 1572 dib0090_write_reg(state, 0x18, 0x2910); /* charge pump current = 0 */ 1573 1574 if (state->identity.p1g) 1575 dib0090_set_default_config(state, dib0090_p1g_additionnal_defaults); 1576 1577 /* Update the efuse : Only available for KROSUS > P1C and SOC as well*/ 1578 if (((state->identity.version & 0x1f) >= P1D_E_F) || (state->identity.in_soc)) 1579 dib0090_set_EFUSE(state); 1580 1581 /* Congigure in function of the crystal */ 1582 if (state->config->force_crystal_mode != 0) 1583 dib0090_write_reg(state, 0x14, 1584 state->config->force_crystal_mode & 3); 1585 else if (state->config->io.clock_khz >= 24000) 1586 dib0090_write_reg(state, 0x14, 1); 1587 else 1588 dib0090_write_reg(state, 0x14, 2); 1589 dprintk("Pll lock : %d", (dib0090_read_reg(state, 0x1a) >> 11) & 0x1); 1590 1591 state->calibrate = DC_CAL | WBD_CAL | TEMP_CAL; /* enable iq-offset-calibration and wbd-calibration when tuning next time */ 1592 1593 return 0; 1594 } 1595 1596 #define steps(u) (((u) > 15) ? ((u)-16) : (u)) 1597 #define INTERN_WAIT 10 1598 static int dib0090_get_offset(struct dib0090_state *state, enum frontend_tune_state *tune_state) 1599 { 1600 int ret = INTERN_WAIT * 10; 1601 1602 switch (*tune_state) { 1603 case CT_TUNER_STEP_2: 1604 /* Turns to positive */ 1605 dib0090_write_reg(state, 0x1f, 0x7); 1606 *tune_state = CT_TUNER_STEP_3; 1607 break; 1608 1609 case CT_TUNER_STEP_3: 1610 state->adc_diff = dib0090_read_reg(state, 0x1d); 1611 1612 /* Turns to negative */ 1613 dib0090_write_reg(state, 0x1f, 0x4); 1614 *tune_state = CT_TUNER_STEP_4; 1615 break; 1616 1617 case CT_TUNER_STEP_4: 1618 state->adc_diff -= dib0090_read_reg(state, 0x1d); 1619 *tune_state = CT_TUNER_STEP_5; 1620 ret = 0; 1621 break; 1622 1623 default: 1624 break; 1625 } 1626 1627 return ret; 1628 } 1629 1630 struct dc_calibration { 1631 u8 addr; 1632 u8 offset; 1633 u8 pga:1; 1634 u16 bb1; 1635 u8 i:1; 1636 }; 1637 1638 static const struct dc_calibration dc_table[] = { 1639 /* Step1 BB gain1= 26 with boost 1, gain 2 = 0 */ 1640 {0x06, 5, 1, (1 << 13) | (0 << 8) | (26 << 3), 1}, 1641 {0x07, 11, 1, (1 << 13) | (0 << 8) | (26 << 3), 0}, 1642 /* Step 2 BB gain 1 = 26 with boost = 1 & gain 2 = 29 */ 1643 {0x06, 0, 0, (1 << 13) | (29 << 8) | (26 << 3), 1}, 1644 {0x06, 10, 0, (1 << 13) | (29 << 8) | (26 << 3), 0}, 1645 {0}, 1646 }; 1647 1648 static const struct dc_calibration dc_p1g_table[] = { 1649 /* Step1 BB gain1= 26 with boost 1, gain 2 = 0 */ 1650 /* addr ; trim reg offset ; pga ; CTRL_BB1 value ; i or q */ 1651 {0x06, 5, 1, (1 << 13) | (0 << 8) | (15 << 3), 1}, 1652 {0x07, 11, 1, (1 << 13) | (0 << 8) | (15 << 3), 0}, 1653 /* Step 2 BB gain 1 = 26 with boost = 1 & gain 2 = 29 */ 1654 {0x06, 0, 0, (1 << 13) | (29 << 8) | (15 << 3), 1}, 1655 {0x06, 10, 0, (1 << 13) | (29 << 8) | (15 << 3), 0}, 1656 {0}, 1657 }; 1658 1659 static void dib0090_set_trim(struct dib0090_state *state) 1660 { 1661 u16 *val; 1662 1663 if (state->dc->addr == 0x07) 1664 val = &state->bb7; 1665 else 1666 val = &state->bb6; 1667 1668 *val &= ~(0x1f << state->dc->offset); 1669 *val |= state->step << state->dc->offset; 1670 1671 dib0090_write_reg(state, state->dc->addr, *val); 1672 } 1673 1674 static int dib0090_dc_offset_calibration(struct dib0090_state *state, enum frontend_tune_state *tune_state) 1675 { 1676 int ret = 0; 1677 u16 reg; 1678 1679 switch (*tune_state) { 1680 case CT_TUNER_START: 1681 dprintk("Start DC offset calibration"); 1682 1683 /* force vcm2 = 0.8V */ 1684 state->bb6 = 0; 1685 state->bb7 = 0x040d; 1686 1687 /* the LNA AND LO are off */ 1688 reg = dib0090_read_reg(state, 0x24) & 0x0ffb; /* shutdown lna and lo */ 1689 dib0090_write_reg(state, 0x24, reg); 1690 1691 state->wbdmux = dib0090_read_reg(state, 0x10); 1692 dib0090_write_reg(state, 0x10, (state->wbdmux & ~(0xff << 3)) | (0x7 << 3) | 0x3); 1693 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) & ~(1 << 14)); 1694 1695 state->dc = dc_table; 1696 1697 if (state->identity.p1g) 1698 state->dc = dc_p1g_table; 1699 1700 /* fall through */ 1701 case CT_TUNER_STEP_0: 1702 dprintk("Start/continue DC calibration for %s path", (state->dc->i == 1) ? "I" : "Q"); 1703 dib0090_write_reg(state, 0x01, state->dc->bb1); 1704 dib0090_write_reg(state, 0x07, state->bb7 | (state->dc->i << 7)); 1705 1706 state->step = 0; 1707 state->min_adc_diff = 1023; 1708 *tune_state = CT_TUNER_STEP_1; 1709 ret = 50; 1710 break; 1711 1712 case CT_TUNER_STEP_1: 1713 dib0090_set_trim(state); 1714 *tune_state = CT_TUNER_STEP_2; 1715 break; 1716 1717 case CT_TUNER_STEP_2: 1718 case CT_TUNER_STEP_3: 1719 case CT_TUNER_STEP_4: 1720 ret = dib0090_get_offset(state, tune_state); 1721 break; 1722 1723 case CT_TUNER_STEP_5: /* found an offset */ 1724 dprintk("adc_diff = %d, current step= %d", (u32) state->adc_diff, state->step); 1725 if (state->step == 0 && state->adc_diff < 0) { 1726 state->min_adc_diff = -1023; 1727 dprintk("Change of sign of the minimum adc diff"); 1728 } 1729 1730 dprintk("adc_diff = %d, min_adc_diff = %d current_step = %d", state->adc_diff, state->min_adc_diff, state->step); 1731 1732 /* first turn for this frequency */ 1733 if (state->step == 0) { 1734 if (state->dc->pga && state->adc_diff < 0) 1735 state->step = 0x10; 1736 if (state->dc->pga == 0 && state->adc_diff > 0) 1737 state->step = 0x10; 1738 } 1739 1740 /* Look for a change of Sign in the Adc_diff.min_adc_diff is used to STORE the setp N-1 */ 1741 if ((state->adc_diff & 0x8000) == (state->min_adc_diff & 0x8000) && steps(state->step) < 15) { 1742 /* stop search when the delta the sign is changing and Steps =15 and Step=0 is force for continuance */ 1743 state->step++; 1744 state->min_adc_diff = state->adc_diff; 1745 *tune_state = CT_TUNER_STEP_1; 1746 } else { 1747 /* the minimum was what we have seen in the step before */ 1748 if (ABS(state->adc_diff) > ABS(state->min_adc_diff)) { 1749 dprintk("Since adc_diff N = %d > adc_diff step N-1 = %d, Come back one step", state->adc_diff, state->min_adc_diff); 1750 state->step--; 1751 } 1752 1753 dib0090_set_trim(state); 1754 dprintk("BB Offset Cal, BBreg=%hd,Offset=%hd,Value Set=%hd", state->dc->addr, state->adc_diff, state->step); 1755 1756 state->dc++; 1757 if (state->dc->addr == 0) /* done */ 1758 *tune_state = CT_TUNER_STEP_6; 1759 else 1760 *tune_state = CT_TUNER_STEP_0; 1761 1762 } 1763 break; 1764 1765 case CT_TUNER_STEP_6: 1766 dib0090_write_reg(state, 0x07, state->bb7 & ~0x0008); 1767 dib0090_write_reg(state, 0x1f, 0x7); 1768 *tune_state = CT_TUNER_START; /* reset done -> real tuning can now begin */ 1769 state->calibrate &= ~DC_CAL; 1770 default: 1771 break; 1772 } 1773 return ret; 1774 } 1775 1776 static int dib0090_wbd_calibration(struct dib0090_state *state, enum frontend_tune_state *tune_state) 1777 { 1778 u8 wbd_gain; 1779 const struct dib0090_wbd_slope *wbd = state->current_wbd_table; 1780 1781 switch (*tune_state) { 1782 case CT_TUNER_START: 1783 while (state->current_rf / 1000 > wbd->max_freq) 1784 wbd++; 1785 if (wbd->wbd_gain != 0) 1786 wbd_gain = wbd->wbd_gain; 1787 else { 1788 wbd_gain = 4; 1789 #if defined(CONFIG_BAND_LBAND) || defined(CONFIG_BAND_SBAND) 1790 if ((state->current_band == BAND_LBAND) || (state->current_band == BAND_SBAND)) 1791 wbd_gain = 2; 1792 #endif 1793 } 1794 1795 if (wbd_gain == state->wbd_calibration_gain) { /* the WBD calibration has already been done */ 1796 *tune_state = CT_TUNER_START; 1797 state->calibrate &= ~WBD_CAL; 1798 return 0; 1799 } 1800 1801 dib0090_write_reg(state, 0x10, 0x1b81 | (1 << 10) | (wbd_gain << 13) | (1 << 3)); 1802 1803 dib0090_write_reg(state, 0x24, ((EN_UHF & 0x0fff) | (1 << 1))); 1804 *tune_state = CT_TUNER_STEP_0; 1805 state->wbd_calibration_gain = wbd_gain; 1806 return 90; /* wait for the WBDMUX to switch and for the ADC to sample */ 1807 1808 case CT_TUNER_STEP_0: 1809 state->wbd_offset = dib0090_get_slow_adc_val(state); 1810 dprintk("WBD calibration offset = %d", state->wbd_offset); 1811 *tune_state = CT_TUNER_START; /* reset done -> real tuning can now begin */ 1812 state->calibrate &= ~WBD_CAL; 1813 break; 1814 1815 default: 1816 break; 1817 } 1818 return 0; 1819 } 1820 1821 static void dib0090_set_bandwidth(struct dib0090_state *state) 1822 { 1823 u16 tmp; 1824 1825 if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 5000) 1826 tmp = (3 << 14); 1827 else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 6000) 1828 tmp = (2 << 14); 1829 else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 7000) 1830 tmp = (1 << 14); 1831 else 1832 tmp = (0 << 14); 1833 1834 state->bb_1_def &= 0x3fff; 1835 state->bb_1_def |= tmp; 1836 1837 dib0090_write_reg(state, 0x01, state->bb_1_def); /* be sure that we have the right bb-filter */ 1838 1839 dib0090_write_reg(state, 0x03, 0x6008); /* = 0x6008 : vcm3_trim = 1 ; filter2_gm1_trim = 8 ; filter2_cutoff_freq = 0 */ 1840 dib0090_write_reg(state, 0x04, 0x1); /* 0 = 1KHz ; 1 = 50Hz ; 2 = 150Hz ; 3 = 50KHz ; 4 = servo fast */ 1841 if (state->identity.in_soc) { 1842 dib0090_write_reg(state, 0x05, 0x9bcf); /* attenuator_ibias_tri = 2 ; input_stage_ibias_tr = 1 ; nc = 11 ; ext_gm_trim = 1 ; obuf_ibias_trim = 4 ; filter13_gm2_ibias_t = 15 */ 1843 } else { 1844 dib0090_write_reg(state, 0x02, (5 << 11) | (8 << 6) | (22 & 0x3f)); /* 22 = cap_value */ 1845 dib0090_write_reg(state, 0x05, 0xabcd); /* = 0xabcd : attenuator_ibias_tri = 2 ; input_stage_ibias_tr = 2 ; nc = 11 ; ext_gm_trim = 1 ; obuf_ibias_trim = 4 ; filter13_gm2_ibias_t = 13 */ 1846 } 1847 } 1848 1849 static const struct dib0090_pll dib0090_pll_table[] = { 1850 #ifdef CONFIG_BAND_CBAND 1851 {56000, 0, 9, 48, 6}, 1852 {70000, 1, 9, 48, 6}, 1853 {87000, 0, 8, 32, 4}, 1854 {105000, 1, 8, 32, 4}, 1855 {115000, 0, 7, 24, 6}, 1856 {140000, 1, 7, 24, 6}, 1857 {170000, 0, 6, 16, 4}, 1858 #endif 1859 #ifdef CONFIG_BAND_VHF 1860 {200000, 1, 6, 16, 4}, 1861 {230000, 0, 5, 12, 6}, 1862 {280000, 1, 5, 12, 6}, 1863 {340000, 0, 4, 8, 4}, 1864 {380000, 1, 4, 8, 4}, 1865 {450000, 0, 3, 6, 6}, 1866 #endif 1867 #ifdef CONFIG_BAND_UHF 1868 {580000, 1, 3, 6, 6}, 1869 {700000, 0, 2, 4, 4}, 1870 {860000, 1, 2, 4, 4}, 1871 #endif 1872 #ifdef CONFIG_BAND_LBAND 1873 {1800000, 1, 0, 2, 4}, 1874 #endif 1875 #ifdef CONFIG_BAND_SBAND 1876 {2900000, 0, 14, 1, 4}, 1877 #endif 1878 }; 1879 1880 static const struct dib0090_tuning dib0090_tuning_table_fm_vhf_on_cband[] = { 1881 1882 #ifdef CONFIG_BAND_CBAND 1883 {184000, 4, 1, 15, 0x280, 0x2912, 0xb94e, EN_CAB}, 1884 {227000, 4, 3, 15, 0x280, 0x2912, 0xb94e, EN_CAB}, 1885 {380000, 4, 7, 15, 0x280, 0x2912, 0xb94e, EN_CAB}, 1886 #endif 1887 #ifdef CONFIG_BAND_UHF 1888 {520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1889 {550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1890 {650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1891 {750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1892 {850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1893 {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1894 #endif 1895 #ifdef CONFIG_BAND_LBAND 1896 {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1897 {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1898 {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1899 #endif 1900 #ifdef CONFIG_BAND_SBAND 1901 {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD}, 1902 {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD}, 1903 #endif 1904 }; 1905 1906 static const struct dib0090_tuning dib0090_tuning_table[] = { 1907 1908 #ifdef CONFIG_BAND_CBAND 1909 {170000, 4, 1, 15, 0x280, 0x2912, 0xb94e, EN_CAB}, 1910 #endif 1911 #ifdef CONFIG_BAND_VHF 1912 {184000, 1, 1, 15, 0x300, 0x4d12, 0xb94e, EN_VHF}, 1913 {227000, 1, 3, 15, 0x300, 0x4d12, 0xb94e, EN_VHF}, 1914 {380000, 1, 7, 15, 0x300, 0x4d12, 0xb94e, EN_VHF}, 1915 #endif 1916 #ifdef CONFIG_BAND_UHF 1917 {520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1918 {550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1919 {650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1920 {750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1921 {850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1922 {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1923 #endif 1924 #ifdef CONFIG_BAND_LBAND 1925 {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1926 {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1927 {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1928 #endif 1929 #ifdef CONFIG_BAND_SBAND 1930 {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD}, 1931 {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD}, 1932 #endif 1933 }; 1934 1935 static const struct dib0090_tuning dib0090_p1g_tuning_table[] = { 1936 #ifdef CONFIG_BAND_CBAND 1937 {170000, 4, 1, 0x820f, 0x300, 0x2d22, 0x82cb, EN_CAB}, 1938 #endif 1939 #ifdef CONFIG_BAND_VHF 1940 {184000, 1, 1, 15, 0x300, 0x4d12, 0xb94e, EN_VHF}, 1941 {227000, 1, 3, 15, 0x300, 0x4d12, 0xb94e, EN_VHF}, 1942 {380000, 1, 7, 15, 0x300, 0x4d12, 0xb94e, EN_VHF}, 1943 #endif 1944 #ifdef CONFIG_BAND_UHF 1945 {510000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1946 {540000, 2, 1, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1947 {600000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1948 {630000, 2, 4, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1949 {680000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1950 {720000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1951 {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 1952 #endif 1953 #ifdef CONFIG_BAND_LBAND 1954 {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1955 {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1956 {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 1957 #endif 1958 #ifdef CONFIG_BAND_SBAND 1959 {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD}, 1960 {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD}, 1961 #endif 1962 }; 1963 1964 static const struct dib0090_pll dib0090_p1g_pll_table[] = { 1965 #ifdef CONFIG_BAND_CBAND 1966 {57000, 0, 11, 48, 6}, 1967 {70000, 1, 11, 48, 6}, 1968 {86000, 0, 10, 32, 4}, 1969 {105000, 1, 10, 32, 4}, 1970 {115000, 0, 9, 24, 6}, 1971 {140000, 1, 9, 24, 6}, 1972 {170000, 0, 8, 16, 4}, 1973 #endif 1974 #ifdef CONFIG_BAND_VHF 1975 {200000, 1, 8, 16, 4}, 1976 {230000, 0, 7, 12, 6}, 1977 {280000, 1, 7, 12, 6}, 1978 {340000, 0, 6, 8, 4}, 1979 {380000, 1, 6, 8, 4}, 1980 {455000, 0, 5, 6, 6}, 1981 #endif 1982 #ifdef CONFIG_BAND_UHF 1983 {580000, 1, 5, 6, 6}, 1984 {680000, 0, 4, 4, 4}, 1985 {860000, 1, 4, 4, 4}, 1986 #endif 1987 #ifdef CONFIG_BAND_LBAND 1988 {1800000, 1, 2, 2, 4}, 1989 #endif 1990 #ifdef CONFIG_BAND_SBAND 1991 {2900000, 0, 1, 1, 6}, 1992 #endif 1993 }; 1994 1995 static const struct dib0090_tuning dib0090_p1g_tuning_table_fm_vhf_on_cband[] = { 1996 #ifdef CONFIG_BAND_CBAND 1997 {184000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB}, 1998 {227000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB}, 1999 {380000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB}, 2000 #endif 2001 #ifdef CONFIG_BAND_UHF 2002 {520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 2003 {550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 2004 {650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 2005 {750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 2006 {850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 2007 {900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF}, 2008 #endif 2009 #ifdef CONFIG_BAND_LBAND 2010 {1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 2011 {1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 2012 {1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD}, 2013 #endif 2014 #ifdef CONFIG_BAND_SBAND 2015 {2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD}, 2016 {2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD}, 2017 #endif 2018 }; 2019 2020 static const struct dib0090_tuning dib0090_tuning_table_cband_7090[] = { 2021 #ifdef CONFIG_BAND_CBAND 2022 {300000, 4, 3, 0x018F, 0x2c0, 0x2d22, 0xb9ce, EN_CAB}, 2023 {380000, 4, 10, 0x018F, 0x2c0, 0x2d22, 0xb9ce, EN_CAB}, 2024 {570000, 4, 10, 0x8190, 0x2c0, 0x2d22, 0xb9ce, EN_CAB}, 2025 {858000, 4, 5, 0x8190, 0x2c0, 0x2d22, 0xb9ce, EN_CAB}, 2026 #endif 2027 }; 2028 2029 static const struct dib0090_tuning dib0090_tuning_table_cband_7090e_sensitivity[] = { 2030 #ifdef CONFIG_BAND_CBAND 2031 { 300000, 0 , 3, 0x8105, 0x2c0, 0x2d12, 0xb84e, EN_CAB }, 2032 { 380000, 0 , 10, 0x810F, 0x2c0, 0x2d12, 0xb84e, EN_CAB }, 2033 { 600000, 0 , 10, 0x815E, 0x280, 0x2d12, 0xb84e, EN_CAB }, 2034 { 660000, 0 , 5, 0x85E3, 0x280, 0x2d12, 0xb84e, EN_CAB }, 2035 { 720000, 0 , 5, 0x852E, 0x280, 0x2d12, 0xb84e, EN_CAB }, 2036 { 860000, 0 , 4, 0x85E5, 0x280, 0x2d12, 0xb84e, EN_CAB }, 2037 #endif 2038 }; 2039 2040 int dib0090_update_tuning_table_7090(struct dvb_frontend *fe, 2041 u8 cfg_sensitivity) 2042 { 2043 struct dib0090_state *state = fe->tuner_priv; 2044 const struct dib0090_tuning *tune = 2045 dib0090_tuning_table_cband_7090e_sensitivity; 2046 const struct dib0090_tuning dib0090_tuning_table_cband_7090e_aci[] = { 2047 { 300000, 0 , 3, 0x8165, 0x2c0, 0x2d12, 0xb84e, EN_CAB }, 2048 { 650000, 0 , 4, 0x815B, 0x280, 0x2d12, 0xb84e, EN_CAB }, 2049 { 860000, 0 , 5, 0x84EF, 0x280, 0x2d12, 0xb84e, EN_CAB }, 2050 }; 2051 2052 if ((!state->identity.p1g) || (!state->identity.in_soc) 2053 || ((state->identity.version != SOC_7090_P1G_21R1) 2054 && (state->identity.version != SOC_7090_P1G_11R1))) { 2055 dprintk("%s() function can only be used for dib7090", __func__); 2056 return -ENODEV; 2057 } 2058 2059 if (cfg_sensitivity) 2060 tune = dib0090_tuning_table_cband_7090e_sensitivity; 2061 else 2062 tune = dib0090_tuning_table_cband_7090e_aci; 2063 2064 while (state->rf_request > tune->max_freq) 2065 tune++; 2066 2067 dib0090_write_reg(state, 0x09, (dib0090_read_reg(state, 0x09) & 0x8000) 2068 | (tune->lna_bias & 0x7fff)); 2069 dib0090_write_reg(state, 0x0b, (dib0090_read_reg(state, 0x0b) & 0xf83f) 2070 | ((tune->lna_tune << 6) & 0x07c0)); 2071 return 0; 2072 } 2073 EXPORT_SYMBOL(dib0090_update_tuning_table_7090); 2074 2075 static int dib0090_captrim_search(struct dib0090_state *state, enum frontend_tune_state *tune_state) 2076 { 2077 int ret = 0; 2078 u16 lo4 = 0xe900; 2079 2080 s16 adc_target; 2081 u16 adc; 2082 s8 step_sign; 2083 u8 force_soft_search = 0; 2084 2085 if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1) 2086 force_soft_search = 1; 2087 2088 if (*tune_state == CT_TUNER_START) { 2089 dprintk("Start Captrim search : %s", (force_soft_search == 1) ? "FORCE SOFT SEARCH" : "AUTO"); 2090 dib0090_write_reg(state, 0x10, 0x2B1); 2091 dib0090_write_reg(state, 0x1e, 0x0032); 2092 2093 if (!state->tuner_is_tuned) { 2094 /* prepare a complete captrim */ 2095 if (!state->identity.p1g || force_soft_search) 2096 state->step = state->captrim = state->fcaptrim = 64; 2097 2098 state->current_rf = state->rf_request; 2099 } else { /* we are already tuned to this frequency - the configuration is correct */ 2100 if (!state->identity.p1g || force_soft_search) { 2101 /* do a minimal captrim even if the frequency has not changed */ 2102 state->step = 4; 2103 state->captrim = state->fcaptrim = dib0090_read_reg(state, 0x18) & 0x7f; 2104 } 2105 } 2106 state->adc_diff = 3000; 2107 *tune_state = CT_TUNER_STEP_0; 2108 2109 } else if (*tune_state == CT_TUNER_STEP_0) { 2110 if (state->identity.p1g && !force_soft_search) { 2111 u8 ratio = 31; 2112 2113 dib0090_write_reg(state, 0x40, (3 << 7) | (ratio << 2) | (1 << 1) | 1); 2114 dib0090_read_reg(state, 0x40); 2115 ret = 50; 2116 } else { 2117 state->step /= 2; 2118 dib0090_write_reg(state, 0x18, lo4 | state->captrim); 2119 2120 if (state->identity.in_soc) 2121 ret = 25; 2122 } 2123 *tune_state = CT_TUNER_STEP_1; 2124 2125 } else if (*tune_state == CT_TUNER_STEP_1) { 2126 if (state->identity.p1g && !force_soft_search) { 2127 dib0090_write_reg(state, 0x40, 0x18c | (0 << 1) | 0); 2128 dib0090_read_reg(state, 0x40); 2129 2130 state->fcaptrim = dib0090_read_reg(state, 0x18) & 0x7F; 2131 dprintk("***Final Captrim= 0x%x", state->fcaptrim); 2132 *tune_state = CT_TUNER_STEP_3; 2133 2134 } else { 2135 /* MERGE for all krosus before P1G */ 2136 adc = dib0090_get_slow_adc_val(state); 2137 dprintk("CAPTRIM=%d; ADC = %d (ADC) & %dmV", (u32) state->captrim, (u32) adc, (u32) (adc) * (u32) 1800 / (u32) 1024); 2138 2139 if (state->rest == 0 || state->identity.in_soc) { /* Just for 8090P SOCS where auto captrim HW bug : TO CHECK IN ACI for SOCS !!! if 400 for 8090p SOC => tune issue !!! */ 2140 adc_target = 200; 2141 } else 2142 adc_target = 400; 2143 2144 if (adc >= adc_target) { 2145 adc -= adc_target; 2146 step_sign = -1; 2147 } else { 2148 adc = adc_target - adc; 2149 step_sign = 1; 2150 } 2151 2152 if (adc < state->adc_diff) { 2153 dprintk("CAPTRIM=%d is closer to target (%d/%d)", (u32) state->captrim, (u32) adc, (u32) state->adc_diff); 2154 state->adc_diff = adc; 2155 state->fcaptrim = state->captrim; 2156 } 2157 2158 state->captrim += step_sign * state->step; 2159 if (state->step >= 1) 2160 *tune_state = CT_TUNER_STEP_0; 2161 else 2162 *tune_state = CT_TUNER_STEP_2; 2163 2164 ret = 25; 2165 } 2166 } else if (*tune_state == CT_TUNER_STEP_2) { /* this step is only used by krosus < P1G */ 2167 /*write the final cptrim config */ 2168 dib0090_write_reg(state, 0x18, lo4 | state->fcaptrim); 2169 2170 *tune_state = CT_TUNER_STEP_3; 2171 2172 } else if (*tune_state == CT_TUNER_STEP_3) { 2173 state->calibrate &= ~CAPTRIM_CAL; 2174 *tune_state = CT_TUNER_STEP_0; 2175 } 2176 2177 return ret; 2178 } 2179 2180 static int dib0090_get_temperature(struct dib0090_state *state, enum frontend_tune_state *tune_state) 2181 { 2182 int ret = 15; 2183 s16 val; 2184 2185 switch (*tune_state) { 2186 case CT_TUNER_START: 2187 state->wbdmux = dib0090_read_reg(state, 0x10); 2188 dib0090_write_reg(state, 0x10, (state->wbdmux & ~(0xff << 3)) | (0x8 << 3)); 2189 2190 state->bias = dib0090_read_reg(state, 0x13); 2191 dib0090_write_reg(state, 0x13, state->bias | (0x3 << 8)); 2192 2193 *tune_state = CT_TUNER_STEP_0; 2194 /* wait for the WBDMUX to switch and for the ADC to sample */ 2195 break; 2196 2197 case CT_TUNER_STEP_0: 2198 state->adc_diff = dib0090_get_slow_adc_val(state); 2199 dib0090_write_reg(state, 0x13, (state->bias & ~(0x3 << 8)) | (0x2 << 8)); 2200 *tune_state = CT_TUNER_STEP_1; 2201 break; 2202 2203 case CT_TUNER_STEP_1: 2204 val = dib0090_get_slow_adc_val(state); 2205 state->temperature = ((s16) ((val - state->adc_diff) * 180) >> 8) + 55; 2206 2207 dprintk("temperature: %d C", state->temperature - 30); 2208 2209 *tune_state = CT_TUNER_STEP_2; 2210 break; 2211 2212 case CT_TUNER_STEP_2: 2213 dib0090_write_reg(state, 0x13, state->bias); 2214 dib0090_write_reg(state, 0x10, state->wbdmux); /* write back original WBDMUX */ 2215 2216 *tune_state = CT_TUNER_START; 2217 state->calibrate &= ~TEMP_CAL; 2218 if (state->config->analog_output == 0) 2219 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14)); 2220 2221 break; 2222 2223 default: 2224 ret = 0; 2225 break; 2226 } 2227 return ret; 2228 } 2229 2230 #define WBD 0x781 /* 1 1 1 1 0000 0 0 1 */ 2231 static int dib0090_tune(struct dvb_frontend *fe) 2232 { 2233 struct dib0090_state *state = fe->tuner_priv; 2234 const struct dib0090_tuning *tune = state->current_tune_table_index; 2235 const struct dib0090_pll *pll = state->current_pll_table_index; 2236 enum frontend_tune_state *tune_state = &state->tune_state; 2237 2238 u16 lo5, lo6, Den, tmp; 2239 u32 FBDiv, Rest, FREF, VCOF_kHz = 0; 2240 int ret = 10; /* 1ms is the default delay most of the time */ 2241 u8 c, i; 2242 2243 /************************* VCO ***************************/ 2244 /* Default values for FG */ 2245 /* from these are needed : */ 2246 /* Cp,HFdiv,VCOband,SD,Num,Den,FB and REFDiv */ 2247 2248 /* in any case we first need to do a calibration if needed */ 2249 if (*tune_state == CT_TUNER_START) { 2250 /* deactivate DataTX before some calibrations */ 2251 if (state->calibrate & (DC_CAL | TEMP_CAL | WBD_CAL)) 2252 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) & ~(1 << 14)); 2253 else 2254 /* Activate DataTX in case a calibration has been done before */ 2255 if (state->config->analog_output == 0) 2256 dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14)); 2257 } 2258 2259 if (state->calibrate & DC_CAL) 2260 return dib0090_dc_offset_calibration(state, tune_state); 2261 else if (state->calibrate & WBD_CAL) { 2262 if (state->current_rf == 0) 2263 state->current_rf = state->fe->dtv_property_cache.frequency / 1000; 2264 return dib0090_wbd_calibration(state, tune_state); 2265 } else if (state->calibrate & TEMP_CAL) 2266 return dib0090_get_temperature(state, tune_state); 2267 else if (state->calibrate & CAPTRIM_CAL) 2268 return dib0090_captrim_search(state, tune_state); 2269 2270 if (*tune_state == CT_TUNER_START) { 2271 /* if soc and AGC pwm control, disengage mux to be able to R/W access to 0x01 register to set the right filter (cutoff_freq_select) during the tune sequence, otherwise, SOC SERPAR error when accessing to 0x01 */ 2272 if (state->config->use_pwm_agc && state->identity.in_soc) { 2273 tmp = dib0090_read_reg(state, 0x39); 2274 if ((tmp >> 10) & 0x1) 2275 dib0090_write_reg(state, 0x39, tmp & ~(1 << 10)); 2276 } 2277 2278 state->current_band = (u8) BAND_OF_FREQUENCY(state->fe->dtv_property_cache.frequency / 1000); 2279 state->rf_request = 2280 state->fe->dtv_property_cache.frequency / 1000 + (state->current_band == 2281 BAND_UHF ? state->config->freq_offset_khz_uhf : state->config-> 2282 freq_offset_khz_vhf); 2283 2284 /* in ISDB-T 1seg we shift tuning frequency */ 2285 if ((state->fe->dtv_property_cache.delivery_system == SYS_ISDBT && state->fe->dtv_property_cache.isdbt_sb_mode == 1 2286 && state->fe->dtv_property_cache.isdbt_partial_reception == 0)) { 2287 const struct dib0090_low_if_offset_table *LUT_offset = state->config->low_if; 2288 u8 found_offset = 0; 2289 u32 margin_khz = 100; 2290 2291 if (LUT_offset != NULL) { 2292 while (LUT_offset->RF_freq != 0xffff) { 2293 if (((state->rf_request > (LUT_offset->RF_freq - margin_khz)) 2294 && (state->rf_request < (LUT_offset->RF_freq + margin_khz))) 2295 && LUT_offset->std == state->fe->dtv_property_cache.delivery_system) { 2296 state->rf_request += LUT_offset->offset_khz; 2297 found_offset = 1; 2298 break; 2299 } 2300 LUT_offset++; 2301 } 2302 } 2303 2304 if (found_offset == 0) 2305 state->rf_request += 400; 2306 } 2307 if (state->current_rf != state->rf_request || (state->current_standard != state->fe->dtv_property_cache.delivery_system)) { 2308 state->tuner_is_tuned = 0; 2309 state->current_rf = 0; 2310 state->current_standard = 0; 2311 2312 tune = dib0090_tuning_table; 2313 if (state->identity.p1g) 2314 tune = dib0090_p1g_tuning_table; 2315 2316 tmp = (state->identity.version >> 5) & 0x7; 2317 2318 if (state->identity.in_soc) { 2319 if (state->config->force_cband_input) { /* Use the CBAND input for all band */ 2320 if (state->current_band & BAND_CBAND || state->current_band & BAND_FM || state->current_band & BAND_VHF 2321 || state->current_band & BAND_UHF) { 2322 state->current_band = BAND_CBAND; 2323 if (state->config->is_dib7090e) 2324 tune = dib0090_tuning_table_cband_7090e_sensitivity; 2325 else 2326 tune = dib0090_tuning_table_cband_7090; 2327 } 2328 } else { /* Use the CBAND input for all band under UHF */ 2329 if (state->current_band & BAND_CBAND || state->current_band & BAND_FM || state->current_band & BAND_VHF) { 2330 state->current_band = BAND_CBAND; 2331 if (state->config->is_dib7090e) 2332 tune = dib0090_tuning_table_cband_7090e_sensitivity; 2333 else 2334 tune = dib0090_tuning_table_cband_7090; 2335 } 2336 } 2337 } else 2338 if (tmp == 0x4 || tmp == 0x7) { 2339 /* CBAND tuner version for VHF */ 2340 if (state->current_band == BAND_FM || state->current_band == BAND_CBAND || state->current_band == BAND_VHF) { 2341 state->current_band = BAND_CBAND; /* Force CBAND */ 2342 2343 tune = dib0090_tuning_table_fm_vhf_on_cband; 2344 if (state->identity.p1g) 2345 tune = dib0090_p1g_tuning_table_fm_vhf_on_cband; 2346 } 2347 } 2348 2349 pll = dib0090_pll_table; 2350 if (state->identity.p1g) 2351 pll = dib0090_p1g_pll_table; 2352 2353 /* Look for the interval */ 2354 while (state->rf_request > tune->max_freq) 2355 tune++; 2356 while (state->rf_request > pll->max_freq) 2357 pll++; 2358 2359 state->current_tune_table_index = tune; 2360 state->current_pll_table_index = pll; 2361 2362 dib0090_write_reg(state, 0x0b, 0xb800 | (tune->switch_trim)); 2363 2364 VCOF_kHz = (pll->hfdiv * state->rf_request) * 2; 2365 2366 FREF = state->config->io.clock_khz; 2367 if (state->config->fref_clock_ratio != 0) 2368 FREF /= state->config->fref_clock_ratio; 2369 2370 FBDiv = (VCOF_kHz / pll->topresc / FREF); 2371 Rest = (VCOF_kHz / pll->topresc) - FBDiv * FREF; 2372 2373 if (Rest < LPF) 2374 Rest = 0; 2375 else if (Rest < 2 * LPF) 2376 Rest = 2 * LPF; 2377 else if (Rest > (FREF - LPF)) { 2378 Rest = 0; 2379 FBDiv += 1; 2380 } else if (Rest > (FREF - 2 * LPF)) 2381 Rest = FREF - 2 * LPF; 2382 Rest = (Rest * 6528) / (FREF / 10); 2383 state->rest = Rest; 2384 2385 /* external loop filter, otherwise: 2386 * lo5 = (0 << 15) | (0 << 12) | (0 << 11) | (3 << 9) | (4 << 6) | (3 << 4) | 4; 2387 * lo6 = 0x0e34 */ 2388 2389 if (Rest == 0) { 2390 if (pll->vco_band) 2391 lo5 = 0x049f; 2392 else 2393 lo5 = 0x041f; 2394 } else { 2395 if (pll->vco_band) 2396 lo5 = 0x049e; 2397 else if (state->config->analog_output) 2398 lo5 = 0x041d; 2399 else 2400 lo5 = 0x041c; 2401 } 2402 2403 if (state->identity.p1g) { /* Bias is done automatically in P1G */ 2404 if (state->identity.in_soc) { 2405 if (state->identity.version == SOC_8090_P1G_11R1) 2406 lo5 = 0x46f; 2407 else 2408 lo5 = 0x42f; 2409 } else 2410 lo5 = 0x42c; 2411 } 2412 2413 lo5 |= (pll->hfdiv_code << 11) | (pll->vco_band << 7); /* bit 15 is the split to the slave, we do not do it here */ 2414 2415 if (!state->config->io.pll_int_loop_filt) { 2416 if (state->identity.in_soc) 2417 lo6 = 0xff98; 2418 else if (state->identity.p1g || (Rest == 0)) 2419 lo6 = 0xfff8; 2420 else 2421 lo6 = 0xff28; 2422 } else 2423 lo6 = (state->config->io.pll_int_loop_filt << 3); 2424 2425 Den = 1; 2426 2427 if (Rest > 0) { 2428 if (state->config->analog_output) 2429 lo6 |= (1 << 2) | 2; 2430 else { 2431 if (state->identity.in_soc) 2432 lo6 |= (1 << 2) | 2; 2433 else 2434 lo6 |= (1 << 2) | 2; 2435 } 2436 Den = 255; 2437 } 2438 dib0090_write_reg(state, 0x15, (u16) FBDiv); 2439 if (state->config->fref_clock_ratio != 0) 2440 dib0090_write_reg(state, 0x16, (Den << 8) | state->config->fref_clock_ratio); 2441 else 2442 dib0090_write_reg(state, 0x16, (Den << 8) | 1); 2443 dib0090_write_reg(state, 0x17, (u16) Rest); 2444 dib0090_write_reg(state, 0x19, lo5); 2445 dib0090_write_reg(state, 0x1c, lo6); 2446 2447 lo6 = tune->tuner_enable; 2448 if (state->config->analog_output) 2449 lo6 = (lo6 & 0xff9f) | 0x2; 2450 2451 dib0090_write_reg(state, 0x24, lo6 | EN_LO | state->config->use_pwm_agc * EN_CRYSTAL); 2452 2453 } 2454 2455 state->current_rf = state->rf_request; 2456 state->current_standard = state->fe->dtv_property_cache.delivery_system; 2457 2458 ret = 20; 2459 state->calibrate = CAPTRIM_CAL; /* captrim serach now */ 2460 } 2461 2462 else if (*tune_state == CT_TUNER_STEP_0) { /* Warning : because of captrim cal, if you change this step, change it also in _cal.c file because it is the step following captrim cal state machine */ 2463 const struct dib0090_wbd_slope *wbd = state->current_wbd_table; 2464 2465 while (state->current_rf / 1000 > wbd->max_freq) 2466 wbd++; 2467 2468 dib0090_write_reg(state, 0x1e, 0x07ff); 2469 dprintk("Final Captrim: %d", (u32) state->fcaptrim); 2470 dprintk("HFDIV code: %d", (u32) pll->hfdiv_code); 2471 dprintk("VCO = %d", (u32) pll->vco_band); 2472 dprintk("VCOF in kHz: %d ((%d*%d) << 1))", (u32) ((pll->hfdiv * state->rf_request) * 2), (u32) pll->hfdiv, (u32) state->rf_request); 2473 dprintk("REFDIV: %d, FREF: %d", (u32) 1, (u32) state->config->io.clock_khz); 2474 dprintk("FBDIV: %d, Rest: %d", (u32) dib0090_read_reg(state, 0x15), (u32) dib0090_read_reg(state, 0x17)); 2475 dprintk("Num: %d, Den: %d, SD: %d", (u32) dib0090_read_reg(state, 0x17), (u32) (dib0090_read_reg(state, 0x16) >> 8), 2476 (u32) dib0090_read_reg(state, 0x1c) & 0x3); 2477 2478 #define WBD 0x781 /* 1 1 1 1 0000 0 0 1 */ 2479 c = 4; 2480 i = 3; 2481 2482 if (wbd->wbd_gain != 0) 2483 c = wbd->wbd_gain; 2484 2485 state->wbdmux = (c << 13) | (i << 11) | (WBD | (state->config->use_pwm_agc << 1)); 2486 dib0090_write_reg(state, 0x10, state->wbdmux); 2487 2488 if ((tune->tuner_enable == EN_CAB) && state->identity.p1g) { 2489 dprintk("P1G : The cable band is selected and lna_tune = %d", tune->lna_tune); 2490 dib0090_write_reg(state, 0x09, tune->lna_bias); 2491 dib0090_write_reg(state, 0x0b, 0xb800 | (tune->lna_tune << 6) | (tune->switch_trim)); 2492 } else 2493 dib0090_write_reg(state, 0x09, (tune->lna_tune << 5) | tune->lna_bias); 2494 2495 dib0090_write_reg(state, 0x0c, tune->v2i); 2496 dib0090_write_reg(state, 0x0d, tune->mix); 2497 dib0090_write_reg(state, 0x0e, tune->load); 2498 *tune_state = CT_TUNER_STEP_1; 2499 2500 } else if (*tune_state == CT_TUNER_STEP_1) { 2501 /* initialize the lt gain register */ 2502 state->rf_lt_def = 0x7c00; 2503 2504 dib0090_set_bandwidth(state); 2505 state->tuner_is_tuned = 1; 2506 2507 state->calibrate |= WBD_CAL; 2508 state->calibrate |= TEMP_CAL; 2509 *tune_state = CT_TUNER_STOP; 2510 } else 2511 ret = FE_CALLBACK_TIME_NEVER; 2512 return ret; 2513 } 2514 2515 static int dib0090_release(struct dvb_frontend *fe) 2516 { 2517 kfree(fe->tuner_priv); 2518 fe->tuner_priv = NULL; 2519 return 0; 2520 } 2521 2522 enum frontend_tune_state dib0090_get_tune_state(struct dvb_frontend *fe) 2523 { 2524 struct dib0090_state *state = fe->tuner_priv; 2525 2526 return state->tune_state; 2527 } 2528 2529 EXPORT_SYMBOL(dib0090_get_tune_state); 2530 2531 int dib0090_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state) 2532 { 2533 struct dib0090_state *state = fe->tuner_priv; 2534 2535 state->tune_state = tune_state; 2536 return 0; 2537 } 2538 2539 EXPORT_SYMBOL(dib0090_set_tune_state); 2540 2541 static int dib0090_get_frequency(struct dvb_frontend *fe, u32 * frequency) 2542 { 2543 struct dib0090_state *state = fe->tuner_priv; 2544 2545 *frequency = 1000 * state->current_rf; 2546 return 0; 2547 } 2548 2549 static int dib0090_set_params(struct dvb_frontend *fe) 2550 { 2551 struct dib0090_state *state = fe->tuner_priv; 2552 u32 ret; 2553 2554 state->tune_state = CT_TUNER_START; 2555 2556 do { 2557 ret = dib0090_tune(fe); 2558 if (ret == FE_CALLBACK_TIME_NEVER) 2559 break; 2560 2561 /* 2562 * Despite dib0090_tune returns time at a 0.1 ms range, 2563 * the actual sleep time depends on CONFIG_HZ. The worse case 2564 * is when CONFIG_HZ=100. In such case, the minimum granularity 2565 * is 10ms. On some real field tests, the tuner sometimes don't 2566 * lock when this timer is lower than 10ms. So, enforce a 10ms 2567 * granularity and use usleep_range() instead of msleep(). 2568 */ 2569 ret = 10 * (ret + 99)/100; 2570 usleep_range(ret * 1000, (ret + 1) * 1000); 2571 } while (state->tune_state != CT_TUNER_STOP); 2572 2573 return 0; 2574 } 2575 2576 static const struct dvb_tuner_ops dib0090_ops = { 2577 .info = { 2578 .name = "DiBcom DiB0090", 2579 .frequency_min = 45000000, 2580 .frequency_max = 860000000, 2581 .frequency_step = 1000, 2582 }, 2583 .release = dib0090_release, 2584 2585 .init = dib0090_wakeup, 2586 .sleep = dib0090_sleep, 2587 .set_params = dib0090_set_params, 2588 .get_frequency = dib0090_get_frequency, 2589 }; 2590 2591 static const struct dvb_tuner_ops dib0090_fw_ops = { 2592 .info = { 2593 .name = "DiBcom DiB0090", 2594 .frequency_min = 45000000, 2595 .frequency_max = 860000000, 2596 .frequency_step = 1000, 2597 }, 2598 .release = dib0090_release, 2599 2600 .init = NULL, 2601 .sleep = NULL, 2602 .set_params = NULL, 2603 .get_frequency = NULL, 2604 }; 2605 2606 static const struct dib0090_wbd_slope dib0090_wbd_table_default[] = { 2607 {470, 0, 250, 0, 100, 4}, 2608 {860, 51, 866, 21, 375, 4}, 2609 {1700, 0, 800, 0, 850, 4}, 2610 {2900, 0, 250, 0, 100, 6}, 2611 {0xFFFF, 0, 0, 0, 0, 0}, 2612 }; 2613 2614 struct dvb_frontend *dib0090_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config) 2615 { 2616 struct dib0090_state *st = kzalloc(sizeof(struct dib0090_state), GFP_KERNEL); 2617 if (st == NULL) 2618 return NULL; 2619 2620 st->config = config; 2621 st->i2c = i2c; 2622 st->fe = fe; 2623 mutex_init(&st->i2c_buffer_lock); 2624 fe->tuner_priv = st; 2625 2626 if (config->wbd == NULL) 2627 st->current_wbd_table = dib0090_wbd_table_default; 2628 else 2629 st->current_wbd_table = config->wbd; 2630 2631 if (dib0090_reset(fe) != 0) 2632 goto free_mem; 2633 2634 printk(KERN_INFO "DiB0090: successfully identified\n"); 2635 memcpy(&fe->ops.tuner_ops, &dib0090_ops, sizeof(struct dvb_tuner_ops)); 2636 2637 return fe; 2638 free_mem: 2639 kfree(st); 2640 fe->tuner_priv = NULL; 2641 return NULL; 2642 } 2643 2644 EXPORT_SYMBOL(dib0090_register); 2645 2646 struct dvb_frontend *dib0090_fw_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config) 2647 { 2648 struct dib0090_fw_state *st = kzalloc(sizeof(struct dib0090_fw_state), GFP_KERNEL); 2649 if (st == NULL) 2650 return NULL; 2651 2652 st->config = config; 2653 st->i2c = i2c; 2654 st->fe = fe; 2655 mutex_init(&st->i2c_buffer_lock); 2656 fe->tuner_priv = st; 2657 2658 if (dib0090_fw_reset_digital(fe, st->config) != 0) 2659 goto free_mem; 2660 2661 dprintk("DiB0090 FW: successfully identified"); 2662 memcpy(&fe->ops.tuner_ops, &dib0090_fw_ops, sizeof(struct dvb_tuner_ops)); 2663 2664 return fe; 2665 free_mem: 2666 kfree(st); 2667 fe->tuner_priv = NULL; 2668 return NULL; 2669 } 2670 EXPORT_SYMBOL(dib0090_fw_register); 2671 2672 MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>"); 2673 MODULE_AUTHOR("Olivier Grenie <olivier.grenie@dibcom.fr>"); 2674 MODULE_DESCRIPTION("Driver for the DiBcom 0090 base-band RF Tuner"); 2675 MODULE_LICENSE("GPL"); 2676