tda18271-fe.c revision 1bacb2df3bc999dcad21e9aab6bdb60d6dc7bc02
1/* 2 tda18271-fe.c - driver for the Philips / NXP TDA18271 silicon tuner 3 4 Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19*/ 20 21#include <linux/delay.h> 22#include <linux/videodev2.h> 23#include "tda18271-priv.h" 24#include "tda8290.h" 25 26int tda18271_debug; 27module_param_named(debug, tda18271_debug, int, 0644); 28MODULE_PARM_DESC(debug, "set debug level " 29 "(info=1, map=2, reg=4, adv=8, cal=16 (or-able))"); 30 31static int tda18271_cal_on_startup = -1; 32module_param_named(cal, tda18271_cal_on_startup, int, 0644); 33MODULE_PARM_DESC(cal, "perform RF tracking filter calibration on startup"); 34 35static DEFINE_MUTEX(tda18271_list_mutex); 36static LIST_HEAD(hybrid_tuner_instance_list); 37 38/*---------------------------------------------------------------------*/ 39 40static int tda18271_toggle_output(struct dvb_frontend *fe, int standby) 41{ 42 struct tda18271_priv *priv = fe->tuner_priv; 43 44 int ret = tda18271_set_standby_mode(fe, standby ? 1 : 0, 45 priv->output_opt & TDA18271_OUTPUT_LT_OFF ? 1 : 0, 46 priv->output_opt & TDA18271_OUTPUT_XT_OFF ? 1 : 0); 47 48 if (tda_fail(ret)) 49 goto fail; 50 51 tda_dbg("%s mode: xtal oscillator %s, slave tuner loop thru %s\n", 52 standby ? "standby" : "active", 53 priv->output_opt & TDA18271_OUTPUT_XT_OFF ? "off" : "on", 54 priv->output_opt & TDA18271_OUTPUT_LT_OFF ? "off" : "on"); 55fail: 56 return ret; 57} 58 59/*---------------------------------------------------------------------*/ 60 61static inline int charge_pump_source(struct dvb_frontend *fe, int force) 62{ 63 struct tda18271_priv *priv = fe->tuner_priv; 64 return tda18271_charge_pump_source(fe, 65 (priv->role == TDA18271_SLAVE) ? 66 TDA18271_CAL_PLL : 67 TDA18271_MAIN_PLL, force); 68} 69 70static inline void tda18271_set_if_notch(struct dvb_frontend *fe) 71{ 72 struct tda18271_priv *priv = fe->tuner_priv; 73 unsigned char *regs = priv->tda18271_regs; 74 75 switch (priv->mode) { 76 case TDA18271_ANALOG: 77 regs[R_MPD] &= ~0x80; /* IF notch = 0 */ 78 break; 79 case TDA18271_DIGITAL: 80 regs[R_MPD] |= 0x80; /* IF notch = 1 */ 81 break; 82 } 83} 84 85static int tda18271_channel_configuration(struct dvb_frontend *fe, 86 struct tda18271_std_map_item *map, 87 u32 freq, u32 bw) 88{ 89 struct tda18271_priv *priv = fe->tuner_priv; 90 unsigned char *regs = priv->tda18271_regs; 91 int ret; 92 u32 N; 93 94 /* update TV broadcast parameters */ 95 96 /* set standard */ 97 regs[R_EP3] &= ~0x1f; /* clear std bits */ 98 regs[R_EP3] |= (map->agc_mode << 3) | map->std; 99 100 if (priv->id == TDA18271HDC2) { 101 /* set rfagc to high speed mode */ 102 regs[R_EP3] &= ~0x04; 103 } 104 105 /* set cal mode to normal */ 106 regs[R_EP4] &= ~0x03; 107 108 /* update IF output level */ 109 regs[R_EP4] &= ~0x1c; /* clear if level bits */ 110 regs[R_EP4] |= (map->if_lvl << 2); 111 112 /* update FM_RFn */ 113 regs[R_EP4] &= ~0x80; 114 regs[R_EP4] |= map->fm_rfn << 7; 115 116 /* update rf top / if top */ 117 regs[R_EB22] = 0x00; 118 regs[R_EB22] |= map->rfagc_top; 119 ret = tda18271_write_regs(fe, R_EB22, 1); 120 if (tda_fail(ret)) 121 goto fail; 122 123 /* --------------------------------------------------------------- */ 124 125 /* disable Power Level Indicator */ 126 regs[R_EP1] |= 0x40; 127 128 /* make sure thermometer is off */ 129 regs[R_TM] &= ~0x10; 130 131 /* frequency dependent parameters */ 132 133 tda18271_calc_ir_measure(fe, &freq); 134 135 tda18271_calc_bp_filter(fe, &freq); 136 137 tda18271_calc_rf_band(fe, &freq); 138 139 tda18271_calc_gain_taper(fe, &freq); 140 141 /* --------------------------------------------------------------- */ 142 143 /* dual tuner and agc1 extra configuration */ 144 145 switch (priv->role) { 146 case TDA18271_MASTER: 147 regs[R_EB1] |= 0x04; /* main vco */ 148 break; 149 case TDA18271_SLAVE: 150 regs[R_EB1] &= ~0x04; /* cal vco */ 151 break; 152 } 153 154 /* agc1 always active */ 155 regs[R_EB1] &= ~0x02; 156 157 /* agc1 has priority on agc2 */ 158 regs[R_EB1] &= ~0x01; 159 160 ret = tda18271_write_regs(fe, R_EB1, 1); 161 if (tda_fail(ret)) 162 goto fail; 163 164 /* --------------------------------------------------------------- */ 165 166 N = map->if_freq * 1000 + freq; 167 168 switch (priv->role) { 169 case TDA18271_MASTER: 170 tda18271_calc_main_pll(fe, N); 171 tda18271_set_if_notch(fe); 172 tda18271_write_regs(fe, R_MPD, 4); 173 break; 174 case TDA18271_SLAVE: 175 tda18271_calc_cal_pll(fe, N); 176 tda18271_write_regs(fe, R_CPD, 4); 177 178 regs[R_MPD] = regs[R_CPD] & 0x7f; 179 tda18271_set_if_notch(fe); 180 tda18271_write_regs(fe, R_MPD, 1); 181 break; 182 } 183 184 ret = tda18271_write_regs(fe, R_TM, 7); 185 if (tda_fail(ret)) 186 goto fail; 187 188 /* force charge pump source */ 189 charge_pump_source(fe, 1); 190 191 msleep(1); 192 193 /* return pll to normal operation */ 194 charge_pump_source(fe, 0); 195 196 msleep(20); 197 198 if (priv->id == TDA18271HDC2) { 199 /* set rfagc to normal speed mode */ 200 if (map->fm_rfn) 201 regs[R_EP3] &= ~0x04; 202 else 203 regs[R_EP3] |= 0x04; 204 ret = tda18271_write_regs(fe, R_EP3, 1); 205 } 206fail: 207 return ret; 208} 209 210static int tda18271_read_thermometer(struct dvb_frontend *fe) 211{ 212 struct tda18271_priv *priv = fe->tuner_priv; 213 unsigned char *regs = priv->tda18271_regs; 214 int tm; 215 216 /* switch thermometer on */ 217 regs[R_TM] |= 0x10; 218 tda18271_write_regs(fe, R_TM, 1); 219 220 /* read thermometer info */ 221 tda18271_read_regs(fe); 222 223 if ((((regs[R_TM] & 0x0f) == 0x00) && ((regs[R_TM] & 0x20) == 0x20)) || 224 (((regs[R_TM] & 0x0f) == 0x08) && ((regs[R_TM] & 0x20) == 0x00))) { 225 226 if ((regs[R_TM] & 0x20) == 0x20) 227 regs[R_TM] &= ~0x20; 228 else 229 regs[R_TM] |= 0x20; 230 231 tda18271_write_regs(fe, R_TM, 1); 232 233 msleep(10); /* temperature sensing */ 234 235 /* read thermometer info */ 236 tda18271_read_regs(fe); 237 } 238 239 tm = tda18271_lookup_thermometer(fe); 240 241 /* switch thermometer off */ 242 regs[R_TM] &= ~0x10; 243 tda18271_write_regs(fe, R_TM, 1); 244 245 /* set CAL mode to normal */ 246 regs[R_EP4] &= ~0x03; 247 tda18271_write_regs(fe, R_EP4, 1); 248 249 return tm; 250} 251 252/* ------------------------------------------------------------------ */ 253 254static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe, 255 u32 freq) 256{ 257 struct tda18271_priv *priv = fe->tuner_priv; 258 struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state; 259 unsigned char *regs = priv->tda18271_regs; 260 int i, ret; 261 u8 tm_current, dc_over_dt, rf_tab; 262 s32 rfcal_comp, approx; 263 264 /* power up */ 265 ret = tda18271_set_standby_mode(fe, 0, 0, 0); 266 if (tda_fail(ret)) 267 goto fail; 268 269 /* read die current temperature */ 270 tm_current = tda18271_read_thermometer(fe); 271 272 /* frequency dependent parameters */ 273 274 tda18271_calc_rf_cal(fe, &freq); 275 rf_tab = regs[R_EB14]; 276 277 i = tda18271_lookup_rf_band(fe, &freq, NULL); 278 if (tda_fail(i)) 279 return i; 280 281 if ((0 == map[i].rf3) || (freq / 1000 < map[i].rf2)) { 282 approx = map[i].rf_a1 * (s32)(freq / 1000 - map[i].rf1) + 283 map[i].rf_b1 + rf_tab; 284 } else { 285 approx = map[i].rf_a2 * (s32)(freq / 1000 - map[i].rf2) + 286 map[i].rf_b2 + rf_tab; 287 } 288 289 if (approx < 0) 290 approx = 0; 291 if (approx > 255) 292 approx = 255; 293 294 tda18271_lookup_map(fe, RF_CAL_DC_OVER_DT, &freq, &dc_over_dt); 295 296 /* calculate temperature compensation */ 297 rfcal_comp = dc_over_dt * (s32)(tm_current - priv->tm_rfcal) / 1000; 298 299 regs[R_EB14] = (unsigned char)(approx + rfcal_comp); 300 ret = tda18271_write_regs(fe, R_EB14, 1); 301fail: 302 return ret; 303} 304 305static int tda18271_por(struct dvb_frontend *fe) 306{ 307 struct tda18271_priv *priv = fe->tuner_priv; 308 unsigned char *regs = priv->tda18271_regs; 309 int ret; 310 311 /* power up detector 1 */ 312 regs[R_EB12] &= ~0x20; 313 ret = tda18271_write_regs(fe, R_EB12, 1); 314 if (tda_fail(ret)) 315 goto fail; 316 317 regs[R_EB18] &= ~0x80; /* turn agc1 loop on */ 318 regs[R_EB18] &= ~0x03; /* set agc1_gain to 6 dB */ 319 ret = tda18271_write_regs(fe, R_EB18, 1); 320 if (tda_fail(ret)) 321 goto fail; 322 323 regs[R_EB21] |= 0x03; /* set agc2_gain to -6 dB */ 324 325 /* POR mode */ 326 ret = tda18271_set_standby_mode(fe, 1, 0, 0); 327 if (tda_fail(ret)) 328 goto fail; 329 330 /* disable 1.5 MHz low pass filter */ 331 regs[R_EB23] &= ~0x04; /* forcelp_fc2_en = 0 */ 332 regs[R_EB23] &= ~0x02; /* XXX: lp_fc[2] = 0 */ 333 ret = tda18271_write_regs(fe, R_EB21, 3); 334fail: 335 return ret; 336} 337 338static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq) 339{ 340 struct tda18271_priv *priv = fe->tuner_priv; 341 unsigned char *regs = priv->tda18271_regs; 342 u32 N; 343 344 /* set CAL mode to normal */ 345 regs[R_EP4] &= ~0x03; 346 tda18271_write_regs(fe, R_EP4, 1); 347 348 /* switch off agc1 */ 349 regs[R_EP3] |= 0x40; /* sm_lt = 1 */ 350 351 regs[R_EB18] |= 0x03; /* set agc1_gain to 15 dB */ 352 tda18271_write_regs(fe, R_EB18, 1); 353 354 /* frequency dependent parameters */ 355 356 tda18271_calc_bp_filter(fe, &freq); 357 tda18271_calc_gain_taper(fe, &freq); 358 tda18271_calc_rf_band(fe, &freq); 359 tda18271_calc_km(fe, &freq); 360 361 tda18271_write_regs(fe, R_EP1, 3); 362 tda18271_write_regs(fe, R_EB13, 1); 363 364 /* main pll charge pump source */ 365 tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1); 366 367 /* cal pll charge pump source */ 368 tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 1); 369 370 /* force dcdc converter to 0 V */ 371 regs[R_EB14] = 0x00; 372 tda18271_write_regs(fe, R_EB14, 1); 373 374 /* disable plls lock */ 375 regs[R_EB20] &= ~0x20; 376 tda18271_write_regs(fe, R_EB20, 1); 377 378 /* set CAL mode to RF tracking filter calibration */ 379 regs[R_EP4] |= 0x03; 380 tda18271_write_regs(fe, R_EP4, 2); 381 382 /* --------------------------------------------------------------- */ 383 384 /* set the internal calibration signal */ 385 N = freq; 386 387 tda18271_calc_cal_pll(fe, N); 388 tda18271_write_regs(fe, R_CPD, 4); 389 390 /* downconvert internal calibration */ 391 N += 1000000; 392 393 tda18271_calc_main_pll(fe, N); 394 tda18271_write_regs(fe, R_MPD, 4); 395 396 msleep(5); 397 398 tda18271_write_regs(fe, R_EP2, 1); 399 tda18271_write_regs(fe, R_EP1, 1); 400 tda18271_write_regs(fe, R_EP2, 1); 401 tda18271_write_regs(fe, R_EP1, 1); 402 403 /* --------------------------------------------------------------- */ 404 405 /* normal operation for the main pll */ 406 tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0); 407 408 /* normal operation for the cal pll */ 409 tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 0); 410 411 msleep(10); /* plls locking */ 412 413 /* launch the rf tracking filters calibration */ 414 regs[R_EB20] |= 0x20; 415 tda18271_write_regs(fe, R_EB20, 1); 416 417 msleep(60); /* calibration */ 418 419 /* --------------------------------------------------------------- */ 420 421 /* set CAL mode to normal */ 422 regs[R_EP4] &= ~0x03; 423 424 /* switch on agc1 */ 425 regs[R_EP3] &= ~0x40; /* sm_lt = 0 */ 426 427 regs[R_EB18] &= ~0x03; /* set agc1_gain to 6 dB */ 428 tda18271_write_regs(fe, R_EB18, 1); 429 430 tda18271_write_regs(fe, R_EP3, 2); 431 432 /* synchronization */ 433 tda18271_write_regs(fe, R_EP1, 1); 434 435 /* get calibration result */ 436 tda18271_read_extended(fe); 437 438 return regs[R_EB14]; 439} 440 441static int tda18271_powerscan(struct dvb_frontend *fe, 442 u32 *freq_in, u32 *freq_out) 443{ 444 struct tda18271_priv *priv = fe->tuner_priv; 445 unsigned char *regs = priv->tda18271_regs; 446 int sgn, bcal, count, wait, ret; 447 u8 cid_target; 448 u16 count_limit; 449 u32 freq; 450 451 freq = *freq_in; 452 453 tda18271_calc_rf_band(fe, &freq); 454 tda18271_calc_rf_cal(fe, &freq); 455 tda18271_calc_gain_taper(fe, &freq); 456 tda18271_lookup_cid_target(fe, &freq, &cid_target, &count_limit); 457 458 tda18271_write_regs(fe, R_EP2, 1); 459 tda18271_write_regs(fe, R_EB14, 1); 460 461 /* downconvert frequency */ 462 freq += 1000000; 463 464 tda18271_calc_main_pll(fe, freq); 465 tda18271_write_regs(fe, R_MPD, 4); 466 467 msleep(5); /* pll locking */ 468 469 /* detection mode */ 470 regs[R_EP4] &= ~0x03; 471 regs[R_EP4] |= 0x01; 472 tda18271_write_regs(fe, R_EP4, 1); 473 474 /* launch power detection measurement */ 475 tda18271_write_regs(fe, R_EP2, 1); 476 477 /* read power detection info, stored in EB10 */ 478 ret = tda18271_read_extended(fe); 479 if (tda_fail(ret)) 480 return ret; 481 482 /* algorithm initialization */ 483 sgn = 1; 484 *freq_out = *freq_in; 485 bcal = 0; 486 count = 0; 487 wait = false; 488 489 while ((regs[R_EB10] & 0x3f) < cid_target) { 490 /* downconvert updated freq to 1 MHz */ 491 freq = *freq_in + (sgn * count) + 1000000; 492 493 tda18271_calc_main_pll(fe, freq); 494 tda18271_write_regs(fe, R_MPD, 4); 495 496 if (wait) { 497 msleep(5); /* pll locking */ 498 wait = false; 499 } else 500 udelay(100); /* pll locking */ 501 502 /* launch power detection measurement */ 503 tda18271_write_regs(fe, R_EP2, 1); 504 505 /* read power detection info, stored in EB10 */ 506 ret = tda18271_read_extended(fe); 507 if (tda_fail(ret)) 508 return ret; 509 510 count += 200; 511 512 if (count <= count_limit) 513 continue; 514 515 if (sgn <= 0) 516 break; 517 518 sgn = -1 * sgn; 519 count = 200; 520 wait = true; 521 } 522 523 if ((regs[R_EB10] & 0x3f) >= cid_target) { 524 bcal = 1; 525 *freq_out = freq - 1000000; 526 } else 527 bcal = 0; 528 529 tda_cal("bcal = %d, freq_in = %d, freq_out = %d (freq = %d)\n", 530 bcal, *freq_in, *freq_out, freq); 531 532 return bcal; 533} 534 535static int tda18271_powerscan_init(struct dvb_frontend *fe) 536{ 537 struct tda18271_priv *priv = fe->tuner_priv; 538 unsigned char *regs = priv->tda18271_regs; 539 int ret; 540 541 /* set standard to digital */ 542 regs[R_EP3] &= ~0x1f; /* clear std bits */ 543 regs[R_EP3] |= 0x12; 544 545 /* set cal mode to normal */ 546 regs[R_EP4] &= ~0x03; 547 548 /* update IF output level */ 549 regs[R_EP4] &= ~0x1c; /* clear if level bits */ 550 551 ret = tda18271_write_regs(fe, R_EP3, 2); 552 if (tda_fail(ret)) 553 goto fail; 554 555 regs[R_EB18] &= ~0x03; /* set agc1_gain to 6 dB */ 556 ret = tda18271_write_regs(fe, R_EB18, 1); 557 if (tda_fail(ret)) 558 goto fail; 559 560 regs[R_EB21] &= ~0x03; /* set agc2_gain to -15 dB */ 561 562 /* 1.5 MHz low pass filter */ 563 regs[R_EB23] |= 0x04; /* forcelp_fc2_en = 1 */ 564 regs[R_EB23] |= 0x02; /* lp_fc[2] = 1 */ 565 566 ret = tda18271_write_regs(fe, R_EB21, 3); 567fail: 568 return ret; 569} 570 571static int tda18271_rf_tracking_filters_init(struct dvb_frontend *fe, u32 freq) 572{ 573 struct tda18271_priv *priv = fe->tuner_priv; 574 struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state; 575 unsigned char *regs = priv->tda18271_regs; 576 int bcal, rf, i; 577 s32 divisor, dividend; 578#define RF1 0 579#define RF2 1 580#define RF3 2 581 u32 rf_default[3]; 582 u32 rf_freq[3]; 583 s32 prog_cal[3]; 584 s32 prog_tab[3]; 585 586 i = tda18271_lookup_rf_band(fe, &freq, NULL); 587 588 if (tda_fail(i)) 589 return i; 590 591 rf_default[RF1] = 1000 * map[i].rf1_def; 592 rf_default[RF2] = 1000 * map[i].rf2_def; 593 rf_default[RF3] = 1000 * map[i].rf3_def; 594 595 for (rf = RF1; rf <= RF3; rf++) { 596 if (0 == rf_default[rf]) 597 return 0; 598 tda_cal("freq = %d, rf = %d\n", freq, rf); 599 600 /* look for optimized calibration frequency */ 601 bcal = tda18271_powerscan(fe, &rf_default[rf], &rf_freq[rf]); 602 if (tda_fail(bcal)) 603 return bcal; 604 605 tda18271_calc_rf_cal(fe, &rf_freq[rf]); 606 prog_tab[rf] = (s32)regs[R_EB14]; 607 608 if (1 == bcal) 609 prog_cal[rf] = 610 (s32)tda18271_calibrate_rf(fe, rf_freq[rf]); 611 else 612 prog_cal[rf] = prog_tab[rf]; 613 614 switch (rf) { 615 case RF1: 616 map[i].rf_a1 = 0; 617 map[i].rf_b1 = (prog_cal[RF1] - prog_tab[RF1]); 618 map[i].rf1 = rf_freq[RF1] / 1000; 619 break; 620 case RF2: 621 dividend = (prog_cal[RF2] - prog_tab[RF2] - 622 prog_cal[RF1] + prog_tab[RF1]); 623 divisor = (s32)(rf_freq[RF2] - rf_freq[RF1]) / 1000; 624 map[i].rf_a1 = (dividend / divisor); 625 map[i].rf2 = rf_freq[RF2] / 1000; 626 break; 627 case RF3: 628 dividend = (prog_cal[RF3] - prog_tab[RF3] - 629 prog_cal[RF2] + prog_tab[RF2]); 630 divisor = (s32)(rf_freq[RF3] - rf_freq[RF2]) / 1000; 631 map[i].rf_a2 = (dividend / divisor); 632 map[i].rf_b2 = (prog_cal[RF2] - prog_tab[RF2]); 633 map[i].rf3 = rf_freq[RF3] / 1000; 634 break; 635 default: 636 BUG(); 637 } 638 } 639 640 return 0; 641} 642 643static int tda18271_calc_rf_filter_curve(struct dvb_frontend *fe) 644{ 645 struct tda18271_priv *priv = fe->tuner_priv; 646 unsigned int i; 647 int ret; 648 649 tda_info("tda18271: performing RF tracking filter calibration\n"); 650 651 /* wait for die temperature stabilization */ 652 msleep(200); 653 654 ret = tda18271_powerscan_init(fe); 655 if (tda_fail(ret)) 656 goto fail; 657 658 /* rf band calibration */ 659 for (i = 0; priv->rf_cal_state[i].rfmax != 0; i++) { 660 ret = 661 tda18271_rf_tracking_filters_init(fe, 1000 * 662 priv->rf_cal_state[i].rfmax); 663 if (tda_fail(ret)) 664 goto fail; 665 } 666 667 priv->tm_rfcal = tda18271_read_thermometer(fe); 668fail: 669 return ret; 670} 671 672/* ------------------------------------------------------------------ */ 673 674static int tda18271c2_rf_cal_init(struct dvb_frontend *fe) 675{ 676 struct tda18271_priv *priv = fe->tuner_priv; 677 unsigned char *regs = priv->tda18271_regs; 678 int ret; 679 680 /* test RF_CAL_OK to see if we need init */ 681 if ((regs[R_EP1] & 0x10) == 0) 682 priv->cal_initialized = false; 683 684 if (priv->cal_initialized) 685 return 0; 686 687 ret = tda18271_calc_rf_filter_curve(fe); 688 if (tda_fail(ret)) 689 goto fail; 690 691 ret = tda18271_por(fe); 692 if (tda_fail(ret)) 693 goto fail; 694 695 tda_info("tda18271: RF tracking filter calibration complete\n"); 696 697 priv->cal_initialized = true; 698 goto end; 699fail: 700 tda_info("tda18271: RF tracking filter calibration failed!\n"); 701end: 702 return ret; 703} 704 705static int tda18271c1_rf_tracking_filter_calibration(struct dvb_frontend *fe, 706 u32 freq, u32 bw) 707{ 708 struct tda18271_priv *priv = fe->tuner_priv; 709 unsigned char *regs = priv->tda18271_regs; 710 int ret; 711 u32 N = 0; 712 713 /* calculate bp filter */ 714 tda18271_calc_bp_filter(fe, &freq); 715 tda18271_write_regs(fe, R_EP1, 1); 716 717 regs[R_EB4] &= 0x07; 718 regs[R_EB4] |= 0x60; 719 tda18271_write_regs(fe, R_EB4, 1); 720 721 regs[R_EB7] = 0x60; 722 tda18271_write_regs(fe, R_EB7, 1); 723 724 regs[R_EB14] = 0x00; 725 tda18271_write_regs(fe, R_EB14, 1); 726 727 regs[R_EB20] = 0xcc; 728 tda18271_write_regs(fe, R_EB20, 1); 729 730 /* set cal mode to RF tracking filter calibration */ 731 regs[R_EP4] |= 0x03; 732 733 /* calculate cal pll */ 734 735 switch (priv->mode) { 736 case TDA18271_ANALOG: 737 N = freq - 1250000; 738 break; 739 case TDA18271_DIGITAL: 740 N = freq + bw / 2; 741 break; 742 } 743 744 tda18271_calc_cal_pll(fe, N); 745 746 /* calculate main pll */ 747 748 switch (priv->mode) { 749 case TDA18271_ANALOG: 750 N = freq - 250000; 751 break; 752 case TDA18271_DIGITAL: 753 N = freq + bw / 2 + 1000000; 754 break; 755 } 756 757 tda18271_calc_main_pll(fe, N); 758 759 ret = tda18271_write_regs(fe, R_EP3, 11); 760 if (tda_fail(ret)) 761 return ret; 762 763 msleep(5); /* RF tracking filter calibration initialization */ 764 765 /* search for K,M,CO for RF calibration */ 766 tda18271_calc_km(fe, &freq); 767 tda18271_write_regs(fe, R_EB13, 1); 768 769 /* search for rf band */ 770 tda18271_calc_rf_band(fe, &freq); 771 772 /* search for gain taper */ 773 tda18271_calc_gain_taper(fe, &freq); 774 775 tda18271_write_regs(fe, R_EP2, 1); 776 tda18271_write_regs(fe, R_EP1, 1); 777 tda18271_write_regs(fe, R_EP2, 1); 778 tda18271_write_regs(fe, R_EP1, 1); 779 780 regs[R_EB4] &= 0x07; 781 regs[R_EB4] |= 0x40; 782 tda18271_write_regs(fe, R_EB4, 1); 783 784 regs[R_EB7] = 0x40; 785 tda18271_write_regs(fe, R_EB7, 1); 786 msleep(10); /* pll locking */ 787 788 regs[R_EB20] = 0xec; 789 tda18271_write_regs(fe, R_EB20, 1); 790 msleep(60); /* RF tracking filter calibration completion */ 791 792 regs[R_EP4] &= ~0x03; /* set cal mode to normal */ 793 tda18271_write_regs(fe, R_EP4, 1); 794 795 tda18271_write_regs(fe, R_EP1, 1); 796 797 /* RF tracking filter correction for VHF_Low band */ 798 if (0 == tda18271_calc_rf_cal(fe, &freq)) 799 tda18271_write_regs(fe, R_EB14, 1); 800 801 return 0; 802} 803 804/* ------------------------------------------------------------------ */ 805 806static int tda18271_ir_cal_init(struct dvb_frontend *fe) 807{ 808 struct tda18271_priv *priv = fe->tuner_priv; 809 unsigned char *regs = priv->tda18271_regs; 810 int ret; 811 812 ret = tda18271_read_regs(fe); 813 if (tda_fail(ret)) 814 goto fail; 815 816 /* test IR_CAL_OK to see if we need init */ 817 if ((regs[R_EP1] & 0x08) == 0) 818 ret = tda18271_init_regs(fe); 819fail: 820 return ret; 821} 822 823static int tda18271_init(struct dvb_frontend *fe) 824{ 825 struct tda18271_priv *priv = fe->tuner_priv; 826 int ret; 827 828 mutex_lock(&priv->lock); 829 830 /* full power up */ 831 ret = tda18271_set_standby_mode(fe, 0, 0, 0); 832 if (tda_fail(ret)) 833 goto fail; 834 835 /* initialization */ 836 ret = tda18271_ir_cal_init(fe); 837 if (tda_fail(ret)) 838 goto fail; 839 840 if (priv->id == TDA18271HDC2) 841 tda18271c2_rf_cal_init(fe); 842fail: 843 mutex_unlock(&priv->lock); 844 845 return ret; 846} 847 848static int tda18271_sleep(struct dvb_frontend *fe) 849{ 850 struct tda18271_priv *priv = fe->tuner_priv; 851 int ret; 852 853 mutex_lock(&priv->lock); 854 855 /* enter standby mode, with required output features enabled */ 856 ret = tda18271_toggle_output(fe, 1); 857 858 mutex_unlock(&priv->lock); 859 860 return ret; 861} 862 863/* ------------------------------------------------------------------ */ 864 865static int tda18271_agc(struct dvb_frontend *fe) 866{ 867 struct tda18271_priv *priv = fe->tuner_priv; 868 int ret = 0; 869 870 switch (priv->config) { 871 case TDA8290_LNA_OFF: 872 /* no external agc configuration required */ 873 if (tda18271_debug & DBG_ADV) 874 tda_dbg("no agc configuration provided\n"); 875 break; 876 case TDA8290_LNA_ON_BRIDGE: 877 /* switch with GPIO of saa713x */ 878 tda_dbg("invoking callback\n"); 879 if (fe->callback) 880 ret = fe->callback(priv->i2c_props.adap->algo_data, 881 DVB_FRONTEND_COMPONENT_TUNER, 882 TDA18271_CALLBACK_CMD_AGC_ENABLE, 883 priv->mode); 884 break; 885 case TDA8290_LNA_GP0_HIGH_ON: 886 case TDA8290_LNA_GP0_HIGH_OFF: 887 default: 888 /* n/a - currently not supported */ 889 tda_err("unsupported configuration: %d\n", priv->config); 890 ret = -EINVAL; 891 break; 892 } 893 return ret; 894} 895 896static int tda18271_tune(struct dvb_frontend *fe, 897 struct tda18271_std_map_item *map, u32 freq, u32 bw) 898{ 899 struct tda18271_priv *priv = fe->tuner_priv; 900 int ret; 901 902 tda_dbg("freq = %d, ifc = %d, bw = %d, agc_mode = %d, std = %d\n", 903 freq, map->if_freq, bw, map->agc_mode, map->std); 904 905 ret = tda18271_agc(fe); 906 if (tda_fail(ret)) 907 tda_warn("failed to configure agc\n"); 908 909 ret = tda18271_init(fe); 910 if (tda_fail(ret)) 911 goto fail; 912 913 mutex_lock(&priv->lock); 914 915 switch (priv->id) { 916 case TDA18271HDC1: 917 tda18271c1_rf_tracking_filter_calibration(fe, freq, bw); 918 break; 919 case TDA18271HDC2: 920 tda18271c2_rf_tracking_filters_correction(fe, freq); 921 break; 922 } 923 ret = tda18271_channel_configuration(fe, map, freq, bw); 924 925 mutex_unlock(&priv->lock); 926fail: 927 return ret; 928} 929 930/* ------------------------------------------------------------------ */ 931 932static int tda18271_set_params(struct dvb_frontend *fe) 933{ 934 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 935 u32 delsys = c->delivery_system; 936 u32 bw = c->bandwidth_hz; 937 u32 freq = c->frequency; 938 struct tda18271_priv *priv = fe->tuner_priv; 939 struct tda18271_std_map *std_map = &priv->std; 940 struct tda18271_std_map_item *map; 941 int ret; 942 943 priv->mode = TDA18271_DIGITAL; 944 945 switch (delsys) { 946 case SYS_ATSC: 947 map = &std_map->atsc_6; 948 bw = 6000000; 949 break; 950 case SYS_ISDBT: 951 case SYS_DVBT: 952 case SYS_DVBT2: 953 if (bw <= 6000000) { 954 map = &std_map->dvbt_6; 955 } else if (bw <= 7000000) { 956 map = &std_map->dvbt_7; 957 } else { 958 map = &std_map->dvbt_8; 959 } 960 break; 961 case SYS_DVBC_ANNEX_B: 962 bw = 6000000; 963 /* falltrough */ 964 case SYS_DVBC_ANNEX_A: 965 case SYS_DVBC_ANNEX_C: 966 if (bw <= 6000000) { 967 map = &std_map->qam_6; 968 } else if (bw <= 7000000) { 969 map = &std_map->qam_7; 970 } else { 971 map = &std_map->qam_8; 972 } 973 break; 974 default: 975 tda_warn("modulation type not supported!\n"); 976 return -EINVAL; 977 } 978 979 /* When tuning digital, the analog demod must be tri-stated */ 980 if (fe->ops.analog_ops.standby) 981 fe->ops.analog_ops.standby(fe); 982 983 ret = tda18271_tune(fe, map, freq, bw); 984 985 if (tda_fail(ret)) 986 goto fail; 987 988 priv->if_freq = map->if_freq; 989 priv->frequency = freq; 990 priv->bandwidth = bw; 991fail: 992 return ret; 993} 994 995static int tda18271_set_analog_params(struct dvb_frontend *fe, 996 struct analog_parameters *params) 997{ 998 struct tda18271_priv *priv = fe->tuner_priv; 999 struct tda18271_std_map *std_map = &priv->std; 1000 struct tda18271_std_map_item *map; 1001 char *mode; 1002 int ret; 1003 u32 freq = params->frequency * 125 * 1004 ((params->mode == V4L2_TUNER_RADIO) ? 1 : 1000) / 2; 1005 1006 priv->mode = TDA18271_ANALOG; 1007 1008 if (params->mode == V4L2_TUNER_RADIO) { 1009 map = &std_map->fm_radio; 1010 mode = "fm"; 1011 } else if (params->std & V4L2_STD_MN) { 1012 map = &std_map->atv_mn; 1013 mode = "MN"; 1014 } else if (params->std & V4L2_STD_B) { 1015 map = &std_map->atv_b; 1016 mode = "B"; 1017 } else if (params->std & V4L2_STD_GH) { 1018 map = &std_map->atv_gh; 1019 mode = "GH"; 1020 } else if (params->std & V4L2_STD_PAL_I) { 1021 map = &std_map->atv_i; 1022 mode = "I"; 1023 } else if (params->std & V4L2_STD_DK) { 1024 map = &std_map->atv_dk; 1025 mode = "DK"; 1026 } else if (params->std & V4L2_STD_SECAM_L) { 1027 map = &std_map->atv_l; 1028 mode = "L"; 1029 } else if (params->std & V4L2_STD_SECAM_LC) { 1030 map = &std_map->atv_lc; 1031 mode = "L'"; 1032 } else { 1033 map = &std_map->atv_i; 1034 mode = "xx"; 1035 } 1036 1037 tda_dbg("setting tda18271 to system %s\n", mode); 1038 1039 ret = tda18271_tune(fe, map, freq, 0); 1040 1041 if (tda_fail(ret)) 1042 goto fail; 1043 1044 priv->if_freq = map->if_freq; 1045 priv->frequency = freq; 1046 priv->bandwidth = 0; 1047fail: 1048 return ret; 1049} 1050 1051static int tda18271_release(struct dvb_frontend *fe) 1052{ 1053 struct tda18271_priv *priv = fe->tuner_priv; 1054 1055 mutex_lock(&tda18271_list_mutex); 1056 1057 if (priv) 1058 hybrid_tuner_release_state(priv); 1059 1060 mutex_unlock(&tda18271_list_mutex); 1061 1062 fe->tuner_priv = NULL; 1063 1064 return 0; 1065} 1066 1067static int tda18271_get_frequency(struct dvb_frontend *fe, u32 *frequency) 1068{ 1069 struct tda18271_priv *priv = fe->tuner_priv; 1070 *frequency = priv->frequency; 1071 return 0; 1072} 1073 1074static int tda18271_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) 1075{ 1076 struct tda18271_priv *priv = fe->tuner_priv; 1077 *bandwidth = priv->bandwidth; 1078 return 0; 1079} 1080 1081static int tda18271_get_if_frequency(struct dvb_frontend *fe, u32 *frequency) 1082{ 1083 struct tda18271_priv *priv = fe->tuner_priv; 1084 *frequency = (u32)priv->if_freq * 1000; 1085 return 0; 1086} 1087 1088/* ------------------------------------------------------------------ */ 1089 1090#define tda18271_update_std(std_cfg, name) do { \ 1091 if (map->std_cfg.if_freq + \ 1092 map->std_cfg.agc_mode + map->std_cfg.std + \ 1093 map->std_cfg.if_lvl + map->std_cfg.rfagc_top > 0) { \ 1094 tda_dbg("Using custom std config for %s\n", name); \ 1095 memcpy(&std->std_cfg, &map->std_cfg, \ 1096 sizeof(struct tda18271_std_map_item)); \ 1097 } } while (0) 1098 1099#define tda18271_dump_std_item(std_cfg, name) do { \ 1100 tda_dbg("(%s) if_freq = %d, agc_mode = %d, std = %d, " \ 1101 "if_lvl = %d, rfagc_top = 0x%02x\n", \ 1102 name, std->std_cfg.if_freq, \ 1103 std->std_cfg.agc_mode, std->std_cfg.std, \ 1104 std->std_cfg.if_lvl, std->std_cfg.rfagc_top); \ 1105 } while (0) 1106 1107static int tda18271_dump_std_map(struct dvb_frontend *fe) 1108{ 1109 struct tda18271_priv *priv = fe->tuner_priv; 1110 struct tda18271_std_map *std = &priv->std; 1111 1112 tda_dbg("========== STANDARD MAP SETTINGS ==========\n"); 1113 tda18271_dump_std_item(fm_radio, " fm "); 1114 tda18271_dump_std_item(atv_b, "atv b "); 1115 tda18271_dump_std_item(atv_dk, "atv dk"); 1116 tda18271_dump_std_item(atv_gh, "atv gh"); 1117 tda18271_dump_std_item(atv_i, "atv i "); 1118 tda18271_dump_std_item(atv_l, "atv l "); 1119 tda18271_dump_std_item(atv_lc, "atv l'"); 1120 tda18271_dump_std_item(atv_mn, "atv mn"); 1121 tda18271_dump_std_item(atsc_6, "atsc 6"); 1122 tda18271_dump_std_item(dvbt_6, "dvbt 6"); 1123 tda18271_dump_std_item(dvbt_7, "dvbt 7"); 1124 tda18271_dump_std_item(dvbt_8, "dvbt 8"); 1125 tda18271_dump_std_item(qam_6, "qam 6 "); 1126 tda18271_dump_std_item(qam_7, "qam 7 "); 1127 tda18271_dump_std_item(qam_8, "qam 8 "); 1128 1129 return 0; 1130} 1131 1132static int tda18271_update_std_map(struct dvb_frontend *fe, 1133 struct tda18271_std_map *map) 1134{ 1135 struct tda18271_priv *priv = fe->tuner_priv; 1136 struct tda18271_std_map *std = &priv->std; 1137 1138 if (!map) 1139 return -EINVAL; 1140 1141 tda18271_update_std(fm_radio, "fm"); 1142 tda18271_update_std(atv_b, "atv b"); 1143 tda18271_update_std(atv_dk, "atv dk"); 1144 tda18271_update_std(atv_gh, "atv gh"); 1145 tda18271_update_std(atv_i, "atv i"); 1146 tda18271_update_std(atv_l, "atv l"); 1147 tda18271_update_std(atv_lc, "atv l'"); 1148 tda18271_update_std(atv_mn, "atv mn"); 1149 tda18271_update_std(atsc_6, "atsc 6"); 1150 tda18271_update_std(dvbt_6, "dvbt 6"); 1151 tda18271_update_std(dvbt_7, "dvbt 7"); 1152 tda18271_update_std(dvbt_8, "dvbt 8"); 1153 tda18271_update_std(qam_6, "qam 6"); 1154 tda18271_update_std(qam_7, "qam 7"); 1155 tda18271_update_std(qam_8, "qam 8"); 1156 1157 return 0; 1158} 1159 1160static int tda18271_get_id(struct dvb_frontend *fe) 1161{ 1162 struct tda18271_priv *priv = fe->tuner_priv; 1163 unsigned char *regs = priv->tda18271_regs; 1164 char *name; 1165 int ret; 1166 1167 mutex_lock(&priv->lock); 1168 ret = tda18271_read_regs(fe); 1169 mutex_unlock(&priv->lock); 1170 1171 if (ret) { 1172 tda_info("Error reading device ID @ %d-%04x, bailing out.\n", 1173 i2c_adapter_id(priv->i2c_props.adap), 1174 priv->i2c_props.addr); 1175 return -EIO; 1176 } 1177 1178 switch (regs[R_ID] & 0x7f) { 1179 case 3: 1180 name = "TDA18271HD/C1"; 1181 priv->id = TDA18271HDC1; 1182 break; 1183 case 4: 1184 name = "TDA18271HD/C2"; 1185 priv->id = TDA18271HDC2; 1186 break; 1187 default: 1188 tda_info("Unknown device (%i) detected @ %d-%04x, device not supported.\n", 1189 regs[R_ID], i2c_adapter_id(priv->i2c_props.adap), 1190 priv->i2c_props.addr); 1191 return -EINVAL; 1192 } 1193 1194 tda_info("%s detected @ %d-%04x\n", name, 1195 i2c_adapter_id(priv->i2c_props.adap), priv->i2c_props.addr); 1196 1197 return 0; 1198} 1199 1200static int tda18271_setup_configuration(struct dvb_frontend *fe, 1201 struct tda18271_config *cfg) 1202{ 1203 struct tda18271_priv *priv = fe->tuner_priv; 1204 1205 priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO; 1206 priv->role = (cfg) ? cfg->role : TDA18271_MASTER; 1207 priv->config = (cfg) ? cfg->config : 0; 1208 priv->small_i2c = (cfg) ? 1209 cfg->small_i2c : TDA18271_39_BYTE_CHUNK_INIT; 1210 priv->output_opt = (cfg) ? 1211 cfg->output_opt : TDA18271_OUTPUT_LT_XT_ON; 1212 1213 return 0; 1214} 1215 1216static inline int tda18271_need_cal_on_startup(struct tda18271_config *cfg) 1217{ 1218 /* tda18271_cal_on_startup == -1 when cal module option is unset */ 1219 return ((tda18271_cal_on_startup == -1) ? 1220 /* honor configuration setting */ 1221 ((cfg) && (cfg->rf_cal_on_startup)) : 1222 /* module option overrides configuration setting */ 1223 (tda18271_cal_on_startup)) ? 1 : 0; 1224} 1225 1226static int tda18271_set_config(struct dvb_frontend *fe, void *priv_cfg) 1227{ 1228 struct tda18271_config *cfg = (struct tda18271_config *) priv_cfg; 1229 1230 tda18271_setup_configuration(fe, cfg); 1231 1232 if (tda18271_need_cal_on_startup(cfg)) 1233 tda18271_init(fe); 1234 1235 /* override default std map with values in config struct */ 1236 if ((cfg) && (cfg->std_map)) 1237 tda18271_update_std_map(fe, cfg->std_map); 1238 1239 return 0; 1240} 1241 1242static const struct dvb_tuner_ops tda18271_tuner_ops = { 1243 .info = { 1244 .name = "NXP TDA18271HD", 1245 .frequency_min = 45000000, 1246 .frequency_max = 864000000, 1247 .frequency_step = 62500 1248 }, 1249 .init = tda18271_init, 1250 .sleep = tda18271_sleep, 1251 .set_params = tda18271_set_params, 1252 .set_analog_params = tda18271_set_analog_params, 1253 .release = tda18271_release, 1254 .set_config = tda18271_set_config, 1255 .get_frequency = tda18271_get_frequency, 1256 .get_bandwidth = tda18271_get_bandwidth, 1257 .get_if_frequency = tda18271_get_if_frequency, 1258}; 1259 1260struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr, 1261 struct i2c_adapter *i2c, 1262 struct tda18271_config *cfg) 1263{ 1264 struct tda18271_priv *priv = NULL; 1265 int instance, ret; 1266 1267 mutex_lock(&tda18271_list_mutex); 1268 1269 instance = hybrid_tuner_request_state(struct tda18271_priv, priv, 1270 hybrid_tuner_instance_list, 1271 i2c, addr, "tda18271"); 1272 switch (instance) { 1273 case 0: 1274 goto fail; 1275 case 1: 1276 /* new tuner instance */ 1277 fe->tuner_priv = priv; 1278 1279 tda18271_setup_configuration(fe, cfg); 1280 1281 priv->cal_initialized = false; 1282 mutex_init(&priv->lock); 1283 1284 ret = tda18271_get_id(fe); 1285 if (tda_fail(ret)) 1286 goto fail; 1287 1288 ret = tda18271_assign_map_layout(fe); 1289 if (tda_fail(ret)) 1290 goto fail; 1291 1292 /* if delay_cal is set, delay IR & RF calibration until init() 1293 * module option 'cal' overrides this delay */ 1294 if ((cfg->delay_cal) && (!tda18271_need_cal_on_startup(cfg))) 1295 break; 1296 1297 mutex_lock(&priv->lock); 1298 tda18271_init_regs(fe); 1299 1300 if ((tda18271_need_cal_on_startup(cfg)) && 1301 (priv->id == TDA18271HDC2)) 1302 tda18271c2_rf_cal_init(fe); 1303 1304 /* enter standby mode, with required output features enabled */ 1305 ret = tda18271_toggle_output(fe, 1); 1306 tda_fail(ret); 1307 1308 mutex_unlock(&priv->lock); 1309 break; 1310 default: 1311 /* existing tuner instance */ 1312 fe->tuner_priv = priv; 1313 1314 /* allow dvb driver to override configuration settings */ 1315 if (cfg) { 1316 if (cfg->gate != TDA18271_GATE_ANALOG) 1317 priv->gate = cfg->gate; 1318 if (cfg->role) 1319 priv->role = cfg->role; 1320 if (cfg->config) 1321 priv->config = cfg->config; 1322 if (cfg->small_i2c) 1323 priv->small_i2c = cfg->small_i2c; 1324 if (cfg->output_opt) 1325 priv->output_opt = cfg->output_opt; 1326 if (cfg->std_map) 1327 tda18271_update_std_map(fe, cfg->std_map); 1328 } 1329 if (tda18271_need_cal_on_startup(cfg)) 1330 tda18271_init(fe); 1331 break; 1332 } 1333 1334 /* override default std map with values in config struct */ 1335 if ((cfg) && (cfg->std_map)) 1336 tda18271_update_std_map(fe, cfg->std_map); 1337 1338 mutex_unlock(&tda18271_list_mutex); 1339 1340 memcpy(&fe->ops.tuner_ops, &tda18271_tuner_ops, 1341 sizeof(struct dvb_tuner_ops)); 1342 1343 if (tda18271_debug & (DBG_MAP | DBG_ADV)) 1344 tda18271_dump_std_map(fe); 1345 1346 return fe; 1347fail: 1348 mutex_unlock(&tda18271_list_mutex); 1349 1350 tda18271_release(fe); 1351 return NULL; 1352} 1353EXPORT_SYMBOL_GPL(tda18271_attach); 1354MODULE_DESCRIPTION("NXP TDA18271HD analog / digital tuner driver"); 1355MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>"); 1356MODULE_LICENSE("GPL"); 1357MODULE_VERSION("0.4"); 1358 1359/* 1360 * Overrides for Emacs so that we follow Linus's tabbing style. 1361 * --------------------------------------------------------------------------- 1362 * Local variables: 1363 * c-basic-offset: 8 1364 * End: 1365 */ 1366