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/init.h>
24 #include <linux/delay.h>
25 #include <linux/firmware.h>
26 #include <linux/i2c.h>
27 #include <asm/div64.h>
29 #include <media/dvb_frontend.h>
30 #include "tda18271c2dd.h"
32 /* Max transfer size done by I2C transfer functions */
33 #define MAX_XFER_SIZE 64
35 struct SStandardParam
{
69 EP1
, EP2
, EP3
, EP4
, EP5
,
72 EB1
, EB2
, EB3
, EB4
, EB5
, EB6
, EB7
, EB8
, EB9
, EB10
,
73 EB11
, EB12
, EB13
, EB14
, EB15
, EB16
, EB17
, EB18
, EB19
, EB20
,
79 struct i2c_adapter
*i2c
;
99 /* Tracking filter settings for band 0..6 */
108 u8 m_TMValue_RFCal
; /* Calibration temperature */
110 bool m_bFMInput
; /* true to use Pin 8 for FM Radio */
114 static int PowerScan(struct tda_state
*state
,
115 u8 RFBand
, u32 RF_in
,
116 u32
*pRF_Out
, bool *pbcal
);
118 static int i2c_readn(struct i2c_adapter
*adapter
, u8 adr
, u8
*data
, int len
)
120 struct i2c_msg msgs
[1] = {{.addr
= adr
, .flags
= I2C_M_RD
,
121 .buf
= data
, .len
= len
} };
122 return (i2c_transfer(adapter
, msgs
, 1) == 1) ? 0 : -1;
125 static int i2c_write(struct i2c_adapter
*adap
, u8 adr
, u8
*data
, int len
)
127 struct i2c_msg msg
= {.addr
= adr
, .flags
= 0,
128 .buf
= data
, .len
= len
};
130 if (i2c_transfer(adap
, &msg
, 1) != 1) {
131 printk(KERN_ERR
"tda18271c2dd: i2c write error at addr %i\n", adr
);
137 static int WriteRegs(struct tda_state
*state
,
138 u8 SubAddr
, u8
*Regs
, u16 nRegs
)
140 u8 data
[MAX_XFER_SIZE
];
142 if (1 + nRegs
> sizeof(data
)) {
144 "%s: i2c wr: len=%d is too big!\n",
145 KBUILD_MODNAME
, nRegs
);
150 memcpy(data
+ 1, Regs
, nRegs
);
151 return i2c_write(state
->i2c
, state
->adr
, data
, nRegs
+ 1);
154 static int WriteReg(struct tda_state
*state
, u8 SubAddr
, u8 Reg
)
156 u8 msg
[2] = {SubAddr
, Reg
};
158 return i2c_write(state
->i2c
, state
->adr
, msg
, 2);
161 static int Read(struct tda_state
*state
, u8
* Regs
)
163 return i2c_readn(state
->i2c
, state
->adr
, Regs
, 16);
166 static int ReadExtented(struct tda_state
*state
, u8
* Regs
)
168 return i2c_readn(state
->i2c
, state
->adr
, Regs
, NUM_REGS
);
171 static int UpdateRegs(struct tda_state
*state
, u8 RegFrom
, u8 RegTo
)
173 return WriteRegs(state
, RegFrom
,
174 &state
->m_Regs
[RegFrom
], RegTo
-RegFrom
+1);
176 static int UpdateReg(struct tda_state
*state
, u8 Reg
)
178 return WriteReg(state
, Reg
, state
->m_Regs
[Reg
]);
181 #include "tda18271c2dd_maps.h"
183 static void reset(struct tda_state
*state
)
185 u32 ulIFLevelAnalog
= 0;
186 u32 ulIFLevelDigital
= 2;
187 u32 ulIFLevelDVBC
= 7;
188 u32 ulIFLevelDVBT
= 6;
190 u32 ulStandbyMode
= 0x06; /* Send in stdb, but leave osc on */
193 u32 ulSettlingTime
= 100;
195 state
->m_Frequency
= 0;
196 state
->m_SettlingTime
= 100;
197 state
->m_IFLevelAnalog
= (ulIFLevelAnalog
& 0x07) << 2;
198 state
->m_IFLevelDigital
= (ulIFLevelDigital
& 0x07) << 2;
199 state
->m_IFLevelDVBC
= (ulIFLevelDVBC
& 0x07) << 2;
200 state
->m_IFLevelDVBT
= (ulIFLevelDVBT
& 0x07) << 2;
204 state
->m_EP4
|= 0x40;
206 state
->m_EP3_Standby
= ((ulStandbyMode
& 0x07) << 5) | 0x0F;
207 state
->m_bMaster
= (ulSlave
== 0);
209 state
->m_SettlingTime
= ulSettlingTime
;
211 state
->m_bFMInput
= (ulFMInput
== 2);
214 static bool SearchMap1(struct SMap Map
[],
215 u32 Frequency
, u8
*pParam
)
219 while ((Map
[i
].m_Frequency
!= 0) && (Frequency
> Map
[i
].m_Frequency
))
221 if (Map
[i
].m_Frequency
== 0)
223 *pParam
= Map
[i
].m_Param
;
227 static bool SearchMap2(struct SMapI Map
[],
228 u32 Frequency
, s32
*pParam
)
232 while ((Map
[i
].m_Frequency
!= 0) &&
233 (Frequency
> Map
[i
].m_Frequency
))
235 if (Map
[i
].m_Frequency
== 0)
237 *pParam
= Map
[i
].m_Param
;
241 static bool SearchMap3(struct SMap2 Map
[], u32 Frequency
,
242 u8
*pParam1
, u8
*pParam2
)
246 while ((Map
[i
].m_Frequency
!= 0) &&
247 (Frequency
> Map
[i
].m_Frequency
))
249 if (Map
[i
].m_Frequency
== 0)
251 *pParam1
= Map
[i
].m_Param1
;
252 *pParam2
= Map
[i
].m_Param2
;
256 static bool SearchMap4(struct SRFBandMap Map
[],
257 u32 Frequency
, u8
*pRFBand
)
261 while (i
< 7 && (Frequency
> Map
[i
].m_RF_max
))
269 static int ThermometerRead(struct tda_state
*state
, u8
*pTM_Value
)
275 state
->m_Regs
[TM
] |= 0x10;
276 status
= UpdateReg(state
, TM
);
279 status
= Read(state
, Regs
);
282 if (((Regs
[TM
] & 0x0F) == 0 && (Regs
[TM
] & 0x20) == 0x20) ||
283 ((Regs
[TM
] & 0x0F) == 8 && (Regs
[TM
] & 0x20) == 0x00)) {
284 state
->m_Regs
[TM
] ^= 0x20;
285 status
= UpdateReg(state
, TM
);
289 status
= Read(state
, Regs
);
293 *pTM_Value
= (Regs
[TM
] & 0x20)
294 ? m_Thermometer_Map_2
[Regs
[TM
] & 0x0F]
295 : m_Thermometer_Map_1
[Regs
[TM
] & 0x0F] ;
296 state
->m_Regs
[TM
] &= ~0x10; /* Thermometer off */
297 status
= UpdateReg(state
, TM
);
300 state
->m_Regs
[EP4
] &= ~0x03; /* CAL_mode = 0 ????????? */
301 status
= UpdateReg(state
, EP4
);
309 static int StandBy(struct tda_state
*state
)
313 state
->m_Regs
[EB12
] &= ~0x20; /* PD_AGC1_Det = 0 */
314 status
= UpdateReg(state
, EB12
);
317 state
->m_Regs
[EB18
] &= ~0x83; /* AGC1_loop_off = 0, AGC1_Gain = 6 dB */
318 status
= UpdateReg(state
, EB18
);
321 state
->m_Regs
[EB21
] |= 0x03; /* AGC2_Gain = -6 dB */
322 state
->m_Regs
[EP3
] = state
->m_EP3_Standby
;
323 status
= UpdateReg(state
, EP3
);
326 state
->m_Regs
[EB23
] &= ~0x06; /* ForceLP_Fc2_En = 0, LP_Fc[2] = 0 */
327 status
= UpdateRegs(state
, EB21
, EB23
);
334 static int CalcMainPLL(struct tda_state
*state
, u32 freq
)
342 if (!SearchMap3(m_Main_PLL_Map
, freq
, &PostDiv
, &Div
))
345 OscFreq
= (u64
) freq
* (u64
) Div
;
346 OscFreq
*= (u64
) 16384;
347 do_div(OscFreq
, (u64
)16000000);
350 state
->m_Regs
[MPD
] = PostDiv
& 0x77;
351 state
->m_Regs
[MD1
] = ((MainDiv
>> 16) & 0x7F);
352 state
->m_Regs
[MD2
] = ((MainDiv
>> 8) & 0xFF);
353 state
->m_Regs
[MD3
] = (MainDiv
& 0xFF);
355 return UpdateRegs(state
, MPD
, MD3
);
358 static int CalcCalPLL(struct tda_state
*state
, u32 freq
)
365 if (!SearchMap3(m_Cal_PLL_Map
, freq
, &PostDiv
, &Div
))
368 OscFreq
= (u64
)freq
* (u64
)Div
;
369 /* CalDiv = u32( OscFreq * 16384 / 16000000 ); */
370 OscFreq
*= (u64
)16384;
371 do_div(OscFreq
, (u64
)16000000);
374 state
->m_Regs
[CPD
] = PostDiv
;
375 state
->m_Regs
[CD1
] = ((CalDiv
>> 16) & 0xFF);
376 state
->m_Regs
[CD2
] = ((CalDiv
>> 8) & 0xFF);
377 state
->m_Regs
[CD3
] = (CalDiv
& 0xFF);
379 return UpdateRegs(state
, CPD
, CD3
);
382 static int CalibrateRF(struct tda_state
*state
,
383 u8 RFBand
, u32 freq
, s32
*pCprog
)
393 state
->m_Regs
[EP4
] &= ~0x03; /* CAL_mode = 0 */
394 status
= UpdateReg(state
, EP4
);
397 state
->m_Regs
[EB18
] |= 0x03; /* AGC1_Gain = 3 */
398 status
= UpdateReg(state
, EB18
);
402 /* Switching off LT (as datasheet says) causes calibration on C1 to fail */
403 /* (Readout of Cprog is always 255) */
404 if (state
->m_Regs
[ID
] != 0x83) /* C1: ID == 83, C2: ID == 84 */
405 state
->m_Regs
[EP3
] |= 0x40; /* SM_LT = 1 */
407 if (!(SearchMap1(m_BP_Filter_Map
, freq
, &BP_Filter
) &&
408 SearchMap1(m_GainTaper_Map
, freq
, &GainTaper
) &&
409 SearchMap3(m_KM_Map
, freq
, &RFC_K
, &RFC_M
)))
412 state
->m_Regs
[EP1
] = (state
->m_Regs
[EP1
] & ~0x07) | BP_Filter
;
413 state
->m_Regs
[EP2
] = (RFBand
<< 5) | GainTaper
;
415 state
->m_Regs
[EB13
] = (state
->m_Regs
[EB13
] & ~0x7C) | (RFC_K
<< 4) | (RFC_M
<< 2);
417 status
= UpdateRegs(state
, EP1
, EP3
);
420 status
= UpdateReg(state
, EB13
);
424 state
->m_Regs
[EB4
] |= 0x20; /* LO_ForceSrce = 1 */
425 status
= UpdateReg(state
, EB4
);
429 state
->m_Regs
[EB7
] |= 0x20; /* CAL_ForceSrce = 1 */
430 status
= UpdateReg(state
, EB7
);
434 state
->m_Regs
[EB14
] = 0; /* RFC_Cprog = 0 */
435 status
= UpdateReg(state
, EB14
);
439 state
->m_Regs
[EB20
] &= ~0x20; /* ForceLock = 0; */
440 status
= UpdateReg(state
, EB20
);
444 state
->m_Regs
[EP4
] |= 0x03; /* CAL_Mode = 3 */
445 status
= UpdateRegs(state
, EP4
, EP5
);
449 status
= CalcCalPLL(state
, freq
);
452 status
= CalcMainPLL(state
, freq
+ 1000000);
457 status
= UpdateReg(state
, EP2
);
460 status
= UpdateReg(state
, EP1
);
463 status
= UpdateReg(state
, EP2
);
466 status
= UpdateReg(state
, EP1
);
470 state
->m_Regs
[EB4
] &= ~0x20; /* LO_ForceSrce = 0 */
471 status
= UpdateReg(state
, EB4
);
475 state
->m_Regs
[EB7
] &= ~0x20; /* CAL_ForceSrce = 0 */
476 status
= UpdateReg(state
, EB7
);
481 state
->m_Regs
[EB20
] |= 0x20; /* ForceLock = 1; */
482 status
= UpdateReg(state
, EB20
);
487 state
->m_Regs
[EP4
] &= ~0x03; /* CAL_Mode = 0 */
488 state
->m_Regs
[EP3
] &= ~0x40; /* SM_LT = 0 */
489 state
->m_Regs
[EB18
] &= ~0x03; /* AGC1_Gain = 0 */
490 status
= UpdateReg(state
, EB18
);
493 status
= UpdateRegs(state
, EP3
, EP4
);
496 status
= UpdateReg(state
, EP1
);
500 status
= ReadExtented(state
, Regs
);
504 *pCprog
= Regs
[EB14
];
510 static int RFTrackingFiltersInit(struct tda_state
*state
,
515 u32 RF1
= m_RF_Band_Map
[RFBand
].m_RF1_Default
;
516 u32 RF2
= m_RF_Band_Map
[RFBand
].m_RF2_Default
;
517 u32 RF3
= m_RF_Band_Map
[RFBand
].m_RF3_Default
;
521 s32 Cprog_table1
= 0;
523 s32 Cprog_table2
= 0;
525 s32 Cprog_table3
= 0;
527 state
->m_RF_A1
[RFBand
] = 0;
528 state
->m_RF_B1
[RFBand
] = 0;
529 state
->m_RF_A2
[RFBand
] = 0;
530 state
->m_RF_B2
[RFBand
] = 0;
533 status
= PowerScan(state
, RFBand
, RF1
, &RF1
, &bcal
);
537 status
= CalibrateRF(state
, RFBand
, RF1
, &Cprog_cal1
);
541 SearchMap2(m_RF_Cal_Map
, RF1
, &Cprog_table1
);
543 Cprog_cal1
= Cprog_table1
;
544 state
->m_RF_B1
[RFBand
] = Cprog_cal1
- Cprog_table1
;
545 /* state->m_RF_A1[RF_Band] = ???? */
550 status
= PowerScan(state
, RFBand
, RF2
, &RF2
, &bcal
);
554 status
= CalibrateRF(state
, RFBand
, RF2
, &Cprog_cal2
);
558 SearchMap2(m_RF_Cal_Map
, RF2
, &Cprog_table2
);
560 Cprog_cal2
= Cprog_table2
;
562 state
->m_RF_A1
[RFBand
] =
563 (Cprog_cal2
- Cprog_table2
- Cprog_cal1
+ Cprog_table1
) /
564 ((s32
)(RF2
) - (s32
)(RF1
));
569 status
= PowerScan(state
, RFBand
, RF3
, &RF3
, &bcal
);
573 status
= CalibrateRF(state
, RFBand
, RF3
, &Cprog_cal3
);
577 SearchMap2(m_RF_Cal_Map
, RF3
, &Cprog_table3
);
579 Cprog_cal3
= Cprog_table3
;
580 state
->m_RF_A2
[RFBand
] = (Cprog_cal3
- Cprog_table3
- Cprog_cal2
+ Cprog_table2
) / ((s32
)(RF3
) - (s32
)(RF2
));
581 state
->m_RF_B2
[RFBand
] = Cprog_cal2
- Cprog_table2
;
585 state
->m_RF1
[RFBand
] = RF1
;
586 state
->m_RF2
[RFBand
] = RF2
;
587 state
->m_RF3
[RFBand
] = RF3
;
590 printk(KERN_ERR
"tda18271c2dd: %s %d RF1 = %d A1 = %d B1 = %d RF2 = %d A2 = %d B2 = %d RF3 = %d\n", __func__
,
591 RFBand
, RF1
, state
->m_RF_A1
[RFBand
], state
->m_RF_B1
[RFBand
], RF2
,
592 state
->m_RF_A2
[RFBand
], state
->m_RF_B2
[RFBand
], RF3
);
598 static int PowerScan(struct tda_state
*state
,
599 u8 RFBand
, u32 RF_in
, u32
*pRF_Out
, bool *pbcal
)
614 if (!(SearchMap2(m_RF_Cal_Map
, RF_in
, &RFC_Cprog
) &&
615 SearchMap1(m_GainTaper_Map
, RF_in
, &Gain_Taper
) &&
616 SearchMap3(m_CID_Target_Map
, RF_in
, &CID_Target
, &CountLimit
))) {
618 printk(KERN_ERR
"tda18271c2dd: %s Search map failed\n", __func__
);
622 state
->m_Regs
[EP2
] = (RFBand
<< 5) | Gain_Taper
;
623 state
->m_Regs
[EB14
] = (RFC_Cprog
);
624 status
= UpdateReg(state
, EP2
);
627 status
= UpdateReg(state
, EB14
);
631 freq_MainPLL
= RF_in
+ 1000000;
632 status
= CalcMainPLL(state
, freq_MainPLL
);
636 state
->m_Regs
[EP4
] = (state
->m_Regs
[EP4
] & ~0x03) | 1; /* CAL_mode = 1 */
637 status
= UpdateReg(state
, EP4
);
640 status
= UpdateReg(state
, EP2
); /* Launch power measurement */
643 status
= ReadExtented(state
, Regs
);
646 CID_Gain
= Regs
[EB10
] & 0x3F;
647 state
->m_Regs
[ID
] = Regs
[ID
]; /* Chip version, (needed for C1 workaround in CalibrateRF) */
651 while (CID_Gain
< CID_Target
) {
652 freq_MainPLL
= RF_in
+ sign
* Count
+ 1000000;
653 status
= CalcMainPLL(state
, freq_MainPLL
);
656 msleep(wait
? 5 : 1);
658 status
= UpdateReg(state
, EP2
); /* Launch power measurement */
661 status
= ReadExtented(state
, Regs
);
664 CID_Gain
= Regs
[EB10
] & 0x3F;
667 if (Count
< CountLimit
* 100000)
678 if (CID_Gain
>= CID_Target
) {
680 *pRF_Out
= freq_MainPLL
- 1000000;
688 static int PowerScanInit(struct tda_state
*state
)
692 state
->m_Regs
[EP3
] = (state
->m_Regs
[EP3
] & ~0x1F) | 0x12;
693 state
->m_Regs
[EP4
] = (state
->m_Regs
[EP4
] & ~0x1F); /* If level = 0, Cal mode = 0 */
694 status
= UpdateRegs(state
, EP3
, EP4
);
697 state
->m_Regs
[EB18
] = (state
->m_Regs
[EB18
] & ~0x03); /* AGC 1 Gain = 0 */
698 status
= UpdateReg(state
, EB18
);
701 state
->m_Regs
[EB21
] = (state
->m_Regs
[EB21
] & ~0x03); /* AGC 2 Gain = 0 (Datasheet = 3) */
702 state
->m_Regs
[EB23
] = (state
->m_Regs
[EB23
] | 0x06); /* ForceLP_Fc2_En = 1, LPFc[2] = 1 */
703 status
= UpdateRegs(state
, EB21
, EB23
);
710 static int CalcRFFilterCurve(struct tda_state
*state
)
714 msleep(200); /* Temperature stabilisation */
715 status
= PowerScanInit(state
);
718 status
= RFTrackingFiltersInit(state
, 0);
721 status
= RFTrackingFiltersInit(state
, 1);
724 status
= RFTrackingFiltersInit(state
, 2);
727 status
= RFTrackingFiltersInit(state
, 3);
730 status
= RFTrackingFiltersInit(state
, 4);
733 status
= RFTrackingFiltersInit(state
, 5);
736 status
= RFTrackingFiltersInit(state
, 6);
739 status
= ThermometerRead(state
, &state
->m_TMValue_RFCal
); /* also switches off Cal mode !!! */
747 static int FixedContentsI2CUpdate(struct tda_state
*state
)
749 static u8 InitRegs
[] = {
751 0xDF, 0x16, 0x60, 0x80,
752 0x80, 0x00, 0x00, 0x00,
753 0x00, 0x00, 0x00, 0x00,
754 0xFC, 0x01, 0x84, 0x41,
755 0x01, 0x84, 0x40, 0x07,
756 0x00, 0x00, 0x96, 0x3F,
757 0xC1, 0x00, 0x8F, 0x00,
758 0x00, 0x8C, 0x00, 0x20,
762 memcpy(&state
->m_Regs
[TM
], InitRegs
, EB23
- TM
+ 1);
764 status
= UpdateRegs(state
, TM
, EB23
);
768 /* AGC1 gain setup */
769 state
->m_Regs
[EB17
] = 0x00;
770 status
= UpdateReg(state
, EB17
);
773 state
->m_Regs
[EB17
] = 0x03;
774 status
= UpdateReg(state
, EB17
);
777 state
->m_Regs
[EB17
] = 0x43;
778 status
= UpdateReg(state
, EB17
);
781 state
->m_Regs
[EB17
] = 0x4C;
782 status
= UpdateReg(state
, EB17
);
786 /* IRC Cal Low band */
787 state
->m_Regs
[EP3
] = 0x1F;
788 state
->m_Regs
[EP4
] = 0x66;
789 state
->m_Regs
[EP5
] = 0x81;
790 state
->m_Regs
[CPD
] = 0xCC;
791 state
->m_Regs
[CD1
] = 0x6C;
792 state
->m_Regs
[CD2
] = 0x00;
793 state
->m_Regs
[CD3
] = 0x00;
794 state
->m_Regs
[MPD
] = 0xC5;
795 state
->m_Regs
[MD1
] = 0x77;
796 state
->m_Regs
[MD2
] = 0x08;
797 state
->m_Regs
[MD3
] = 0x00;
798 status
= UpdateRegs(state
, EP2
, MD3
); /* diff between sw and datasheet (ep3-md3) */
803 state
->m_Regs
[EB4
] = 0x61; /* missing in sw */
804 status
= UpdateReg(state
, EB4
);
808 state
->m_Regs
[EB4
] = 0x41;
809 status
= UpdateReg(state
, EB4
);
815 status
= UpdateReg(state
, EP1
);
820 state
->m_Regs
[EP5
] = 0x85;
821 state
->m_Regs
[CPD
] = 0xCB;
822 state
->m_Regs
[CD1
] = 0x66;
823 state
->m_Regs
[CD2
] = 0x70;
824 status
= UpdateRegs(state
, EP3
, CD3
);
828 status
= UpdateReg(state
, EP2
);
833 /* IRC Cal mid band */
834 state
->m_Regs
[EP5
] = 0x82;
835 state
->m_Regs
[CPD
] = 0xA8;
836 state
->m_Regs
[CD2
] = 0x00;
837 state
->m_Regs
[MPD
] = 0xA1; /* Datasheet = 0xA9 */
838 state
->m_Regs
[MD1
] = 0x73;
839 state
->m_Regs
[MD2
] = 0x1A;
840 status
= UpdateRegs(state
, EP3
, MD3
);
845 status
= UpdateReg(state
, EP1
);
850 state
->m_Regs
[EP5
] = 0x86;
851 state
->m_Regs
[CPD
] = 0xA8;
852 state
->m_Regs
[CD1
] = 0x66;
853 state
->m_Regs
[CD2
] = 0xA0;
854 status
= UpdateRegs(state
, EP3
, CD3
);
858 status
= UpdateReg(state
, EP2
);
863 /* IRC Cal high band */
864 state
->m_Regs
[EP5
] = 0x83;
865 state
->m_Regs
[CPD
] = 0x98;
866 state
->m_Regs
[CD1
] = 0x65;
867 state
->m_Regs
[CD2
] = 0x00;
868 state
->m_Regs
[MPD
] = 0x91; /* Datasheet = 0x91 */
869 state
->m_Regs
[MD1
] = 0x71;
870 state
->m_Regs
[MD2
] = 0xCD;
871 status
= UpdateRegs(state
, EP3
, MD3
);
875 status
= UpdateReg(state
, EP1
);
879 state
->m_Regs
[EP5
] = 0x87;
880 state
->m_Regs
[CD1
] = 0x65;
881 state
->m_Regs
[CD2
] = 0x50;
882 status
= UpdateRegs(state
, EP3
, CD3
);
886 status
= UpdateReg(state
, EP2
);
892 state
->m_Regs
[EP4
] = 0x64;
893 status
= UpdateReg(state
, EP4
);
896 status
= UpdateReg(state
, EP1
);
904 static int InitCal(struct tda_state
*state
)
909 status
= FixedContentsI2CUpdate(state
);
912 status
= CalcRFFilterCurve(state
);
915 status
= StandBy(state
);
918 /* m_bInitDone = true; */
923 static int RFTrackingFiltersCorrection(struct tda_state
*state
,
931 if (!SearchMap2(m_RF_Cal_Map
, Frequency
, &Cprog_table
) ||
932 !SearchMap4(m_RF_Band_Map
, Frequency
, &RFBand
) ||
933 !SearchMap1(m_RF_Cal_DC_Over_DT_Map
, Frequency
, &dCoverdT
))
939 u32 RF1
= state
->m_RF1
[RFBand
];
940 u32 RF2
= state
->m_RF1
[RFBand
];
941 u32 RF3
= state
->m_RF1
[RFBand
];
942 s32 RF_A1
= state
->m_RF_A1
[RFBand
];
943 s32 RF_B1
= state
->m_RF_B1
[RFBand
];
944 s32 RF_A2
= state
->m_RF_A2
[RFBand
];
945 s32 RF_B2
= state
->m_RF_B2
[RFBand
];
949 state
->m_Regs
[EP3
] &= ~0xE0; /* Power up */
950 status
= UpdateReg(state
, EP3
);
954 status
= ThermometerRead(state
, &TMValue_Current
);
958 if (RF3
== 0 || Frequency
< RF2
)
959 Capprox
= RF_A1
* ((s32
)(Frequency
) - (s32
)(RF1
)) + RF_B1
+ Cprog_table
;
961 Capprox
= RF_A2
* ((s32
)(Frequency
) - (s32
)(RF2
)) + RF_B2
+ Cprog_table
;
963 TComp
= (int)(dCoverdT
) * ((int)(TMValue_Current
) - (int)(state
->m_TMValue_RFCal
))/1000;
969 else if (Capprox
> 255)
973 /* TODO Temperature compensation. There is defenitely a scale factor */
974 /* missing in the datasheet, so leave it out for now. */
975 state
->m_Regs
[EB14
] = Capprox
;
977 status
= UpdateReg(state
, EB14
);
985 static int ChannelConfiguration(struct tda_state
*state
,
986 u32 Frequency
, int Standard
)
989 s32 IntermediateFrequency
= m_StandardTable
[Standard
].m_IFFrequency
;
997 state
->IF
= IntermediateFrequency
;
998 /* printk("tda18271c2dd: %s Freq = %d Standard = %d IF = %d\n", __func__, Frequency, Standard, IntermediateFrequency); */
999 /* get values from tables */
1001 if (!(SearchMap1(m_BP_Filter_Map
, Frequency
, &BP_Filter
) &&
1002 SearchMap1(m_GainTaper_Map
, Frequency
, &GainTaper
) &&
1003 SearchMap1(m_IR_Meas_Map
, Frequency
, &IR_Meas
) &&
1004 SearchMap4(m_RF_Band_Map
, Frequency
, &RF_Band
))) {
1006 printk(KERN_ERR
"tda18271c2dd: %s SearchMap failed\n", __func__
);
1011 state
->m_Regs
[EP3
] = (state
->m_Regs
[EP3
] & ~0x1F) | m_StandardTable
[Standard
].m_EP3_4_0
;
1012 state
->m_Regs
[EP3
] &= ~0x04; /* switch RFAGC to high speed mode */
1014 /* m_EP4 default for XToutOn, CAL_Mode (0) */
1015 state
->m_Regs
[EP4
] = state
->m_EP4
| ((Standard
> HF_AnalogMax
) ? state
->m_IFLevelDigital
: state
->m_IFLevelAnalog
);
1016 /* state->m_Regs[EP4] = state->m_EP4 | state->m_IFLevelDigital; */
1017 if (Standard
<= HF_AnalogMax
)
1018 state
->m_Regs
[EP4
] = state
->m_EP4
| state
->m_IFLevelAnalog
;
1019 else if (Standard
<= HF_ATSC
)
1020 state
->m_Regs
[EP4
] = state
->m_EP4
| state
->m_IFLevelDVBT
;
1021 else if (Standard
<= HF_DVBC
)
1022 state
->m_Regs
[EP4
] = state
->m_EP4
| state
->m_IFLevelDVBC
;
1024 state
->m_Regs
[EP4
] = state
->m_EP4
| state
->m_IFLevelDigital
;
1026 if ((Standard
== HF_FM_Radio
) && state
->m_bFMInput
)
1027 state
->m_Regs
[EP4
] |= 0x80;
1029 state
->m_Regs
[MPD
] &= ~0x80;
1030 if (Standard
> HF_AnalogMax
)
1031 state
->m_Regs
[MPD
] |= 0x80; /* Add IF_notch for digital */
1033 state
->m_Regs
[EB22
] = m_StandardTable
[Standard
].m_EB22
;
1035 /* Note: This is missing from flowchart in TDA18271 specification ( 1.5 MHz cutoff for FM ) */
1036 if (Standard
== HF_FM_Radio
)
1037 state
->m_Regs
[EB23
] |= 0x06; /* ForceLP_Fc2_En = 1, LPFc[2] = 1 */
1039 state
->m_Regs
[EB23
] &= ~0x06; /* ForceLP_Fc2_En = 0, LPFc[2] = 0 */
1041 status
= UpdateRegs(state
, EB22
, EB23
);
1045 state
->m_Regs
[EP1
] = (state
->m_Regs
[EP1
] & ~0x07) | 0x40 | BP_Filter
; /* Dis_Power_level = 1, Filter */
1046 state
->m_Regs
[EP5
] = (state
->m_Regs
[EP5
] & ~0x07) | IR_Meas
;
1047 state
->m_Regs
[EP2
] = (RF_Band
<< 5) | GainTaper
;
1049 state
->m_Regs
[EB1
] = (state
->m_Regs
[EB1
] & ~0x07) |
1050 (state
->m_bMaster
? 0x04 : 0x00); /* CALVCO_FortLOn = MS */
1051 /* AGC1_always_master = 0 */
1052 /* AGC_firstn = 0 */
1053 status
= UpdateReg(state
, EB1
);
1057 if (state
->m_bMaster
) {
1058 status
= CalcMainPLL(state
, Frequency
+ IntermediateFrequency
);
1061 status
= UpdateRegs(state
, TM
, EP5
);
1064 state
->m_Regs
[EB4
] |= 0x20; /* LO_forceSrce = 1 */
1065 status
= UpdateReg(state
, EB4
);
1069 state
->m_Regs
[EB4
] &= ~0x20; /* LO_forceSrce = 0 */
1070 status
= UpdateReg(state
, EB4
);
1076 status
= CalcCalPLL(state
, Frequency
+ IntermediateFrequency
);
1080 SearchMap3(m_Cal_PLL_Map
, Frequency
+ IntermediateFrequency
, &PostDiv
, &Div
);
1081 state
->m_Regs
[MPD
] = (state
->m_Regs
[MPD
] & ~0x7F) | (PostDiv
& 0x77);
1082 status
= UpdateReg(state
, MPD
);
1085 status
= UpdateRegs(state
, TM
, EP5
);
1089 state
->m_Regs
[EB7
] |= 0x20; /* CAL_forceSrce = 1 */
1090 status
= UpdateReg(state
, EB7
);
1094 state
->m_Regs
[EB7
] &= ~0x20; /* CAL_forceSrce = 0 */
1095 status
= UpdateReg(state
, EB7
);
1100 if (Standard
!= HF_FM_Radio
)
1101 state
->m_Regs
[EP3
] |= 0x04; /* RFAGC to normal mode */
1102 status
= UpdateReg(state
, EP3
);
1110 static int sleep(struct dvb_frontend
*fe
)
1112 struct tda_state
*state
= fe
->tuner_priv
;
1118 static int init(struct dvb_frontend
*fe
)
1123 static void release(struct dvb_frontend
*fe
)
1125 kfree(fe
->tuner_priv
);
1126 fe
->tuner_priv
= NULL
;
1130 static int set_params(struct dvb_frontend
*fe
)
1132 struct tda_state
*state
= fe
->tuner_priv
;
1135 u32 bw
= fe
->dtv_property_cache
.bandwidth_hz
;
1136 u32 delsys
= fe
->dtv_property_cache
.delivery_system
;
1138 state
->m_Frequency
= fe
->dtv_property_cache
.frequency
;
1145 Standard
= HF_DVBT_6MHZ
;
1148 Standard
= HF_DVBT_7MHZ
;
1151 Standard
= HF_DVBT_8MHZ
;
1157 case SYS_DVBC_ANNEX_A
:
1158 case SYS_DVBC_ANNEX_C
:
1160 Standard
= HF_DVBC_6MHZ
;
1161 else if (bw
<= 7000000)
1162 Standard
= HF_DVBC_7MHZ
;
1164 Standard
= HF_DVBC_8MHZ
;
1170 status
= RFTrackingFiltersCorrection(state
, state
->m_Frequency
);
1173 status
= ChannelConfiguration(state
, state
->m_Frequency
,
1178 msleep(state
->m_SettlingTime
); /* Allow AGC's to settle down */
1184 static int GetSignalStrength(s32
*pSignalStrength
, u32 RFAgc
, u32 IFAgc
)
1187 /* Scale this from 0 to 50000 */
1188 *pSignalStrength
= IFAgc
* 100;
1190 /* Scale range 500-1500 to 50000-80000 */
1191 *pSignalStrength
= 50000 + (IFAgc
- 500) * 30;
1198 static int get_if_frequency(struct dvb_frontend
*fe
, u32
*frequency
)
1200 struct tda_state
*state
= fe
->tuner_priv
;
1202 *frequency
= state
->IF
;
1206 static int get_bandwidth(struct dvb_frontend
*fe
, u32
*bandwidth
)
1208 /* struct tda_state *state = fe->tuner_priv; */
1209 /* *bandwidth = priv->bandwidth; */
1214 static const struct dvb_tuner_ops tuner_ops
= {
1216 .name
= "NXP TDA18271C2D",
1217 .frequency_min_hz
= 47125 * kHz
,
1218 .frequency_max_hz
= 865 * MHz
,
1219 .frequency_step_hz
= 62500
1223 .set_params
= set_params
,
1225 .get_if_frequency
= get_if_frequency
,
1226 .get_bandwidth
= get_bandwidth
,
1229 struct dvb_frontend
*tda18271c2dd_attach(struct dvb_frontend
*fe
,
1230 struct i2c_adapter
*i2c
, u8 adr
)
1232 struct tda_state
*state
;
1234 state
= kzalloc(sizeof(struct tda_state
), GFP_KERNEL
);
1238 fe
->tuner_priv
= state
;
1241 memcpy(&fe
->ops
.tuner_ops
, &tuner_ops
, sizeof(struct dvb_tuner_ops
));
1247 EXPORT_SYMBOL_GPL(tda18271c2dd_attach
);
1249 MODULE_DESCRIPTION("TDA18271C2 driver");
1250 MODULE_AUTHOR("DD");
1251 MODULE_LICENSE("GPL");