4 * Driver for ST STV6110 satellite tuner IC.
6 * Copyright (C) 2009 NetUP Inc.
7 * Copyright (C) 2009 Igor M. Liplianin <liplianin@netup.ru>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/slab.h>
26 #include <linux/module.h>
27 #include <linux/dvb/frontend.h>
29 #include <linux/types.h>
33 /* Max transfer size done by I2C transfer functions */
34 #define MAX_XFER_SIZE 64
40 struct i2c_adapter
*i2c
;
48 #define dprintk(args...) \
51 printk(KERN_DEBUG args); \
54 static s32
abssub(s32 a
, s32 b
)
62 static void stv6110_release(struct dvb_frontend
*fe
)
64 kfree(fe
->tuner_priv
);
65 fe
->tuner_priv
= NULL
;
68 static int stv6110_write_regs(struct dvb_frontend
*fe
, u8 buf
[],
71 struct stv6110_priv
*priv
= fe
->tuner_priv
;
73 u8 cmdbuf
[MAX_XFER_SIZE
];
74 struct i2c_msg msg
= {
75 .addr
= priv
->i2c_address
,
81 dprintk("%s\n", __func__
);
83 if (1 + len
> sizeof(cmdbuf
)) {
85 "%s: i2c wr: len=%d is too big!\n",
93 memcpy(&cmdbuf
[1], buf
, len
);
96 if (fe
->ops
.i2c_gate_ctrl
)
97 fe
->ops
.i2c_gate_ctrl(fe
, 1);
99 rc
= i2c_transfer(priv
->i2c
, &msg
, 1);
101 dprintk("%s: i2c error\n", __func__
);
103 if (fe
->ops
.i2c_gate_ctrl
)
104 fe
->ops
.i2c_gate_ctrl(fe
, 0);
109 static int stv6110_read_regs(struct dvb_frontend
*fe
, u8 regs
[],
112 struct stv6110_priv
*priv
= fe
->tuner_priv
;
114 u8 reg
[] = { start
};
115 struct i2c_msg msg
[] = {
117 .addr
= priv
->i2c_address
,
122 .addr
= priv
->i2c_address
,
129 if (fe
->ops
.i2c_gate_ctrl
)
130 fe
->ops
.i2c_gate_ctrl(fe
, 1);
132 rc
= i2c_transfer(priv
->i2c
, msg
, 2);
134 dprintk("%s: i2c error\n", __func__
);
136 if (fe
->ops
.i2c_gate_ctrl
)
137 fe
->ops
.i2c_gate_ctrl(fe
, 0);
139 memcpy(&priv
->regs
[start
], regs
, len
);
144 static int stv6110_read_reg(struct dvb_frontend
*fe
, int start
)
147 stv6110_read_regs(fe
, buf
, start
, 1);
152 static int stv6110_sleep(struct dvb_frontend
*fe
)
155 stv6110_write_regs(fe
, reg
, 0, 1);
160 static u32
carrier_width(u32 symbol_rate
, enum fe_rolloff rolloff
)
176 return symbol_rate
+ ((symbol_rate
* rlf
) / 100);
179 static int stv6110_set_bandwidth(struct dvb_frontend
*fe
, u32 bandwidth
)
181 struct stv6110_priv
*priv
= fe
->tuner_priv
;
185 if ((bandwidth
/ 2) > 36000000) /*BW/2 max=31+5=36 mhz for r8=31*/
187 else if ((bandwidth
/ 2) < 5000000) /* BW/2 min=5Mhz for F=0 */
189 else /*if 5 < BW/2 < 36*/
190 r8
= (bandwidth
/ 2) / 1000000 - 5;
192 /* ctrl3, RCCLKOFF = 0 Activate the calibration Clock */
193 /* ctrl3, CF = r8 Set the LPF value */
194 priv
->regs
[RSTV6110_CTRL3
] &= ~((1 << 6) | 0x1f);
195 priv
->regs
[RSTV6110_CTRL3
] |= (r8
& 0x1f);
196 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL3
], RSTV6110_CTRL3
, 1);
197 /* stat1, CALRCSTRT = 1 Start LPF auto calibration*/
198 priv
->regs
[RSTV6110_STAT1
] |= 0x02;
199 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_STAT1
], RSTV6110_STAT1
, 1);
202 /* Wait for CALRCSTRT == 0 */
203 while ((i
< 10) && (ret
!= 0)) {
204 ret
= ((stv6110_read_reg(fe
, RSTV6110_STAT1
)) & 0x02);
205 mdelay(1); /* wait for LPF auto calibration */
209 /* RCCLKOFF = 1 calibration done, desactivate the calibration Clock */
210 priv
->regs
[RSTV6110_CTRL3
] |= (1 << 6);
211 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL3
], RSTV6110_CTRL3
, 1);
215 static int stv6110_init(struct dvb_frontend
*fe
)
217 struct stv6110_priv
*priv
= fe
->tuner_priv
;
218 u8 buf0
[] = { 0x07, 0x11, 0xdc, 0x85, 0x17, 0x01, 0xe6, 0x1e };
220 memcpy(priv
->regs
, buf0
, 8);
221 /* K = (Reference / 1000000) - 16 */
222 priv
->regs
[RSTV6110_CTRL1
] &= ~(0x1f << 3);
223 priv
->regs
[RSTV6110_CTRL1
] |=
224 ((((priv
->mclk
/ 1000000) - 16) & 0x1f) << 3);
226 /* divisor value for the output clock */
227 priv
->regs
[RSTV6110_CTRL2
] &= ~0xc0;
228 priv
->regs
[RSTV6110_CTRL2
] |= (priv
->clk_div
<< 6);
230 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL1
], RSTV6110_CTRL1
, 8);
232 stv6110_set_bandwidth(fe
, 72000000);
237 static int stv6110_get_frequency(struct dvb_frontend
*fe
, u32
*frequency
)
239 struct stv6110_priv
*priv
= fe
->tuner_priv
;
240 u32 nbsteps
, divider
, psd2
, freq
;
241 u8 regs
[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
243 stv6110_read_regs(fe
, regs
, 0, 8);
245 divider
= (priv
->regs
[RSTV6110_TUNING2
] & 0x0f) << 8;
246 divider
+= priv
->regs
[RSTV6110_TUNING1
];
249 nbsteps
= (priv
->regs
[RSTV6110_TUNING2
] >> 6) & 3;
251 psd2
= (priv
->regs
[RSTV6110_TUNING2
] >> 4) & 1;
253 freq
= divider
* (priv
->mclk
/ 1000);
254 freq
/= (1 << (nbsteps
+ psd2
));
262 static int stv6110_set_frequency(struct dvb_frontend
*fe
, u32 frequency
)
264 struct stv6110_priv
*priv
= fe
->tuner_priv
;
265 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
267 u32 divider
, ref
, p
, presc
, i
, result_freq
, vco_freq
;
268 s32 p_calc
, p_calc_opt
= 1000, r_div
, r_div_opt
= 0, p_val
;
271 dprintk("%s, freq=%d kHz, mclk=%d Hz\n", __func__
,
272 frequency
, priv
->mclk
);
274 /* K = (Reference / 1000000) - 16 */
275 priv
->regs
[RSTV6110_CTRL1
] &= ~(0x1f << 3);
276 priv
->regs
[RSTV6110_CTRL1
] |=
277 ((((priv
->mclk
/ 1000000) - 16) & 0x1f) << 3);
280 if (fe
->ops
.set_property
&& fe
->ops
.get_property
) {
281 srate
= c
->symbol_rate
;
282 dprintk("%s: Get Frontend parameters: srate=%d\n",
287 priv
->regs
[RSTV6110_CTRL2
] &= ~0x0f;
288 priv
->regs
[RSTV6110_CTRL2
] |= (priv
->gain
& 0x0f);
290 if (frequency
<= 1023000) {
293 } else if (frequency
<= 1300000) {
296 } else if (frequency
<= 2046000) {
304 priv
->regs
[RSTV6110_TUNING2
] &= ~(1 << 4);
305 priv
->regs
[RSTV6110_TUNING2
] |= (p
<< 4);
307 /* PRESC32ON = presc */
308 priv
->regs
[RSTV6110_TUNING2
] &= ~(1 << 5);
309 priv
->regs
[RSTV6110_TUNING2
] |= (presc
<< 5);
311 p_val
= (int)(1 << (p
+ 1)) * 10;/* P = 2 or P = 4 */
312 for (r_div
= 0; r_div
<= 3; r_div
++) {
313 p_calc
= (priv
->mclk
/ 100000);
314 p_calc
/= (1 << (r_div
+ 1));
315 if ((abssub(p_calc
, p_val
)) < (abssub(p_calc_opt
, p_val
)))
318 p_calc_opt
= (priv
->mclk
/ 100000);
319 p_calc_opt
/= (1 << (r_div_opt
+ 1));
322 ref
= priv
->mclk
/ ((1 << (r_div_opt
+ 1)) * (1 << (p
+ 1)));
323 divider
= (((frequency
* 1000) + (ref
>> 1)) / ref
);
325 /* RDIV = r_div_opt */
326 priv
->regs
[RSTV6110_TUNING2
] &= ~(3 << 6);
327 priv
->regs
[RSTV6110_TUNING2
] |= (((r_div_opt
) & 3) << 6);
329 /* NDIV_MSB = MSB(divider) */
330 priv
->regs
[RSTV6110_TUNING2
] &= ~0x0f;
331 priv
->regs
[RSTV6110_TUNING2
] |= (((divider
) >> 8) & 0x0f);
333 /* NDIV_LSB, LSB(divider) */
334 priv
->regs
[RSTV6110_TUNING1
] = (divider
& 0xff);
336 /* CALVCOSTRT = 1 VCO Auto Calibration */
337 priv
->regs
[RSTV6110_STAT1
] |= 0x04;
338 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL1
],
342 /* Wait for CALVCOSTRT == 0 */
343 while ((i
< 10) && (ret
!= 0)) {
344 ret
= ((stv6110_read_reg(fe
, RSTV6110_STAT1
)) & 0x04);
345 msleep(1); /* wait for VCO auto calibration */
349 ret
= stv6110_read_reg(fe
, RSTV6110_STAT1
);
350 stv6110_get_frequency(fe
, &result_freq
);
352 vco_freq
= divider
* ((priv
->mclk
/ 1000) / ((1 << (r_div_opt
+ 1))));
353 dprintk("%s, stat1=%x, lo_freq=%d kHz, vco_frec=%d kHz\n", __func__
,
354 ret
, result_freq
, vco_freq
);
359 static int stv6110_set_params(struct dvb_frontend
*fe
)
361 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
362 u32 bandwidth
= carrier_width(c
->symbol_rate
, c
->rolloff
);
364 stv6110_set_frequency(fe
, c
->frequency
);
365 stv6110_set_bandwidth(fe
, bandwidth
);
370 static int stv6110_get_bandwidth(struct dvb_frontend
*fe
, u32
*bandwidth
)
372 struct stv6110_priv
*priv
= fe
->tuner_priv
;
374 u8 regs
[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
375 stv6110_read_regs(fe
, regs
, 0, 8);
378 r8
= priv
->regs
[RSTV6110_CTRL3
] & 0x1f;
379 *bandwidth
= (r8
+ 5) * 2000000;/* x2 for ZIF tuner BW/2 = F+5 Mhz */
384 static const struct dvb_tuner_ops stv6110_tuner_ops
= {
386 .name
= "ST STV6110",
387 .frequency_min
= 950000,
388 .frequency_max
= 2150000,
389 .frequency_step
= 1000,
391 .init
= stv6110_init
,
392 .release
= stv6110_release
,
393 .sleep
= stv6110_sleep
,
394 .set_params
= stv6110_set_params
,
395 .get_frequency
= stv6110_get_frequency
,
396 .set_frequency
= stv6110_set_frequency
,
397 .get_bandwidth
= stv6110_get_bandwidth
,
398 .set_bandwidth
= stv6110_set_bandwidth
,
402 struct dvb_frontend
*stv6110_attach(struct dvb_frontend
*fe
,
403 const struct stv6110_config
*config
,
404 struct i2c_adapter
*i2c
)
406 struct stv6110_priv
*priv
= NULL
;
407 u8 reg0
[] = { 0x00, 0x07, 0x11, 0xdc, 0x85, 0x17, 0x01, 0xe6, 0x1e };
409 struct i2c_msg msg
[] = {
411 .addr
= config
->i2c_address
,
419 /* divisor value for the output clock */
421 reg0
[2] |= (config
->clk_div
<< 6);
423 if (fe
->ops
.i2c_gate_ctrl
)
424 fe
->ops
.i2c_gate_ctrl(fe
, 1);
426 ret
= i2c_transfer(i2c
, msg
, 1);
428 if (fe
->ops
.i2c_gate_ctrl
)
429 fe
->ops
.i2c_gate_ctrl(fe
, 0);
434 priv
= kzalloc(sizeof(struct stv6110_priv
), GFP_KERNEL
);
438 priv
->i2c_address
= config
->i2c_address
;
440 priv
->mclk
= config
->mclk
;
441 priv
->clk_div
= config
->clk_div
;
442 priv
->gain
= config
->gain
;
444 memcpy(&priv
->regs
, ®0
[1], 8);
446 memcpy(&fe
->ops
.tuner_ops
, &stv6110_tuner_ops
,
447 sizeof(struct dvb_tuner_ops
));
448 fe
->tuner_priv
= priv
;
449 printk(KERN_INFO
"STV6110 attached on addr=%x!\n", priv
->i2c_address
);
453 EXPORT_SYMBOL(stv6110_attach
);
455 module_param(debug
, int, 0644);
456 MODULE_PARM_DESC(debug
, "Turn on/off frontend debugging (default:off).");
458 MODULE_DESCRIPTION("ST STV6110 driver");
459 MODULE_AUTHOR("Igor M. Liplianin");
460 MODULE_LICENSE("GPL");