2 * NXP TDA18218HN silicon tuner driver
4 * Copyright (C) 2010 Antti Palosaari <crope@iki.fi>
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.
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.
17 #include "tda18218_priv.h"
19 /* Max transfer size done by I2C transfer functions */
20 #define MAX_XFER_SIZE 64
22 /* write multiple registers */
23 static int tda18218_wr_regs(struct tda18218_priv
*priv
, u8 reg
, u8
*val
, u8 len
)
25 int ret
= 0, len2
, remaining
;
26 u8 buf
[MAX_XFER_SIZE
];
27 struct i2c_msg msg
[1] = {
29 .addr
= priv
->cfg
->i2c_address
,
35 if (1 + len
> sizeof(buf
)) {
36 dev_warn(&priv
->i2c
->dev
,
37 "%s: i2c wr reg=%04x: len=%d is too big!\n",
38 KBUILD_MODNAME
, reg
, len
);
42 for (remaining
= len
; remaining
> 0;
43 remaining
-= (priv
->cfg
->i2c_wr_max
- 1)) {
45 if (len2
> (priv
->cfg
->i2c_wr_max
- 1))
46 len2
= (priv
->cfg
->i2c_wr_max
- 1);
48 msg
[0].len
= 1 + len2
;
49 buf
[0] = reg
+ len
- remaining
;
50 memcpy(&buf
[1], &val
[len
- remaining
], len2
);
52 ret
= i2c_transfer(priv
->i2c
, msg
, 1);
60 dev_warn(&priv
->i2c
->dev
, "%s: i2c wr failed=%d reg=%02x " \
61 "len=%d\n", KBUILD_MODNAME
, ret
, reg
, len
);
68 /* read multiple registers */
69 static int tda18218_rd_regs(struct tda18218_priv
*priv
, u8 reg
, u8
*val
, u8 len
)
72 u8 buf
[MAX_XFER_SIZE
]; /* we must start read always from reg 0x00 */
73 struct i2c_msg msg
[2] = {
75 .addr
= priv
->cfg
->i2c_address
,
80 .addr
= priv
->cfg
->i2c_address
,
87 if (reg
+ len
> sizeof(buf
)) {
88 dev_warn(&priv
->i2c
->dev
,
89 "%s: i2c wr reg=%04x: len=%d is too big!\n",
90 KBUILD_MODNAME
, reg
, len
);
94 ret
= i2c_transfer(priv
->i2c
, msg
, 2);
96 memcpy(val
, &buf
[reg
], len
);
99 dev_warn(&priv
->i2c
->dev
, "%s: i2c rd failed=%d reg=%02x " \
100 "len=%d\n", KBUILD_MODNAME
, ret
, reg
, len
);
107 /* write single register */
108 static int tda18218_wr_reg(struct tda18218_priv
*priv
, u8 reg
, u8 val
)
110 return tda18218_wr_regs(priv
, reg
, &val
, 1);
113 /* read single register */
115 static int tda18218_rd_reg(struct tda18218_priv
*priv
, u8 reg
, u8
*val
)
117 return tda18218_rd_regs(priv
, reg
, val
, 1);
120 static int tda18218_set_params(struct dvb_frontend
*fe
)
122 struct tda18218_priv
*priv
= fe
->tuner_priv
;
123 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
124 u32 bw
= c
->bandwidth_hz
;
126 u8 buf
[3], i
, BP_Filter
, LP_Fc
;
128 /* TODO: find out correct AGC algorithm */
146 if (fe
->ops
.i2c_gate_ctrl
)
147 fe
->ops
.i2c_gate_ctrl(fe
, 1); /* open I2C-gate */
149 /* low-pass filter cut-off frequency */
152 priv
->if_frequency
= 3000000;
153 } else if (bw
<= 7000000) {
155 priv
->if_frequency
= 3500000;
158 priv
->if_frequency
= 4000000;
161 LO_Frac
= c
->frequency
+ priv
->if_frequency
;
163 /* band-pass filter */
164 if (LO_Frac
< 188000000)
166 else if (LO_Frac
< 253000000)
168 else if (LO_Frac
< 343000000)
173 buf
[0] = (priv
->regs
[R1A_IF1
] & ~7) | BP_Filter
; /* BP_Filter */
174 buf
[1] = (priv
->regs
[R1B_IF2
] & ~3) | LP_Fc
; /* LP_Fc */
175 buf
[2] = priv
->regs
[R1C_AGC2B
];
176 ret
= tda18218_wr_regs(priv
, R1A_IF1
, buf
, 3);
180 buf
[0] = (LO_Frac
/ 1000) >> 12; /* LO_Frac_0 */
181 buf
[1] = (LO_Frac
/ 1000) >> 4; /* LO_Frac_1 */
182 buf
[2] = (LO_Frac
/ 1000) << 4 |
183 (priv
->regs
[R0C_MD5
] & 0x0f); /* LO_Frac_2 */
184 ret
= tda18218_wr_regs(priv
, R0A_MD3
, buf
, 3);
188 buf
[0] = priv
->regs
[R0F_MD8
] | (1 << 6); /* Freq_prog_Start */
189 ret
= tda18218_wr_regs(priv
, R0F_MD8
, buf
, 1);
193 buf
[0] = priv
->regs
[R0F_MD8
] & ~(1 << 6); /* Freq_prog_Start */
194 ret
= tda18218_wr_regs(priv
, R0F_MD8
, buf
, 1);
199 for (i
= 0; i
< ARRAY_SIZE(agc
); i
++) {
200 ret
= tda18218_wr_reg(priv
, agc
[i
][0], agc
[i
][1]);
206 if (fe
->ops
.i2c_gate_ctrl
)
207 fe
->ops
.i2c_gate_ctrl(fe
, 0); /* close I2C-gate */
210 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
215 static int tda18218_get_if_frequency(struct dvb_frontend
*fe
, u32
*frequency
)
217 struct tda18218_priv
*priv
= fe
->tuner_priv
;
218 *frequency
= priv
->if_frequency
;
219 dev_dbg(&priv
->i2c
->dev
, "%s: if_frequency=%d\n", __func__
, *frequency
);
223 static int tda18218_sleep(struct dvb_frontend
*fe
)
225 struct tda18218_priv
*priv
= fe
->tuner_priv
;
228 if (fe
->ops
.i2c_gate_ctrl
)
229 fe
->ops
.i2c_gate_ctrl(fe
, 1); /* open I2C-gate */
232 ret
= tda18218_wr_reg(priv
, R17_PD1
, priv
->regs
[R17_PD1
] | (1 << 0));
234 if (fe
->ops
.i2c_gate_ctrl
)
235 fe
->ops
.i2c_gate_ctrl(fe
, 0); /* close I2C-gate */
238 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
243 static int tda18218_init(struct dvb_frontend
*fe
)
245 struct tda18218_priv
*priv
= fe
->tuner_priv
;
248 /* TODO: calibrations */
250 if (fe
->ops
.i2c_gate_ctrl
)
251 fe
->ops
.i2c_gate_ctrl(fe
, 1); /* open I2C-gate */
253 ret
= tda18218_wr_regs(priv
, R00_ID
, priv
->regs
, TDA18218_NUM_REGS
);
255 if (fe
->ops
.i2c_gate_ctrl
)
256 fe
->ops
.i2c_gate_ctrl(fe
, 0); /* close I2C-gate */
259 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
264 static void tda18218_release(struct dvb_frontend
*fe
)
266 kfree(fe
->tuner_priv
);
267 fe
->tuner_priv
= NULL
;
270 static const struct dvb_tuner_ops tda18218_tuner_ops
= {
272 .name
= "NXP TDA18218",
274 .frequency_min
= 174000000,
275 .frequency_max
= 864000000,
276 .frequency_step
= 1000,
279 .release
= tda18218_release
,
280 .init
= tda18218_init
,
281 .sleep
= tda18218_sleep
,
283 .set_params
= tda18218_set_params
,
285 .get_if_frequency
= tda18218_get_if_frequency
,
288 struct dvb_frontend
*tda18218_attach(struct dvb_frontend
*fe
,
289 struct i2c_adapter
*i2c
, struct tda18218_config
*cfg
)
291 struct tda18218_priv
*priv
= NULL
;
294 /* chip default registers values */
295 static u8 def_regs
[] = {
296 0xc0, 0x88, 0x00, 0x8e, 0x03, 0x00, 0x00, 0xd0, 0x00, 0x40,
297 0x00, 0x00, 0x07, 0xff, 0x84, 0x09, 0x00, 0x13, 0x00, 0x00,
298 0x01, 0x84, 0x09, 0xf0, 0x19, 0x0a, 0x8e, 0x69, 0x98, 0x01,
299 0x00, 0x58, 0x10, 0x40, 0x8c, 0x00, 0x0c, 0x48, 0x85, 0xc9,
300 0xa7, 0x00, 0x00, 0x00, 0x30, 0x81, 0x80, 0x00, 0x39, 0x00,
301 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xf6
304 priv
= kzalloc(sizeof(struct tda18218_priv
), GFP_KERNEL
);
310 fe
->tuner_priv
= priv
;
312 if (fe
->ops
.i2c_gate_ctrl
)
313 fe
->ops
.i2c_gate_ctrl(fe
, 1); /* open I2C-gate */
315 /* check if the tuner is there */
316 ret
= tda18218_rd_reg(priv
, R00_ID
, &val
);
318 dev_dbg(&priv
->i2c
->dev
, "%s: chip id=%02x\n", __func__
, val
);
319 if (ret
|| val
!= def_regs
[R00_ID
]) {
324 dev_info(&priv
->i2c
->dev
,
325 "%s: NXP TDA18218HN successfully identified\n",
328 memcpy(&fe
->ops
.tuner_ops
, &tda18218_tuner_ops
,
329 sizeof(struct dvb_tuner_ops
));
330 memcpy(priv
->regs
, def_regs
, sizeof(def_regs
));
332 /* loop-through enabled chip default register values */
333 if (priv
->cfg
->loop_through
) {
334 priv
->regs
[R17_PD1
] = 0xb0;
335 priv
->regs
[R18_PD2
] = 0x59;
339 ret
= tda18218_wr_reg(priv
, R17_PD1
, priv
->regs
[R17_PD1
] | (1 << 0));
341 dev_dbg(&priv
->i2c
->dev
, "%s: failed=%d\n", __func__
, ret
);
343 if (fe
->ops
.i2c_gate_ctrl
)
344 fe
->ops
.i2c_gate_ctrl(fe
, 0); /* close I2C-gate */
348 EXPORT_SYMBOL(tda18218_attach
);
350 MODULE_DESCRIPTION("NXP TDA18218HN silicon tuner driver");
351 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
352 MODULE_LICENSE("GPL");