2 * tda18271c2dd: Driver for the TDA18271C2 tuner
4 * Copyright (C) 2010 Digital Devices GmbH
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 only, as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * To obtain the license, point your browser to
18 * http://www.gnu.org/copyleft/gpl.html
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/moduleparam.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/firmware.h>
27 #include <linux/i2c.h>
28 #include <asm/div64.h>
30 #include "dvb_frontend.h"
31 #include "tda18271c2dd.h"
33 /* Max transfer size done by I2C transfer functions */
34 #define MAX_XFER_SIZE 64
36 struct SStandardParam {
70 EP1, EP2, EP3, EP4, EP5,
73 EB1, EB2, EB3, EB4, EB5, EB6, EB7, EB8, EB9, EB10,
74 EB11, EB12, EB13, EB14, EB15, EB16, EB17, EB18, EB19, EB20,
80 struct i2c_adapter *i2c;
100 /* Tracking filter settings for band 0..6 */
109 u8 m_TMValue_RFCal; /* Calibration temperatur */
111 bool m_bFMInput; /* true to use Pin 8 for FM Radio */
115 static int PowerScan(struct tda_state *state,
116 u8 RFBand, u32 RF_in,
117 u32 *pRF_Out, bool *pbcal);
119 static int i2c_readn(struct i2c_adapter *adapter, u8 adr, u8 *data, int len)
121 struct i2c_msg msgs[1] = {{.addr = adr, .flags = I2C_M_RD,
122 .buf = data, .len = len} };
123 return (i2c_transfer(adapter, msgs, 1) == 1) ? 0 : -1;
126 static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len)
128 struct i2c_msg msg = {.addr = adr, .flags = 0,
129 .buf = data, .len = len};
131 if (i2c_transfer(adap, &msg, 1) != 1) {
132 printk(KERN_ERR "tda18271c2dd: i2c write error at addr %i\n", adr);
138 static int WriteRegs(struct tda_state *state,
139 u8 SubAddr, u8 *Regs, u16 nRegs)
141 u8 data[MAX_XFER_SIZE];
143 if (1 + nRegs > sizeof(data)) {
145 "%s: i2c wr: len=%d is too big!\n",
146 KBUILD_MODNAME, nRegs);
151 memcpy(data + 1, Regs, nRegs);
152 return i2c_write(state->i2c, state->adr, data, nRegs + 1);
155 static int WriteReg(struct tda_state *state, u8 SubAddr, u8 Reg)
157 u8 msg[2] = {SubAddr, Reg};
159 return i2c_write(state->i2c, state->adr, msg, 2);
162 static int Read(struct tda_state *state, u8 * Regs)
164 return i2c_readn(state->i2c, state->adr, Regs, 16);
167 static int ReadExtented(struct tda_state *state, u8 * Regs)
169 return i2c_readn(state->i2c, state->adr, Regs, NUM_REGS);
172 static int UpdateRegs(struct tda_state *state, u8 RegFrom, u8 RegTo)
174 return WriteRegs(state, RegFrom,
175 &state->m_Regs[RegFrom], RegTo-RegFrom+1);
177 static int UpdateReg(struct tda_state *state, u8 Reg)
179 return WriteReg(state, Reg, state->m_Regs[Reg]);
182 #include "tda18271c2dd_maps.h"
184 static void reset(struct tda_state *state)
186 u32 ulIFLevelAnalog = 0;
187 u32 ulIFLevelDigital = 2;
188 u32 ulIFLevelDVBC = 7;
189 u32 ulIFLevelDVBT = 6;
191 u32 ulStandbyMode = 0x06; /* Send in stdb, but leave osc on */
194 u32 ulSettlingTime = 100;
196 state->m_Frequency = 0;
197 state->m_SettlingTime = 100;
198 state->m_IFLevelAnalog = (ulIFLevelAnalog & 0x07) << 2;
199 state->m_IFLevelDigital = (ulIFLevelDigital & 0x07) << 2;
200 state->m_IFLevelDVBC = (ulIFLevelDVBC & 0x07) << 2;
201 state->m_IFLevelDVBT = (ulIFLevelDVBT & 0x07) << 2;
205 state->m_EP4 |= 0x40;
207 state->m_EP3_Standby = ((ulStandbyMode & 0x07) << 5) | 0x0F;
208 state->m_bMaster = (ulSlave == 0);
210 state->m_SettlingTime = ulSettlingTime;
212 state->m_bFMInput = (ulFMInput == 2);
215 static bool SearchMap1(struct SMap Map[],
216 u32 Frequency, u8 *pParam)
220 while ((Map[i].m_Frequency != 0) && (Frequency > Map[i].m_Frequency))
222 if (Map[i].m_Frequency == 0)
224 *pParam = Map[i].m_Param;
228 static bool SearchMap2(struct SMapI Map[],
229 u32 Frequency, s32 *pParam)
233 while ((Map[i].m_Frequency != 0) &&
234 (Frequency > Map[i].m_Frequency))
236 if (Map[i].m_Frequency == 0)
238 *pParam = Map[i].m_Param;
242 static bool SearchMap3(struct SMap2 Map[], u32 Frequency,
243 u8 *pParam1, u8 *pParam2)
247 while ((Map[i].m_Frequency != 0) &&
248 (Frequency > Map[i].m_Frequency))
250 if (Map[i].m_Frequency == 0)
252 *pParam1 = Map[i].m_Param1;
253 *pParam2 = Map[i].m_Param2;
257 static bool SearchMap4(struct SRFBandMap Map[],
258 u32 Frequency, u8 *pRFBand)
262 while (i < 7 && (Frequency > Map[i].m_RF_max))
270 static int ThermometerRead(struct tda_state *state, u8 *pTM_Value)
276 state->m_Regs[TM] |= 0x10;
277 status = UpdateReg(state, TM);
280 status = Read(state, Regs);
283 if (((Regs[TM] & 0x0F) == 0 && (Regs[TM] & 0x20) == 0x20) ||
284 ((Regs[TM] & 0x0F) == 8 && (Regs[TM] & 0x20) == 0x00)) {
285 state->m_Regs[TM] ^= 0x20;
286 status = UpdateReg(state, TM);
290 status = Read(state, Regs);
294 *pTM_Value = (Regs[TM] & 0x20)
295 ? m_Thermometer_Map_2[Regs[TM] & 0x0F]
296 : m_Thermometer_Map_1[Regs[TM] & 0x0F] ;
297 state->m_Regs[TM] &= ~0x10; /* Thermometer off */
298 status = UpdateReg(state, TM);
301 state->m_Regs[EP4] &= ~0x03; /* CAL_mode = 0 ????????? */
302 status = UpdateReg(state, EP4);
310 static int StandBy(struct tda_state *state)
314 state->m_Regs[EB12] &= ~0x20; /* PD_AGC1_Det = 0 */
315 status = UpdateReg(state, EB12);
318 state->m_Regs[EB18] &= ~0x83; /* AGC1_loop_off = 0, AGC1_Gain = 6 dB */
319 status = UpdateReg(state, EB18);
322 state->m_Regs[EB21] |= 0x03; /* AGC2_Gain = -6 dB */
323 state->m_Regs[EP3] = state->m_EP3_Standby;
324 status = UpdateReg(state, EP3);
327 state->m_Regs[EB23] &= ~0x06; /* ForceLP_Fc2_En = 0, LP_Fc[2] = 0 */
328 status = UpdateRegs(state, EB21, EB23);
335 static int CalcMainPLL(struct tda_state *state, u32 freq)
343 if (!SearchMap3(m_Main_PLL_Map, freq, &PostDiv, &Div))
346 OscFreq = (u64) freq * (u64) Div;
347 OscFreq *= (u64) 16384;
348 do_div(OscFreq, (u64)16000000);
351 state->m_Regs[MPD] = PostDiv & 0x77;
352 state->m_Regs[MD1] = ((MainDiv >> 16) & 0x7F);
353 state->m_Regs[MD2] = ((MainDiv >> 8) & 0xFF);
354 state->m_Regs[MD3] = (MainDiv & 0xFF);
356 return UpdateRegs(state, MPD, MD3);
359 static int CalcCalPLL(struct tda_state *state, u32 freq)
366 if (!SearchMap3(m_Cal_PLL_Map, freq, &PostDiv, &Div))
369 OscFreq = (u64)freq * (u64)Div;
370 /* CalDiv = u32( OscFreq * 16384 / 16000000 ); */
371 OscFreq *= (u64)16384;
372 do_div(OscFreq, (u64)16000000);
375 state->m_Regs[CPD] = PostDiv;
376 state->m_Regs[CD1] = ((CalDiv >> 16) & 0xFF);
377 state->m_Regs[CD2] = ((CalDiv >> 8) & 0xFF);
378 state->m_Regs[CD3] = (CalDiv & 0xFF);
380 return UpdateRegs(state, CPD, CD3);
383 static int CalibrateRF(struct tda_state *state,
384 u8 RFBand, u32 freq, s32 *pCprog)
394 state->m_Regs[EP4] &= ~0x03; /* CAL_mode = 0 */
395 status = UpdateReg(state, EP4);
398 state->m_Regs[EB18] |= 0x03; /* AGC1_Gain = 3 */
399 status = UpdateReg(state, EB18);
403 /* Switching off LT (as datasheet says) causes calibration on C1 to fail */
404 /* (Readout of Cprog is allways 255) */
405 if (state->m_Regs[ID] != 0x83) /* C1: ID == 83, C2: ID == 84 */
406 state->m_Regs[EP3] |= 0x40; /* SM_LT = 1 */
408 if (!(SearchMap1(m_BP_Filter_Map, freq, &BP_Filter) &&
409 SearchMap1(m_GainTaper_Map, freq, &GainTaper) &&
410 SearchMap3(m_KM_Map, freq, &RFC_K, &RFC_M)))
413 state->m_Regs[EP1] = (state->m_Regs[EP1] & ~0x07) | BP_Filter;
414 state->m_Regs[EP2] = (RFBand << 5) | GainTaper;
416 state->m_Regs[EB13] = (state->m_Regs[EB13] & ~0x7C) | (RFC_K << 4) | (RFC_M << 2);
418 status = UpdateRegs(state, EP1, EP3);
421 status = UpdateReg(state, EB13);
425 state->m_Regs[EB4] |= 0x20; /* LO_ForceSrce = 1 */
426 status = UpdateReg(state, EB4);
430 state->m_Regs[EB7] |= 0x20; /* CAL_ForceSrce = 1 */
431 status = UpdateReg(state, EB7);
435 state->m_Regs[EB14] = 0; /* RFC_Cprog = 0 */
436 status = UpdateReg(state, EB14);
440 state->m_Regs[EB20] &= ~0x20; /* ForceLock = 0; */
441 status = UpdateReg(state, EB20);
445 state->m_Regs[EP4] |= 0x03; /* CAL_Mode = 3 */
446 status = UpdateRegs(state, EP4, EP5);
450 status = CalcCalPLL(state, freq);
453 status = CalcMainPLL(state, freq + 1000000);
458 status = UpdateReg(state, EP2);
461 status = UpdateReg(state, EP1);
464 status = UpdateReg(state, EP2);
467 status = UpdateReg(state, EP1);
471 state->m_Regs[EB4] &= ~0x20; /* LO_ForceSrce = 0 */
472 status = UpdateReg(state, EB4);
476 state->m_Regs[EB7] &= ~0x20; /* CAL_ForceSrce = 0 */
477 status = UpdateReg(state, EB7);
482 state->m_Regs[EB20] |= 0x20; /* ForceLock = 1; */
483 status = UpdateReg(state, EB20);
488 state->m_Regs[EP4] &= ~0x03; /* CAL_Mode = 0 */
489 state->m_Regs[EP3] &= ~0x40; /* SM_LT = 0 */
490 state->m_Regs[EB18] &= ~0x03; /* AGC1_Gain = 0 */
491 status = UpdateReg(state, EB18);
494 status = UpdateRegs(state, EP3, EP4);
497 status = UpdateReg(state, EP1);
501 status = ReadExtented(state, Regs);
505 *pCprog = Regs[EB14];
511 static int RFTrackingFiltersInit(struct tda_state *state,
516 u32 RF1 = m_RF_Band_Map[RFBand].m_RF1_Default;
517 u32 RF2 = m_RF_Band_Map[RFBand].m_RF2_Default;
518 u32 RF3 = m_RF_Band_Map[RFBand].m_RF3_Default;
522 s32 Cprog_table1 = 0;
524 s32 Cprog_table2 = 0;
526 s32 Cprog_table3 = 0;
528 state->m_RF_A1[RFBand] = 0;
529 state->m_RF_B1[RFBand] = 0;
530 state->m_RF_A2[RFBand] = 0;
531 state->m_RF_B2[RFBand] = 0;
534 status = PowerScan(state, RFBand, RF1, &RF1, &bcal);
538 status = CalibrateRF(state, RFBand, RF1, &Cprog_cal1);
542 SearchMap2(m_RF_Cal_Map, RF1, &Cprog_table1);
544 Cprog_cal1 = Cprog_table1;
545 state->m_RF_B1[RFBand] = Cprog_cal1 - Cprog_table1;
546 /* state->m_RF_A1[RF_Band] = ???? */
551 status = PowerScan(state, RFBand, RF2, &RF2, &bcal);
555 status = CalibrateRF(state, RFBand, RF2, &Cprog_cal2);
559 SearchMap2(m_RF_Cal_Map, RF2, &Cprog_table2);
561 Cprog_cal2 = Cprog_table2;
563 state->m_RF_A1[RFBand] =
564 (Cprog_cal2 - Cprog_table2 - Cprog_cal1 + Cprog_table1) /
565 ((s32)(RF2) - (s32)(RF1));
570 status = PowerScan(state, RFBand, RF3, &RF3, &bcal);
574 status = CalibrateRF(state, RFBand, RF3, &Cprog_cal3);
578 SearchMap2(m_RF_Cal_Map, RF3, &Cprog_table3);
580 Cprog_cal3 = Cprog_table3;
581 state->m_RF_A2[RFBand] = (Cprog_cal3 - Cprog_table3 - Cprog_cal2 + Cprog_table2) / ((s32)(RF3) - (s32)(RF2));
582 state->m_RF_B2[RFBand] = Cprog_cal2 - Cprog_table2;
586 state->m_RF1[RFBand] = RF1;
587 state->m_RF2[RFBand] = RF2;
588 state->m_RF3[RFBand] = RF3;
591 printk(KERN_ERR "tda18271c2dd: %s %d RF1 = %d A1 = %d B1 = %d RF2 = %d A2 = %d B2 = %d RF3 = %d\n", __func__,
592 RFBand, RF1, state->m_RF_A1[RFBand], state->m_RF_B1[RFBand], RF2,
593 state->m_RF_A2[RFBand], state->m_RF_B2[RFBand], RF3);
599 static int PowerScan(struct tda_state *state,
600 u8 RFBand, u32 RF_in, u32 *pRF_Out, bool *pbcal)
615 if (!(SearchMap2(m_RF_Cal_Map, RF_in, &RFC_Cprog) &&
616 SearchMap1(m_GainTaper_Map, RF_in, &Gain_Taper) &&
617 SearchMap3(m_CID_Target_Map, RF_in, &CID_Target, &CountLimit))) {
619 printk(KERN_ERR "tda18271c2dd: %s Search map failed\n", __func__);
623 state->m_Regs[EP2] = (RFBand << 5) | Gain_Taper;
624 state->m_Regs[EB14] = (RFC_Cprog);
625 status = UpdateReg(state, EP2);
628 status = UpdateReg(state, EB14);
632 freq_MainPLL = RF_in + 1000000;
633 status = CalcMainPLL(state, freq_MainPLL);
637 state->m_Regs[EP4] = (state->m_Regs[EP4] & ~0x03) | 1; /* CAL_mode = 1 */
638 status = UpdateReg(state, EP4);
641 status = UpdateReg(state, EP2); /* Launch power measurement */
644 status = ReadExtented(state, Regs);
647 CID_Gain = Regs[EB10] & 0x3F;
648 state->m_Regs[ID] = Regs[ID]; /* Chip version, (needed for C1 workarround in CalibrateRF) */
652 while (CID_Gain < CID_Target) {
653 freq_MainPLL = RF_in + sign * Count + 1000000;
654 status = CalcMainPLL(state, freq_MainPLL);
657 msleep(wait ? 5 : 1);
659 status = UpdateReg(state, EP2); /* Launch power measurement */
662 status = ReadExtented(state, Regs);
665 CID_Gain = Regs[EB10] & 0x3F;
668 if (Count < CountLimit * 100000)
680 if (CID_Gain >= CID_Target) {
682 *pRF_Out = freq_MainPLL - 1000000;
690 static int PowerScanInit(struct tda_state *state)
694 state->m_Regs[EP3] = (state->m_Regs[EP3] & ~0x1F) | 0x12;
695 state->m_Regs[EP4] = (state->m_Regs[EP4] & ~0x1F); /* If level = 0, Cal mode = 0 */
696 status = UpdateRegs(state, EP3, EP4);
699 state->m_Regs[EB18] = (state->m_Regs[EB18] & ~0x03); /* AGC 1 Gain = 0 */
700 status = UpdateReg(state, EB18);
703 state->m_Regs[EB21] = (state->m_Regs[EB21] & ~0x03); /* AGC 2 Gain = 0 (Datasheet = 3) */
704 state->m_Regs[EB23] = (state->m_Regs[EB23] | 0x06); /* ForceLP_Fc2_En = 1, LPFc[2] = 1 */
705 status = UpdateRegs(state, EB21, EB23);
712 static int CalcRFFilterCurve(struct tda_state *state)
716 msleep(200); /* Temperature stabilisation */
717 status = PowerScanInit(state);
720 status = RFTrackingFiltersInit(state, 0);
723 status = RFTrackingFiltersInit(state, 1);
726 status = RFTrackingFiltersInit(state, 2);
729 status = RFTrackingFiltersInit(state, 3);
732 status = RFTrackingFiltersInit(state, 4);
735 status = RFTrackingFiltersInit(state, 5);
738 status = RFTrackingFiltersInit(state, 6);
741 status = ThermometerRead(state, &state->m_TMValue_RFCal); /* also switches off Cal mode !!! */
749 static int FixedContentsI2CUpdate(struct tda_state *state)
751 static u8 InitRegs[] = {
753 0xDF, 0x16, 0x60, 0x80,
754 0x80, 0x00, 0x00, 0x00,
755 0x00, 0x00, 0x00, 0x00,
756 0xFC, 0x01, 0x84, 0x41,
757 0x01, 0x84, 0x40, 0x07,
758 0x00, 0x00, 0x96, 0x3F,
759 0xC1, 0x00, 0x8F, 0x00,
760 0x00, 0x8C, 0x00, 0x20,
764 memcpy(&state->m_Regs[TM], InitRegs, EB23 - TM + 1);
766 status = UpdateRegs(state, TM, EB23);
770 /* AGC1 gain setup */
771 state->m_Regs[EB17] = 0x00;
772 status = UpdateReg(state, EB17);
775 state->m_Regs[EB17] = 0x03;
776 status = UpdateReg(state, EB17);
779 state->m_Regs[EB17] = 0x43;
780 status = UpdateReg(state, EB17);
783 state->m_Regs[EB17] = 0x4C;
784 status = UpdateReg(state, EB17);
788 /* IRC Cal Low band */
789 state->m_Regs[EP3] = 0x1F;
790 state->m_Regs[EP4] = 0x66;
791 state->m_Regs[EP5] = 0x81;
792 state->m_Regs[CPD] = 0xCC;
793 state->m_Regs[CD1] = 0x6C;
794 state->m_Regs[CD2] = 0x00;
795 state->m_Regs[CD3] = 0x00;
796 state->m_Regs[MPD] = 0xC5;
797 state->m_Regs[MD1] = 0x77;
798 state->m_Regs[MD2] = 0x08;
799 state->m_Regs[MD3] = 0x00;
800 status = UpdateRegs(state, EP2, MD3); /* diff between sw and datasheet (ep3-md3) */
805 state->m_Regs[EB4] = 0x61; /* missing in sw */
806 status = UpdateReg(state, EB4);
810 state->m_Regs[EB4] = 0x41;
811 status = UpdateReg(state, EB4);
817 status = UpdateReg(state, EP1);
822 state->m_Regs[EP5] = 0x85;
823 state->m_Regs[CPD] = 0xCB;
824 state->m_Regs[CD1] = 0x66;
825 state->m_Regs[CD2] = 0x70;
826 status = UpdateRegs(state, EP3, CD3);
830 status = UpdateReg(state, EP2);
835 /* IRC Cal mid band */
836 state->m_Regs[EP5] = 0x82;
837 state->m_Regs[CPD] = 0xA8;
838 state->m_Regs[CD2] = 0x00;
839 state->m_Regs[MPD] = 0xA1; /* Datasheet = 0xA9 */
840 state->m_Regs[MD1] = 0x73;
841 state->m_Regs[MD2] = 0x1A;
842 status = UpdateRegs(state, EP3, MD3);
847 status = UpdateReg(state, EP1);
852 state->m_Regs[EP5] = 0x86;
853 state->m_Regs[CPD] = 0xA8;
854 state->m_Regs[CD1] = 0x66;
855 state->m_Regs[CD2] = 0xA0;
856 status = UpdateRegs(state, EP3, CD3);
860 status = UpdateReg(state, EP2);
865 /* IRC Cal high band */
866 state->m_Regs[EP5] = 0x83;
867 state->m_Regs[CPD] = 0x98;
868 state->m_Regs[CD1] = 0x65;
869 state->m_Regs[CD2] = 0x00;
870 state->m_Regs[MPD] = 0x91; /* Datasheet = 0x91 */
871 state->m_Regs[MD1] = 0x71;
872 state->m_Regs[MD2] = 0xCD;
873 status = UpdateRegs(state, EP3, MD3);
877 status = UpdateReg(state, EP1);
881 state->m_Regs[EP5] = 0x87;
882 state->m_Regs[CD1] = 0x65;
883 state->m_Regs[CD2] = 0x50;
884 status = UpdateRegs(state, EP3, CD3);
888 status = UpdateReg(state, EP2);
894 state->m_Regs[EP4] = 0x64;
895 status = UpdateReg(state, EP4);
898 status = UpdateReg(state, EP1);
906 static int InitCal(struct tda_state *state)
911 status = FixedContentsI2CUpdate(state);
914 status = CalcRFFilterCurve(state);
917 status = StandBy(state);
920 /* m_bInitDone = true; */
925 static int RFTrackingFiltersCorrection(struct tda_state *state,
933 if (!SearchMap2(m_RF_Cal_Map, Frequency, &Cprog_table) ||
934 !SearchMap4(m_RF_Band_Map, Frequency, &RFBand) ||
935 !SearchMap1(m_RF_Cal_DC_Over_DT_Map, Frequency, &dCoverdT))
941 u32 RF1 = state->m_RF1[RFBand];
942 u32 RF2 = state->m_RF1[RFBand];
943 u32 RF3 = state->m_RF1[RFBand];
944 s32 RF_A1 = state->m_RF_A1[RFBand];
945 s32 RF_B1 = state->m_RF_B1[RFBand];
946 s32 RF_A2 = state->m_RF_A2[RFBand];
947 s32 RF_B2 = state->m_RF_B2[RFBand];
951 state->m_Regs[EP3] &= ~0xE0; /* Power up */
952 status = UpdateReg(state, EP3);
956 status = ThermometerRead(state, &TMValue_Current);
960 if (RF3 == 0 || Frequency < RF2)
961 Capprox = RF_A1 * ((s32)(Frequency) - (s32)(RF1)) + RF_B1 + Cprog_table;
963 Capprox = RF_A2 * ((s32)(Frequency) - (s32)(RF2)) + RF_B2 + Cprog_table;
965 TComp = (int)(dCoverdT) * ((int)(TMValue_Current) - (int)(state->m_TMValue_RFCal))/1000;
971 else if (Capprox > 255)
975 /* TODO Temperature compensation. There is defenitely a scale factor */
976 /* missing in the datasheet, so leave it out for now. */
977 state->m_Regs[EB14] = Capprox;
979 status = UpdateReg(state, EB14);
987 static int ChannelConfiguration(struct tda_state *state,
988 u32 Frequency, int Standard)
991 s32 IntermediateFrequency = m_StandardTable[Standard].m_IFFrequency;
999 state->IF = IntermediateFrequency;
1000 /* printk("tda18271c2dd: %s Freq = %d Standard = %d IF = %d\n", __func__, Frequency, Standard, IntermediateFrequency); */
1001 /* get values from tables */
1003 if (!(SearchMap1(m_BP_Filter_Map, Frequency, &BP_Filter) &&
1004 SearchMap1(m_GainTaper_Map, Frequency, &GainTaper) &&
1005 SearchMap1(m_IR_Meas_Map, Frequency, &IR_Meas) &&
1006 SearchMap4(m_RF_Band_Map, Frequency, &RF_Band))) {
1008 printk(KERN_ERR "tda18271c2dd: %s SearchMap failed\n", __func__);
1013 state->m_Regs[EP3] = (state->m_Regs[EP3] & ~0x1F) | m_StandardTable[Standard].m_EP3_4_0;
1014 state->m_Regs[EP3] &= ~0x04; /* switch RFAGC to high speed mode */
1016 /* m_EP4 default for XToutOn, CAL_Mode (0) */
1017 state->m_Regs[EP4] = state->m_EP4 | ((Standard > HF_AnalogMax) ? state->m_IFLevelDigital : state->m_IFLevelAnalog);
1018 /* state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital; */
1019 if (Standard <= HF_AnalogMax)
1020 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelAnalog;
1021 else if (Standard <= HF_ATSC)
1022 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDVBT;
1023 else if (Standard <= HF_DVBC)
1024 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDVBC;
1026 state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital;
1028 if ((Standard == HF_FM_Radio) && state->m_bFMInput)
1029 state->m_Regs[EP4] |= 0x80;
1031 state->m_Regs[MPD] &= ~0x80;
1032 if (Standard > HF_AnalogMax)
1033 state->m_Regs[MPD] |= 0x80; /* Add IF_notch for digital */
1035 state->m_Regs[EB22] = m_StandardTable[Standard].m_EB22;
1037 /* Note: This is missing from flowchart in TDA18271 specification ( 1.5 MHz cutoff for FM ) */
1038 if (Standard == HF_FM_Radio)
1039 state->m_Regs[EB23] |= 0x06; /* ForceLP_Fc2_En = 1, LPFc[2] = 1 */
1041 state->m_Regs[EB23] &= ~0x06; /* ForceLP_Fc2_En = 0, LPFc[2] = 0 */
1043 status = UpdateRegs(state, EB22, EB23);
1047 state->m_Regs[EP1] = (state->m_Regs[EP1] & ~0x07) | 0x40 | BP_Filter; /* Dis_Power_level = 1, Filter */
1048 state->m_Regs[EP5] = (state->m_Regs[EP5] & ~0x07) | IR_Meas;
1049 state->m_Regs[EP2] = (RF_Band << 5) | GainTaper;
1051 state->m_Regs[EB1] = (state->m_Regs[EB1] & ~0x07) |
1052 (state->m_bMaster ? 0x04 : 0x00); /* CALVCO_FortLOn = MS */
1053 /* AGC1_always_master = 0 */
1054 /* AGC_firstn = 0 */
1055 status = UpdateReg(state, EB1);
1059 if (state->m_bMaster) {
1060 status = CalcMainPLL(state, Frequency + IntermediateFrequency);
1063 status = UpdateRegs(state, TM, EP5);
1066 state->m_Regs[EB4] |= 0x20; /* LO_forceSrce = 1 */
1067 status = UpdateReg(state, EB4);
1071 state->m_Regs[EB4] &= ~0x20; /* LO_forceSrce = 0 */
1072 status = UpdateReg(state, EB4);
1078 status = CalcCalPLL(state, Frequency + IntermediateFrequency);
1082 SearchMap3(m_Cal_PLL_Map, Frequency + IntermediateFrequency, &PostDiv, &Div);
1083 state->m_Regs[MPD] = (state->m_Regs[MPD] & ~0x7F) | (PostDiv & 0x77);
1084 status = UpdateReg(state, MPD);
1087 status = UpdateRegs(state, TM, EP5);
1091 state->m_Regs[EB7] |= 0x20; /* CAL_forceSrce = 1 */
1092 status = UpdateReg(state, EB7);
1096 state->m_Regs[EB7] &= ~0x20; /* CAL_forceSrce = 0 */
1097 status = UpdateReg(state, EB7);
1102 if (Standard != HF_FM_Radio)
1103 state->m_Regs[EP3] |= 0x04; /* RFAGC to normal mode */
1104 status = UpdateReg(state, EP3);
1112 static int sleep(struct dvb_frontend *fe)
1114 struct tda_state *state = fe->tuner_priv;
1120 static int init(struct dvb_frontend *fe)
1125 static void release(struct dvb_frontend *fe)
1127 kfree(fe->tuner_priv);
1128 fe->tuner_priv = NULL;
1132 static int set_params(struct dvb_frontend *fe)
1134 struct tda_state *state = fe->tuner_priv;
1137 u32 bw = fe->dtv_property_cache.bandwidth_hz;
1138 u32 delsys = fe->dtv_property_cache.delivery_system;
1140 state->m_Frequency = fe->dtv_property_cache.frequency;
1147 Standard = HF_DVBT_6MHZ;
1150 Standard = HF_DVBT_7MHZ;
1153 Standard = HF_DVBT_8MHZ;
1158 case SYS_DVBC_ANNEX_A:
1159 case SYS_DVBC_ANNEX_C:
1161 Standard = HF_DVBC_6MHZ;
1162 else if (bw <= 7000000)
1163 Standard = HF_DVBC_7MHZ;
1165 Standard = HF_DVBC_8MHZ;
1171 status = RFTrackingFiltersCorrection(state, state->m_Frequency);
1174 status = ChannelConfiguration(state, state->m_Frequency,
1179 msleep(state->m_SettlingTime); /* Allow AGC's to settle down */
1185 static int GetSignalStrength(s32 *pSignalStrength, u32 RFAgc, u32 IFAgc)
1188 /* Scale this from 0 to 50000 */
1189 *pSignalStrength = IFAgc * 100;
1191 /* Scale range 500-1500 to 50000-80000 */
1192 *pSignalStrength = 50000 + (IFAgc - 500) * 30;
1199 static int get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
1201 struct tda_state *state = fe->tuner_priv;
1203 *frequency = state->IF;
1207 static int get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
1209 /* struct tda_state *state = fe->tuner_priv; */
1210 /* *bandwidth = priv->bandwidth; */
1215 static const struct dvb_tuner_ops tuner_ops = {
1217 .name = "NXP TDA18271C2D",
1218 .frequency_min = 47125000,
1219 .frequency_max = 865000000,
1220 .frequency_step = 62500
1224 .set_params = set_params,
1226 .get_if_frequency = get_if_frequency,
1227 .get_bandwidth = get_bandwidth,
1230 struct dvb_frontend *tda18271c2dd_attach(struct dvb_frontend *fe,
1231 struct i2c_adapter *i2c, u8 adr)
1233 struct tda_state *state;
1235 state = kzalloc(sizeof(struct tda_state), GFP_KERNEL);
1239 fe->tuner_priv = state;
1242 memcpy(&fe->ops.tuner_ops, &tuner_ops, sizeof(struct dvb_tuner_ops));
1248 EXPORT_SYMBOL_GPL(tda18271c2dd_attach);
1250 MODULE_DESCRIPTION("TDA18271C2 driver");
1251 MODULE_AUTHOR("DD");
1252 MODULE_LICENSE("GPL");