1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tda18271c2dd: Driver for the TDA18271C2 tuner 4 * 5 * Copyright (C) 2010 Digital Devices GmbH 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/init.h> 11 #include <linux/delay.h> 12 #include <linux/firmware.h> 13 #include <linux/i2c.h> 14 #include <asm/div64.h> 15 16 #include <media/dvb_frontend.h> 17 #include "tda18271c2dd.h" 18 19 /* Max transfer size done by I2C transfer functions */ 20 #define MAX_XFER_SIZE 64 21 22 struct SStandardParam { 23 s32 m_IFFrequency; 24 u32 m_BandWidth; 25 u8 m_EP3_4_0; 26 u8 m_EB22; 27 }; 28 29 struct SMap { 30 u32 m_Frequency; 31 u8 m_Param; 32 }; 33 34 struct SMapI { 35 u32 m_Frequency; 36 s32 m_Param; 37 }; 38 39 struct SMap2 { 40 u32 m_Frequency; 41 u8 m_Param1; 42 u8 m_Param2; 43 }; 44 45 struct SRFBandMap { 46 u32 m_RF_max; 47 u32 m_RF1_Default; 48 u32 m_RF2_Default; 49 u32 m_RF3_Default; 50 }; 51 52 enum ERegister { 53 ID = 0, 54 TM, 55 PL, 56 EP1, EP2, EP3, EP4, EP5, 57 CPD, CD1, CD2, CD3, 58 MPD, MD1, MD2, MD3, 59 EB1, EB2, EB3, EB4, EB5, EB6, EB7, EB8, EB9, EB10, 60 EB11, EB12, EB13, EB14, EB15, EB16, EB17, EB18, EB19, EB20, 61 EB21, EB22, EB23, 62 NUM_REGS 63 }; 64 65 struct tda_state { 66 struct i2c_adapter *i2c; 67 u8 adr; 68 69 u32 m_Frequency; 70 u32 IF; 71 72 u8 m_IFLevelAnalog; 73 u8 m_IFLevelDigital; 74 u8 m_IFLevelDVBC; 75 u8 m_IFLevelDVBT; 76 77 u8 m_EP4; 78 u8 m_EP3_Standby; 79 80 bool m_bMaster; 81 82 s32 m_SettlingTime; 83 84 u8 m_Regs[NUM_REGS]; 85 86 /* Tracking filter settings for band 0..6 */ 87 u32 m_RF1[7]; 88 s32 m_RF_A1[7]; 89 s32 m_RF_B1[7]; 90 u32 m_RF2[7]; 91 s32 m_RF_A2[7]; 92 s32 m_RF_B2[7]; 93 u32 m_RF3[7]; 94 95 u8 m_TMValue_RFCal; /* Calibration temperature */ 96 97 bool m_bFMInput; /* true to use Pin 8 for FM Radio */ 98 99 }; 100 101 static int PowerScan(struct tda_state *state, 102 u8 RFBand, u32 RF_in, 103 u32 *pRF_Out, bool *pbcal); 104 105 static int i2c_readn(struct i2c_adapter *adapter, u8 adr, u8 *data, int len) 106 { 107 struct i2c_msg msgs[1] = {{.addr = adr, .flags = I2C_M_RD, 108 .buf = data, .len = len} }; 109 return (i2c_transfer(adapter, msgs, 1) == 1) ? 0 : -1; 110 } 111 112 static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len) 113 { 114 struct i2c_msg msg = {.addr = adr, .flags = 0, 115 .buf = data, .len = len}; 116 117 if (i2c_transfer(adap, &msg, 1) != 1) { 118 printk(KERN_ERR "tda18271c2dd: i2c write error at addr %i\n", adr); 119 return -1; 120 } 121 return 0; 122 } 123 124 static int WriteRegs(struct tda_state *state, 125 u8 SubAddr, u8 *Regs, u16 nRegs) 126 { 127 u8 data[MAX_XFER_SIZE]; 128 129 if (1 + nRegs > sizeof(data)) { 130 printk(KERN_WARNING 131 "%s: i2c wr: len=%d is too big!\n", 132 KBUILD_MODNAME, nRegs); 133 return -EINVAL; 134 } 135 136 data[0] = SubAddr; 137 memcpy(data + 1, Regs, nRegs); 138 return i2c_write(state->i2c, state->adr, data, nRegs + 1); 139 } 140 141 static int WriteReg(struct tda_state *state, u8 SubAddr, u8 Reg) 142 { 143 u8 msg[2] = {SubAddr, Reg}; 144 145 return i2c_write(state->i2c, state->adr, msg, 2); 146 } 147 148 static int Read(struct tda_state *state, u8 * Regs) 149 { 150 return i2c_readn(state->i2c, state->adr, Regs, 16); 151 } 152 153 static int ReadExtented(struct tda_state *state, u8 * Regs) 154 { 155 return i2c_readn(state->i2c, state->adr, Regs, NUM_REGS); 156 } 157 158 static int UpdateRegs(struct tda_state *state, u8 RegFrom, u8 RegTo) 159 { 160 return WriteRegs(state, RegFrom, 161 &state->m_Regs[RegFrom], RegTo-RegFrom+1); 162 } 163 static int UpdateReg(struct tda_state *state, u8 Reg) 164 { 165 return WriteReg(state, Reg, state->m_Regs[Reg]); 166 } 167 168 #include "tda18271c2dd_maps.h" 169 170 static void reset(struct tda_state *state) 171 { 172 u32 ulIFLevelAnalog = 0; 173 u32 ulIFLevelDigital = 2; 174 u32 ulIFLevelDVBC = 7; 175 u32 ulIFLevelDVBT = 6; 176 u32 ulXTOut = 0; 177 u32 ulStandbyMode = 0x06; /* Send in stdb, but leave osc on */ 178 u32 ulSlave = 0; 179 u32 ulFMInput = 0; 180 u32 ulSettlingTime = 100; 181 182 state->m_Frequency = 0; 183 state->m_SettlingTime = 100; 184 state->m_IFLevelAnalog = (ulIFLevelAnalog & 0x07) << 2; 185 state->m_IFLevelDigital = (ulIFLevelDigital & 0x07) << 2; 186 state->m_IFLevelDVBC = (ulIFLevelDVBC & 0x07) << 2; 187 state->m_IFLevelDVBT = (ulIFLevelDVBT & 0x07) << 2; 188 189 state->m_EP4 = 0x20; 190 if (ulXTOut != 0) 191 state->m_EP4 |= 0x40; 192 193 state->m_EP3_Standby = ((ulStandbyMode & 0x07) << 5) | 0x0F; 194 state->m_bMaster = (ulSlave == 0); 195 196 state->m_SettlingTime = ulSettlingTime; 197 198 state->m_bFMInput = (ulFMInput == 2); 199 } 200 201 static bool SearchMap1(const struct SMap map[], u32 frequency, u8 *param) 202 { 203 int i = 0; 204 205 while ((map[i].m_Frequency != 0) && (frequency > map[i].m_Frequency)) 206 i += 1; 207 if (map[i].m_Frequency == 0) 208 return false; 209 *param = map[i].m_Param; 210 return true; 211 } 212 213 static bool SearchMap2(const struct SMapI map[], u32 frequency, s32 *param) 214 { 215 int i = 0; 216 217 while ((map[i].m_Frequency != 0) && 218 (frequency > map[i].m_Frequency)) 219 i += 1; 220 if (map[i].m_Frequency == 0) 221 return false; 222 *param = map[i].m_Param; 223 return true; 224 } 225 226 static bool SearchMap3(const struct SMap2 map[], u32 frequency, u8 *param1, 227 u8 *param2) 228 { 229 int i = 0; 230 231 while ((map[i].m_Frequency != 0) && 232 (frequency > map[i].m_Frequency)) 233 i += 1; 234 if (map[i].m_Frequency == 0) 235 return false; 236 *param1 = map[i].m_Param1; 237 *param2 = map[i].m_Param2; 238 return true; 239 } 240 241 static bool SearchMap4(const struct SRFBandMap map[], u32 frequency, u8 *rfband) 242 { 243 int i = 0; 244 245 while (i < 7 && (frequency > map[i].m_RF_max)) 246 i += 1; 247 if (i == 7) 248 return false; 249 *rfband = i; 250 return true; 251 } 252 253 static int ThermometerRead(struct tda_state *state, u8 *pTM_Value) 254 { 255 int status = 0; 256 257 do { 258 u8 Regs[16]; 259 state->m_Regs[TM] |= 0x10; 260 status = UpdateReg(state, TM); 261 if (status < 0) 262 break; 263 status = Read(state, Regs); 264 if (status < 0) 265 break; 266 if (((Regs[TM] & 0x0F) == 0 && (Regs[TM] & 0x20) == 0x20) || 267 ((Regs[TM] & 0x0F) == 8 && (Regs[TM] & 0x20) == 0x00)) { 268 state->m_Regs[TM] ^= 0x20; 269 status = UpdateReg(state, TM); 270 if (status < 0) 271 break; 272 msleep(10); 273 status = Read(state, Regs); 274 if (status < 0) 275 break; 276 } 277 *pTM_Value = (Regs[TM] & 0x20) 278 ? m_Thermometer_Map_2[Regs[TM] & 0x0F] 279 : m_Thermometer_Map_1[Regs[TM] & 0x0F] ; 280 state->m_Regs[TM] &= ~0x10; /* Thermometer off */ 281 status = UpdateReg(state, TM); 282 if (status < 0) 283 break; 284 state->m_Regs[EP4] &= ~0x03; /* CAL_mode = 0 ????????? */ 285 status = UpdateReg(state, EP4); 286 if (status < 0) 287 break; 288 } while (0); 289 290 return status; 291 } 292 293 static int StandBy(struct tda_state *state) 294 { 295 int status = 0; 296 do { 297 state->m_Regs[EB12] &= ~0x20; /* PD_AGC1_Det = 0 */ 298 status = UpdateReg(state, EB12); 299 if (status < 0) 300 break; 301 state->m_Regs[EB18] &= ~0x83; /* AGC1_loop_off = 0, AGC1_Gain = 6 dB */ 302 status = UpdateReg(state, EB18); 303 if (status < 0) 304 break; 305 state->m_Regs[EB21] |= 0x03; /* AGC2_Gain = -6 dB */ 306 state->m_Regs[EP3] = state->m_EP3_Standby; 307 status = UpdateReg(state, EP3); 308 if (status < 0) 309 break; 310 state->m_Regs[EB23] &= ~0x06; /* ForceLP_Fc2_En = 0, LP_Fc[2] = 0 */ 311 status = UpdateRegs(state, EB21, EB23); 312 if (status < 0) 313 break; 314 } while (0); 315 return status; 316 } 317 318 static int CalcMainPLL(struct tda_state *state, u32 freq) 319 { 320 321 u8 PostDiv; 322 u8 Div; 323 u64 OscFreq; 324 u32 MainDiv; 325 326 if (!SearchMap3(m_Main_PLL_Map, freq, &PostDiv, &Div)) 327 return -EINVAL; 328 329 OscFreq = (u64) freq * (u64) Div; 330 OscFreq *= (u64) 16384; 331 do_div(OscFreq, (u64)16000000); 332 MainDiv = OscFreq; 333 334 state->m_Regs[MPD] = PostDiv & 0x77; 335 state->m_Regs[MD1] = ((MainDiv >> 16) & 0x7F); 336 state->m_Regs[MD2] = ((MainDiv >> 8) & 0xFF); 337 state->m_Regs[MD3] = (MainDiv & 0xFF); 338 339 return UpdateRegs(state, MPD, MD3); 340 } 341 342 static int CalcCalPLL(struct tda_state *state, u32 freq) 343 { 344 u8 PostDiv; 345 u8 Div; 346 u64 OscFreq; 347 u32 CalDiv; 348 349 if (!SearchMap3(m_Cal_PLL_Map, freq, &PostDiv, &Div)) 350 return -EINVAL; 351 352 OscFreq = (u64)freq * (u64)Div; 353 /* CalDiv = u32( OscFreq * 16384 / 16000000 ); */ 354 OscFreq *= (u64)16384; 355 do_div(OscFreq, (u64)16000000); 356 CalDiv = OscFreq; 357 358 state->m_Regs[CPD] = PostDiv; 359 state->m_Regs[CD1] = ((CalDiv >> 16) & 0xFF); 360 state->m_Regs[CD2] = ((CalDiv >> 8) & 0xFF); 361 state->m_Regs[CD3] = (CalDiv & 0xFF); 362 363 return UpdateRegs(state, CPD, CD3); 364 } 365 366 static int CalibrateRF(struct tda_state *state, 367 u8 RFBand, u32 freq, s32 *pCprog) 368 { 369 int status = 0; 370 u8 Regs[NUM_REGS]; 371 do { 372 u8 BP_Filter = 0; 373 u8 GainTaper = 0; 374 u8 RFC_K = 0; 375 u8 RFC_M = 0; 376 377 state->m_Regs[EP4] &= ~0x03; /* CAL_mode = 0 */ 378 status = UpdateReg(state, EP4); 379 if (status < 0) 380 break; 381 state->m_Regs[EB18] |= 0x03; /* AGC1_Gain = 3 */ 382 status = UpdateReg(state, EB18); 383 if (status < 0) 384 break; 385 386 /* Switching off LT (as datasheet says) causes calibration on C1 to fail */ 387 /* (Readout of Cprog is always 255) */ 388 if (state->m_Regs[ID] != 0x83) /* C1: ID == 83, C2: ID == 84 */ 389 state->m_Regs[EP3] |= 0x40; /* SM_LT = 1 */ 390 391 if (!(SearchMap1(m_BP_Filter_Map, freq, &BP_Filter) && 392 SearchMap1(m_GainTaper_Map, freq, &GainTaper) && 393 SearchMap3(m_KM_Map, freq, &RFC_K, &RFC_M))) 394 return -EINVAL; 395 396 state->m_Regs[EP1] = (state->m_Regs[EP1] & ~0x07) | BP_Filter; 397 state->m_Regs[EP2] = (RFBand << 5) | GainTaper; 398 399 state->m_Regs[EB13] = (state->m_Regs[EB13] & ~0x7C) | (RFC_K << 4) | (RFC_M << 2); 400 401 status = UpdateRegs(state, EP1, EP3); 402 if (status < 0) 403 break; 404 status = UpdateReg(state, EB13); 405 if (status < 0) 406 break; 407 408 state->m_Regs[EB4] |= 0x20; /* LO_ForceSrce = 1 */ 409 status = UpdateReg(state, EB4); 410 if (status < 0) 411 break; 412 413 state->m_Regs[EB7] |= 0x20; /* CAL_ForceSrce = 1 */ 414 status = UpdateReg(state, EB7); 415 if (status < 0) 416 break; 417 418 state->m_Regs[EB14] = 0; /* RFC_Cprog = 0 */ 419 status = UpdateReg(state, EB14); 420 if (status < 0) 421 break; 422 423 state->m_Regs[EB20] &= ~0x20; /* ForceLock = 0; */ 424 status = UpdateReg(state, EB20); 425 if (status < 0) 426 break; 427 428 state->m_Regs[EP4] |= 0x03; /* CAL_Mode = 3 */ 429 status = UpdateRegs(state, EP4, EP5); 430 if (status < 0) 431 break; 432 433 status = CalcCalPLL(state, freq); 434 if (status < 0) 435 break; 436 status = CalcMainPLL(state, freq + 1000000); 437 if (status < 0) 438 break; 439 440 msleep(5); 441 status = UpdateReg(state, EP2); 442 if (status < 0) 443 break; 444 status = UpdateReg(state, EP1); 445 if (status < 0) 446 break; 447 status = UpdateReg(state, EP2); 448 if (status < 0) 449 break; 450 status = UpdateReg(state, EP1); 451 if (status < 0) 452 break; 453 454 state->m_Regs[EB4] &= ~0x20; /* LO_ForceSrce = 0 */ 455 status = UpdateReg(state, EB4); 456 if (status < 0) 457 break; 458 459 state->m_Regs[EB7] &= ~0x20; /* CAL_ForceSrce = 0 */ 460 status = UpdateReg(state, EB7); 461 if (status < 0) 462 break; 463 msleep(10); 464 465 state->m_Regs[EB20] |= 0x20; /* ForceLock = 1; */ 466 status = UpdateReg(state, EB20); 467 if (status < 0) 468 break; 469 msleep(60); 470 471 state->m_Regs[EP4] &= ~0x03; /* CAL_Mode = 0 */ 472 state->m_Regs[EP3] &= ~0x40; /* SM_LT = 0 */ 473 state->m_Regs[EB18] &= ~0x03; /* AGC1_Gain = 0 */ 474 status = UpdateReg(state, EB18); 475 if (status < 0) 476 break; 477 status = UpdateRegs(state, EP3, EP4); 478 if (status < 0) 479 break; 480 status = UpdateReg(state, EP1); 481 if (status < 0) 482 break; 483 484 status = ReadExtented(state, Regs); 485 if (status < 0) 486 break; 487 488 *pCprog = Regs[EB14]; 489 490 } while (0); 491 return status; 492 } 493 494 static int RFTrackingFiltersInit(struct tda_state *state, 495 u8 RFBand) 496 { 497 int status = 0; 498 499 u32 RF1 = m_RF_Band_Map[RFBand].m_RF1_Default; 500 u32 RF2 = m_RF_Band_Map[RFBand].m_RF2_Default; 501 u32 RF3 = m_RF_Band_Map[RFBand].m_RF3_Default; 502 bool bcal = false; 503 504 s32 Cprog_cal1 = 0; 505 s32 Cprog_table1 = 0; 506 s32 Cprog_cal2 = 0; 507 s32 Cprog_table2 = 0; 508 s32 Cprog_cal3 = 0; 509 s32 Cprog_table3 = 0; 510 511 state->m_RF_A1[RFBand] = 0; 512 state->m_RF_B1[RFBand] = 0; 513 state->m_RF_A2[RFBand] = 0; 514 state->m_RF_B2[RFBand] = 0; 515 516 do { 517 status = PowerScan(state, RFBand, RF1, &RF1, &bcal); 518 if (status < 0) 519 break; 520 if (bcal) { 521 status = CalibrateRF(state, RFBand, RF1, &Cprog_cal1); 522 if (status < 0) 523 break; 524 } 525 SearchMap2(m_RF_Cal_Map, RF1, &Cprog_table1); 526 if (!bcal) 527 Cprog_cal1 = Cprog_table1; 528 state->m_RF_B1[RFBand] = Cprog_cal1 - Cprog_table1; 529 /* state->m_RF_A1[RF_Band] = ???? */ 530 531 if (RF2 == 0) 532 break; 533 534 status = PowerScan(state, RFBand, RF2, &RF2, &bcal); 535 if (status < 0) 536 break; 537 if (bcal) { 538 status = CalibrateRF(state, RFBand, RF2, &Cprog_cal2); 539 if (status < 0) 540 break; 541 } 542 SearchMap2(m_RF_Cal_Map, RF2, &Cprog_table2); 543 if (!bcal) 544 Cprog_cal2 = Cprog_table2; 545 546 state->m_RF_A1[RFBand] = 547 (Cprog_cal2 - Cprog_table2 - Cprog_cal1 + Cprog_table1) / 548 ((s32)(RF2) - (s32)(RF1)); 549 550 if (RF3 == 0) 551 break; 552 553 status = PowerScan(state, RFBand, RF3, &RF3, &bcal); 554 if (status < 0) 555 break; 556 if (bcal) { 557 status = CalibrateRF(state, RFBand, RF3, &Cprog_cal3); 558 if (status < 0) 559 break; 560 } 561 SearchMap2(m_RF_Cal_Map, RF3, &Cprog_table3); 562 if (!bcal) 563 Cprog_cal3 = Cprog_table3; 564 state->m_RF_A2[RFBand] = (Cprog_cal3 - Cprog_table3 - Cprog_cal2 + Cprog_table2) / ((s32)(RF3) - (s32)(RF2)); 565 state->m_RF_B2[RFBand] = Cprog_cal2 - Cprog_table2; 566 567 } while (0); 568 569 state->m_RF1[RFBand] = RF1; 570 state->m_RF2[RFBand] = RF2; 571 state->m_RF3[RFBand] = RF3; 572 573 #if 0 574 printk(KERN_ERR "tda18271c2dd: %s %d RF1 = %d A1 = %d B1 = %d RF2 = %d A2 = %d B2 = %d RF3 = %d\n", __func__, 575 RFBand, RF1, state->m_RF_A1[RFBand], state->m_RF_B1[RFBand], RF2, 576 state->m_RF_A2[RFBand], state->m_RF_B2[RFBand], RF3); 577 #endif 578 579 return status; 580 } 581 582 static int PowerScan(struct tda_state *state, 583 u8 RFBand, u32 RF_in, u32 *pRF_Out, bool *pbcal) 584 { 585 int status = 0; 586 do { 587 u8 Gain_Taper = 0; 588 s32 RFC_Cprog = 0; 589 u8 CID_Target = 0; 590 u8 CountLimit = 0; 591 u32 freq_MainPLL; 592 u8 Regs[NUM_REGS]; 593 u8 CID_Gain; 594 s32 Count = 0; 595 int sign = 1; 596 bool wait = false; 597 598 if (!(SearchMap2(m_RF_Cal_Map, RF_in, &RFC_Cprog) && 599 SearchMap1(m_GainTaper_Map, RF_in, &Gain_Taper) && 600 SearchMap3(m_CID_Target_Map, RF_in, &CID_Target, &CountLimit))) { 601 602 printk(KERN_ERR "tda18271c2dd: %s Search map failed\n", __func__); 603 return -EINVAL; 604 } 605 606 state->m_Regs[EP2] = (RFBand << 5) | Gain_Taper; 607 state->m_Regs[EB14] = (RFC_Cprog); 608 status = UpdateReg(state, EP2); 609 if (status < 0) 610 break; 611 status = UpdateReg(state, EB14); 612 if (status < 0) 613 break; 614 615 freq_MainPLL = RF_in + 1000000; 616 status = CalcMainPLL(state, freq_MainPLL); 617 if (status < 0) 618 break; 619 msleep(5); 620 state->m_Regs[EP4] = (state->m_Regs[EP4] & ~0x03) | 1; /* CAL_mode = 1 */ 621 status = UpdateReg(state, EP4); 622 if (status < 0) 623 break; 624 status = UpdateReg(state, EP2); /* Launch power measurement */ 625 if (status < 0) 626 break; 627 status = ReadExtented(state, Regs); 628 if (status < 0) 629 break; 630 CID_Gain = Regs[EB10] & 0x3F; 631 state->m_Regs[ID] = Regs[ID]; /* Chip version, (needed for C1 workaround in CalibrateRF) */ 632 633 *pRF_Out = RF_in; 634 635 while (CID_Gain < CID_Target) { 636 freq_MainPLL = RF_in + sign * Count + 1000000; 637 status = CalcMainPLL(state, freq_MainPLL); 638 if (status < 0) 639 break; 640 msleep(wait ? 5 : 1); 641 wait = false; 642 status = UpdateReg(state, EP2); /* Launch power measurement */ 643 if (status < 0) 644 break; 645 status = ReadExtented(state, Regs); 646 if (status < 0) 647 break; 648 CID_Gain = Regs[EB10] & 0x3F; 649 Count += 200000; 650 651 if (Count < CountLimit * 100000) 652 continue; 653 if (sign < 0) 654 break; 655 656 sign = -sign; 657 Count = 200000; 658 wait = true; 659 } 660 if (status < 0) 661 break; 662 if (CID_Gain >= CID_Target) { 663 *pbcal = true; 664 *pRF_Out = freq_MainPLL - 1000000; 665 } else 666 *pbcal = false; 667 } while (0); 668 669 return status; 670 } 671 672 static int PowerScanInit(struct tda_state *state) 673 { 674 int status = 0; 675 do { 676 state->m_Regs[EP3] = (state->m_Regs[EP3] & ~0x1F) | 0x12; 677 state->m_Regs[EP4] = (state->m_Regs[EP4] & ~0x1F); /* If level = 0, Cal mode = 0 */ 678 status = UpdateRegs(state, EP3, EP4); 679 if (status < 0) 680 break; 681 state->m_Regs[EB18] = (state->m_Regs[EB18] & ~0x03); /* AGC 1 Gain = 0 */ 682 status = UpdateReg(state, EB18); 683 if (status < 0) 684 break; 685 state->m_Regs[EB21] = (state->m_Regs[EB21] & ~0x03); /* AGC 2 Gain = 0 (Datasheet = 3) */ 686 state->m_Regs[EB23] = (state->m_Regs[EB23] | 0x06); /* ForceLP_Fc2_En = 1, LPFc[2] = 1 */ 687 status = UpdateRegs(state, EB21, EB23); 688 if (status < 0) 689 break; 690 } while (0); 691 return status; 692 } 693 694 static int CalcRFFilterCurve(struct tda_state *state) 695 { 696 int status = 0; 697 do { 698 msleep(200); /* Temperature stabilisation */ 699 status = PowerScanInit(state); 700 if (status < 0) 701 break; 702 status = RFTrackingFiltersInit(state, 0); 703 if (status < 0) 704 break; 705 status = RFTrackingFiltersInit(state, 1); 706 if (status < 0) 707 break; 708 status = RFTrackingFiltersInit(state, 2); 709 if (status < 0) 710 break; 711 status = RFTrackingFiltersInit(state, 3); 712 if (status < 0) 713 break; 714 status = RFTrackingFiltersInit(state, 4); 715 if (status < 0) 716 break; 717 status = RFTrackingFiltersInit(state, 5); 718 if (status < 0) 719 break; 720 status = RFTrackingFiltersInit(state, 6); 721 if (status < 0) 722 break; 723 status = ThermometerRead(state, &state->m_TMValue_RFCal); /* also switches off Cal mode !!! */ 724 if (status < 0) 725 break; 726 } while (0); 727 728 return status; 729 } 730 731 static int FixedContentsI2CUpdate(struct tda_state *state) 732 { 733 static u8 InitRegs[] = { 734 0x08, 0x80, 0xC6, 735 0xDF, 0x16, 0x60, 0x80, 736 0x80, 0x00, 0x00, 0x00, 737 0x00, 0x00, 0x00, 0x00, 738 0xFC, 0x01, 0x84, 0x41, 739 0x01, 0x84, 0x40, 0x07, 740 0x00, 0x00, 0x96, 0x3F, 741 0xC1, 0x00, 0x8F, 0x00, 742 0x00, 0x8C, 0x00, 0x20, 743 0xB3, 0x48, 0xB0, 744 }; 745 int status = 0; 746 memcpy(&state->m_Regs[TM], InitRegs, EB23 - TM + 1); 747 do { 748 status = UpdateRegs(state, TM, EB23); 749 if (status < 0) 750 break; 751 752 /* AGC1 gain setup */ 753 state->m_Regs[EB17] = 0x00; 754 status = UpdateReg(state, EB17); 755 if (status < 0) 756 break; 757 state->m_Regs[EB17] = 0x03; 758 status = UpdateReg(state, EB17); 759 if (status < 0) 760 break; 761 state->m_Regs[EB17] = 0x43; 762 status = UpdateReg(state, EB17); 763 if (status < 0) 764 break; 765 state->m_Regs[EB17] = 0x4C; 766 status = UpdateReg(state, EB17); 767 if (status < 0) 768 break; 769 770 /* IRC Cal Low band */ 771 state->m_Regs[EP3] = 0x1F; 772 state->m_Regs[EP4] = 0x66; 773 state->m_Regs[EP5] = 0x81; 774 state->m_Regs[CPD] = 0xCC; 775 state->m_Regs[CD1] = 0x6C; 776 state->m_Regs[CD2] = 0x00; 777 state->m_Regs[CD3] = 0x00; 778 state->m_Regs[MPD] = 0xC5; 779 state->m_Regs[MD1] = 0x77; 780 state->m_Regs[MD2] = 0x08; 781 state->m_Regs[MD3] = 0x00; 782 status = UpdateRegs(state, EP2, MD3); /* diff between sw and datasheet (ep3-md3) */ 783 if (status < 0) 784 break; 785 786 #if 0 787 state->m_Regs[EB4] = 0x61; /* missing in sw */ 788 status = UpdateReg(state, EB4); 789 if (status < 0) 790 break; 791 msleep(1); 792 state->m_Regs[EB4] = 0x41; 793 status = UpdateReg(state, EB4); 794 if (status < 0) 795 break; 796 #endif 797 798 msleep(5); 799 status = UpdateReg(state, EP1); 800 if (status < 0) 801 break; 802 msleep(5); 803 804 state->m_Regs[EP5] = 0x85; 805 state->m_Regs[CPD] = 0xCB; 806 state->m_Regs[CD1] = 0x66; 807 state->m_Regs[CD2] = 0x70; 808 status = UpdateRegs(state, EP3, CD3); 809 if (status < 0) 810 break; 811 msleep(5); 812 status = UpdateReg(state, EP2); 813 if (status < 0) 814 break; 815 msleep(30); 816 817 /* IRC Cal mid band */ 818 state->m_Regs[EP5] = 0x82; 819 state->m_Regs[CPD] = 0xA8; 820 state->m_Regs[CD2] = 0x00; 821 state->m_Regs[MPD] = 0xA1; /* Datasheet = 0xA9 */ 822 state->m_Regs[MD1] = 0x73; 823 state->m_Regs[MD2] = 0x1A; 824 status = UpdateRegs(state, EP3, MD3); 825 if (status < 0) 826 break; 827 828 msleep(5); 829 status = UpdateReg(state, EP1); 830 if (status < 0) 831 break; 832 msleep(5); 833 834 state->m_Regs[EP5] = 0x86; 835 state->m_Regs[CPD] = 0xA8; 836 state->m_Regs[CD1] = 0x66; 837 state->m_Regs[CD2] = 0xA0; 838 status = UpdateRegs(state, EP3, CD3); 839 if (status < 0) 840 break; 841 msleep(5); 842 status = UpdateReg(state, EP2); 843 if (status < 0) 844 break; 845 msleep(30); 846 847 /* IRC Cal high band */ 848 state->m_Regs[EP5] = 0x83; 849 state->m_Regs[CPD] = 0x98; 850 state->m_Regs[CD1] = 0x65; 851 state->m_Regs[CD2] = 0x00; 852 state->m_Regs[MPD] = 0x91; /* Datasheet = 0x91 */ 853 state->m_Regs[MD1] = 0x71; 854 state->m_Regs[MD2] = 0xCD; 855 status = UpdateRegs(state, EP3, MD3); 856 if (status < 0) 857 break; 858 msleep(5); 859 status = UpdateReg(state, EP1); 860 if (status < 0) 861 break; 862 msleep(5); 863 state->m_Regs[EP5] = 0x87; 864 state->m_Regs[CD1] = 0x65; 865 state->m_Regs[CD2] = 0x50; 866 status = UpdateRegs(state, EP3, CD3); 867 if (status < 0) 868 break; 869 msleep(5); 870 status = UpdateReg(state, EP2); 871 if (status < 0) 872 break; 873 msleep(30); 874 875 /* Back to normal */ 876 state->m_Regs[EP4] = 0x64; 877 status = UpdateReg(state, EP4); 878 if (status < 0) 879 break; 880 status = UpdateReg(state, EP1); 881 if (status < 0) 882 break; 883 884 } while (0); 885 return status; 886 } 887 888 static int InitCal(struct tda_state *state) 889 { 890 int status = 0; 891 892 do { 893 status = FixedContentsI2CUpdate(state); 894 if (status < 0) 895 break; 896 status = CalcRFFilterCurve(state); 897 if (status < 0) 898 break; 899 status = StandBy(state); 900 if (status < 0) 901 break; 902 /* m_bInitDone = true; */ 903 } while (0); 904 return status; 905 }; 906 907 static int RFTrackingFiltersCorrection(struct tda_state *state, 908 u32 Frequency) 909 { 910 int status = 0; 911 s32 Cprog_table; 912 u8 RFBand; 913 u8 dCoverdT; 914 915 if (!SearchMap2(m_RF_Cal_Map, Frequency, &Cprog_table) || 916 !SearchMap4(m_RF_Band_Map, Frequency, &RFBand) || 917 !SearchMap1(m_RF_Cal_DC_Over_DT_Map, Frequency, &dCoverdT)) 918 919 return -EINVAL; 920 921 do { 922 u8 TMValue_Current; 923 u32 RF1 = state->m_RF1[RFBand]; 924 u32 RF2 = state->m_RF1[RFBand]; 925 u32 RF3 = state->m_RF1[RFBand]; 926 s32 RF_A1 = state->m_RF_A1[RFBand]; 927 s32 RF_B1 = state->m_RF_B1[RFBand]; 928 s32 RF_A2 = state->m_RF_A2[RFBand]; 929 s32 RF_B2 = state->m_RF_B2[RFBand]; 930 s32 Capprox = 0; 931 int TComp; 932 933 state->m_Regs[EP3] &= ~0xE0; /* Power up */ 934 status = UpdateReg(state, EP3); 935 if (status < 0) 936 break; 937 938 status = ThermometerRead(state, &TMValue_Current); 939 if (status < 0) 940 break; 941 942 if (RF3 == 0 || Frequency < RF2) 943 Capprox = RF_A1 * ((s32)(Frequency) - (s32)(RF1)) + RF_B1 + Cprog_table; 944 else 945 Capprox = RF_A2 * ((s32)(Frequency) - (s32)(RF2)) + RF_B2 + Cprog_table; 946 947 TComp = (int)(dCoverdT) * ((int)(TMValue_Current) - (int)(state->m_TMValue_RFCal))/1000; 948 949 Capprox += TComp; 950 951 if (Capprox < 0) 952 Capprox = 0; 953 else if (Capprox > 255) 954 Capprox = 255; 955 956 957 /* TODO Temperature compensation. There is defenitely a scale factor */ 958 /* missing in the datasheet, so leave it out for now. */ 959 state->m_Regs[EB14] = Capprox; 960 961 status = UpdateReg(state, EB14); 962 if (status < 0) 963 break; 964 965 } while (0); 966 return status; 967 } 968 969 static int ChannelConfiguration(struct tda_state *state, 970 u32 Frequency, int Standard) 971 { 972 973 s32 IntermediateFrequency = m_StandardTable[Standard].m_IFFrequency; 974 int status = 0; 975 976 u8 BP_Filter = 0; 977 u8 RF_Band = 0; 978 u8 GainTaper = 0; 979 u8 IR_Meas = 0; 980 981 state->IF = IntermediateFrequency; 982 /* printk("tda18271c2dd: %s Freq = %d Standard = %d IF = %d\n", __func__, Frequency, Standard, IntermediateFrequency); */ 983 /* get values from tables */ 984 985 if (!(SearchMap1(m_BP_Filter_Map, Frequency, &BP_Filter) && 986 SearchMap1(m_GainTaper_Map, Frequency, &GainTaper) && 987 SearchMap1(m_IR_Meas_Map, Frequency, &IR_Meas) && 988 SearchMap4(m_RF_Band_Map, Frequency, &RF_Band))) { 989 990 printk(KERN_ERR "tda18271c2dd: %s SearchMap failed\n", __func__); 991 return -EINVAL; 992 } 993 994 do { 995 state->m_Regs[EP3] = (state->m_Regs[EP3] & ~0x1F) | m_StandardTable[Standard].m_EP3_4_0; 996 state->m_Regs[EP3] &= ~0x04; /* switch RFAGC to high speed mode */ 997 998 /* m_EP4 default for XToutOn, CAL_Mode (0) */ 999 state->m_Regs[EP4] = state->m_EP4 | ((Standard > HF_AnalogMax) ? state->m_IFLevelDigital : state->m_IFLevelAnalog); 1000 /* state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital; */ 1001 if (Standard <= HF_AnalogMax) 1002 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelAnalog; 1003 else if (Standard <= HF_ATSC) 1004 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDVBT; 1005 else if (Standard <= HF_DVBC) 1006 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDVBC; 1007 else 1008 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital; 1009 1010 if ((Standard == HF_FM_Radio) && state->m_bFMInput) 1011 state->m_Regs[EP4] |= 0x80; 1012 1013 state->m_Regs[MPD] &= ~0x80; 1014 if (Standard > HF_AnalogMax) 1015 state->m_Regs[MPD] |= 0x80; /* Add IF_notch for digital */ 1016 1017 state->m_Regs[EB22] = m_StandardTable[Standard].m_EB22; 1018 1019 /* Note: This is missing from flowchart in TDA18271 specification ( 1.5 MHz cutoff for FM ) */ 1020 if (Standard == HF_FM_Radio) 1021 state->m_Regs[EB23] |= 0x06; /* ForceLP_Fc2_En = 1, LPFc[2] = 1 */ 1022 else 1023 state->m_Regs[EB23] &= ~0x06; /* ForceLP_Fc2_En = 0, LPFc[2] = 0 */ 1024 1025 status = UpdateRegs(state, EB22, EB23); 1026 if (status < 0) 1027 break; 1028 1029 state->m_Regs[EP1] = (state->m_Regs[EP1] & ~0x07) | 0x40 | BP_Filter; /* Dis_Power_level = 1, Filter */ 1030 state->m_Regs[EP5] = (state->m_Regs[EP5] & ~0x07) | IR_Meas; 1031 state->m_Regs[EP2] = (RF_Band << 5) | GainTaper; 1032 1033 state->m_Regs[EB1] = (state->m_Regs[EB1] & ~0x07) | 1034 (state->m_bMaster ? 0x04 : 0x00); /* CALVCO_FortLOn = MS */ 1035 /* AGC1_always_master = 0 */ 1036 /* AGC_firstn = 0 */ 1037 status = UpdateReg(state, EB1); 1038 if (status < 0) 1039 break; 1040 1041 if (state->m_bMaster) { 1042 status = CalcMainPLL(state, Frequency + IntermediateFrequency); 1043 if (status < 0) 1044 break; 1045 status = UpdateRegs(state, TM, EP5); 1046 if (status < 0) 1047 break; 1048 state->m_Regs[EB4] |= 0x20; /* LO_forceSrce = 1 */ 1049 status = UpdateReg(state, EB4); 1050 if (status < 0) 1051 break; 1052 msleep(1); 1053 state->m_Regs[EB4] &= ~0x20; /* LO_forceSrce = 0 */ 1054 status = UpdateReg(state, EB4); 1055 if (status < 0) 1056 break; 1057 } else { 1058 u8 PostDiv = 0; 1059 u8 Div; 1060 status = CalcCalPLL(state, Frequency + IntermediateFrequency); 1061 if (status < 0) 1062 break; 1063 1064 SearchMap3(m_Cal_PLL_Map, Frequency + IntermediateFrequency, &PostDiv, &Div); 1065 state->m_Regs[MPD] = (state->m_Regs[MPD] & ~0x7F) | (PostDiv & 0x77); 1066 status = UpdateReg(state, MPD); 1067 if (status < 0) 1068 break; 1069 status = UpdateRegs(state, TM, EP5); 1070 if (status < 0) 1071 break; 1072 1073 state->m_Regs[EB7] |= 0x20; /* CAL_forceSrce = 1 */ 1074 status = UpdateReg(state, EB7); 1075 if (status < 0) 1076 break; 1077 msleep(1); 1078 state->m_Regs[EB7] &= ~0x20; /* CAL_forceSrce = 0 */ 1079 status = UpdateReg(state, EB7); 1080 if (status < 0) 1081 break; 1082 } 1083 msleep(20); 1084 if (Standard != HF_FM_Radio) 1085 state->m_Regs[EP3] |= 0x04; /* RFAGC to normal mode */ 1086 status = UpdateReg(state, EP3); 1087 if (status < 0) 1088 break; 1089 1090 } while (0); 1091 return status; 1092 } 1093 1094 static int sleep(struct dvb_frontend *fe) 1095 { 1096 struct tda_state *state = fe->tuner_priv; 1097 1098 StandBy(state); 1099 return 0; 1100 } 1101 1102 static int init(struct dvb_frontend *fe) 1103 { 1104 return 0; 1105 } 1106 1107 static void release(struct dvb_frontend *fe) 1108 { 1109 kfree(fe->tuner_priv); 1110 fe->tuner_priv = NULL; 1111 } 1112 1113 1114 static int set_params(struct dvb_frontend *fe) 1115 { 1116 struct tda_state *state = fe->tuner_priv; 1117 int status = 0; 1118 int Standard; 1119 u32 bw = fe->dtv_property_cache.bandwidth_hz; 1120 u32 delsys = fe->dtv_property_cache.delivery_system; 1121 1122 state->m_Frequency = fe->dtv_property_cache.frequency; 1123 1124 switch (delsys) { 1125 case SYS_DVBT: 1126 case SYS_DVBT2: 1127 switch (bw) { 1128 case 6000000: 1129 Standard = HF_DVBT_6MHZ; 1130 break; 1131 case 7000000: 1132 Standard = HF_DVBT_7MHZ; 1133 break; 1134 case 8000000: 1135 Standard = HF_DVBT_8MHZ; 1136 break; 1137 default: 1138 return -EINVAL; 1139 } 1140 break; 1141 case SYS_DVBC_ANNEX_A: 1142 case SYS_DVBC_ANNEX_C: 1143 if (bw <= 6000000) 1144 Standard = HF_DVBC_6MHZ; 1145 else if (bw <= 7000000) 1146 Standard = HF_DVBC_7MHZ; 1147 else 1148 Standard = HF_DVBC_8MHZ; 1149 break; 1150 default: 1151 return -EINVAL; 1152 } 1153 do { 1154 status = RFTrackingFiltersCorrection(state, state->m_Frequency); 1155 if (status < 0) 1156 break; 1157 status = ChannelConfiguration(state, state->m_Frequency, 1158 Standard); 1159 if (status < 0) 1160 break; 1161 1162 msleep(state->m_SettlingTime); /* Allow AGC's to settle down */ 1163 } while (0); 1164 return status; 1165 } 1166 1167 #if 0 1168 static int GetSignalStrength(s32 *pSignalStrength, u32 RFAgc, u32 IFAgc) 1169 { 1170 if (IFAgc < 500) { 1171 /* Scale this from 0 to 50000 */ 1172 *pSignalStrength = IFAgc * 100; 1173 } else { 1174 /* Scale range 500-1500 to 50000-80000 */ 1175 *pSignalStrength = 50000 + (IFAgc - 500) * 30; 1176 } 1177 1178 return 0; 1179 } 1180 #endif 1181 1182 static int get_if_frequency(struct dvb_frontend *fe, u32 *frequency) 1183 { 1184 struct tda_state *state = fe->tuner_priv; 1185 1186 *frequency = state->IF; 1187 return 0; 1188 } 1189 1190 static int get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) 1191 { 1192 /* struct tda_state *state = fe->tuner_priv; */ 1193 /* *bandwidth = priv->bandwidth; */ 1194 return 0; 1195 } 1196 1197 1198 static const struct dvb_tuner_ops tuner_ops = { 1199 .info = { 1200 .name = "NXP TDA18271C2D", 1201 .frequency_min_hz = 47125 * kHz, 1202 .frequency_max_hz = 865 * MHz, 1203 .frequency_step_hz = 62500 1204 }, 1205 .init = init, 1206 .sleep = sleep, 1207 .set_params = set_params, 1208 .release = release, 1209 .get_if_frequency = get_if_frequency, 1210 .get_bandwidth = get_bandwidth, 1211 }; 1212 1213 struct dvb_frontend *tda18271c2dd_attach(struct dvb_frontend *fe, 1214 struct i2c_adapter *i2c, u8 adr) 1215 { 1216 struct tda_state *state; 1217 1218 state = kzalloc(sizeof(struct tda_state), GFP_KERNEL); 1219 if (!state) 1220 return NULL; 1221 1222 fe->tuner_priv = state; 1223 state->adr = adr; 1224 state->i2c = i2c; 1225 memcpy(&fe->ops.tuner_ops, &tuner_ops, sizeof(struct dvb_tuner_ops)); 1226 reset(state); 1227 InitCal(state); 1228 1229 return fe; 1230 } 1231 EXPORT_SYMBOL_GPL(tda18271c2dd_attach); 1232 1233 MODULE_DESCRIPTION("TDA18271C2 driver"); 1234 MODULE_AUTHOR("DD"); 1235 MODULE_LICENSE("GPL"); 1236