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/module.h>
26 #include <linux/dvb/frontend.h>
28 #include <linux/types.h>
36 struct i2c_adapter
*i2c
;
44 #define dprintk(args...) \
47 printk(KERN_DEBUG args); \
50 static s32
abssub(s32 a
, s32 b
)
58 static int stv6110_release(struct dvb_frontend
*fe
)
60 kfree(fe
->tuner_priv
);
61 fe
->tuner_priv
= NULL
;
65 static int stv6110_write_regs(struct dvb_frontend
*fe
, u8 buf
[],
68 struct stv6110_priv
*priv
= fe
->tuner_priv
;
71 struct i2c_msg msg
= {
72 .addr
= priv
->i2c_address
,
78 dprintk("%s\n", __func__
);
83 memcpy(&cmdbuf
[1], buf
, len
);
86 if (fe
->ops
.i2c_gate_ctrl
)
87 fe
->ops
.i2c_gate_ctrl(fe
, 1);
89 rc
= i2c_transfer(priv
->i2c
, &msg
, 1);
91 dprintk("%s: i2c error\n", __func__
);
93 if (fe
->ops
.i2c_gate_ctrl
)
94 fe
->ops
.i2c_gate_ctrl(fe
, 0);
99 static int stv6110_read_regs(struct dvb_frontend
*fe
, u8 regs
[],
102 struct stv6110_priv
*priv
= fe
->tuner_priv
;
104 u8 reg
[] = { start
};
105 struct i2c_msg msg
[] = {
107 .addr
= priv
->i2c_address
,
112 .addr
= priv
->i2c_address
,
119 if (fe
->ops
.i2c_gate_ctrl
)
120 fe
->ops
.i2c_gate_ctrl(fe
, 1);
122 rc
= i2c_transfer(priv
->i2c
, msg
, 2);
124 dprintk("%s: i2c error\n", __func__
);
126 if (fe
->ops
.i2c_gate_ctrl
)
127 fe
->ops
.i2c_gate_ctrl(fe
, 0);
129 memcpy(&priv
->regs
[start
], regs
, len
);
134 static int stv6110_read_reg(struct dvb_frontend
*fe
, int start
)
137 stv6110_read_regs(fe
, buf
, start
, 1);
142 static int stv6110_sleep(struct dvb_frontend
*fe
)
145 stv6110_write_regs(fe
, reg
, 0, 1);
150 static u32
carrier_width(u32 symbol_rate
, fe_rolloff_t rolloff
)
166 return symbol_rate
+ ((symbol_rate
* rlf
) / 100);
169 static int stv6110_set_bandwidth(struct dvb_frontend
*fe
, u32 bandwidth
)
171 struct stv6110_priv
*priv
= fe
->tuner_priv
;
175 if ((bandwidth
/ 2) > 36000000) /*BW/2 max=31+5=36 mhz for r8=31*/
177 else if ((bandwidth
/ 2) < 5000000) /* BW/2 min=5Mhz for F=0 */
179 else /*if 5 < BW/2 < 36*/
180 r8
= (bandwidth
/ 2) / 1000000 - 5;
182 /* ctrl3, RCCLKOFF = 0 Activate the calibration Clock */
183 /* ctrl3, CF = r8 Set the LPF value */
184 priv
->regs
[RSTV6110_CTRL3
] &= ~((1 << 6) | 0x1f);
185 priv
->regs
[RSTV6110_CTRL3
] |= (r8
& 0x1f);
186 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL3
], RSTV6110_CTRL3
, 1);
187 /* stat1, CALRCSTRT = 1 Start LPF auto calibration*/
188 priv
->regs
[RSTV6110_STAT1
] |= 0x02;
189 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_STAT1
], RSTV6110_STAT1
, 1);
192 /* Wait for CALRCSTRT == 0 */
193 while ((i
< 10) && (ret
!= 0)) {
194 ret
= ((stv6110_read_reg(fe
, RSTV6110_STAT1
)) & 0x02);
195 mdelay(1); /* wait for LPF auto calibration */
199 /* RCCLKOFF = 1 calibration done, desactivate the calibration Clock */
200 priv
->regs
[RSTV6110_CTRL3
] |= (1 << 6);
201 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL3
], RSTV6110_CTRL3
, 1);
205 static int stv6110_init(struct dvb_frontend
*fe
)
207 struct stv6110_priv
*priv
= fe
->tuner_priv
;
208 u8 buf0
[] = { 0x07, 0x11, 0xdc, 0x85, 0x17, 0x01, 0xe6, 0x1e };
210 memcpy(priv
->regs
, buf0
, 8);
211 /* K = (Reference / 1000000) - 16 */
212 priv
->regs
[RSTV6110_CTRL1
] &= ~(0x1f << 3);
213 priv
->regs
[RSTV6110_CTRL1
] |=
214 ((((priv
->mclk
/ 1000000) - 16) & 0x1f) << 3);
216 /* divisor value for the output clock */
217 priv
->regs
[RSTV6110_CTRL2
] &= ~0xc0;
218 priv
->regs
[RSTV6110_CTRL2
] |= (priv
->clk_div
<< 6);
220 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL1
], RSTV6110_CTRL1
, 8);
222 stv6110_set_bandwidth(fe
, 72000000);
227 static int stv6110_get_frequency(struct dvb_frontend
*fe
, u32
*frequency
)
229 struct stv6110_priv
*priv
= fe
->tuner_priv
;
230 u32 nbsteps
, divider
, psd2
, freq
;
231 u8 regs
[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
233 stv6110_read_regs(fe
, regs
, 0, 8);
235 divider
= (priv
->regs
[RSTV6110_TUNING2
] & 0x0f) << 8;
236 divider
+= priv
->regs
[RSTV6110_TUNING1
];
239 nbsteps
= (priv
->regs
[RSTV6110_TUNING2
] >> 6) & 3;
241 psd2
= (priv
->regs
[RSTV6110_TUNING2
] >> 4) & 1;
243 freq
= divider
* (priv
->mclk
/ 1000);
244 freq
/= (1 << (nbsteps
+ psd2
));
252 static int stv6110_set_frequency(struct dvb_frontend
*fe
, u32 frequency
)
254 struct stv6110_priv
*priv
= fe
->tuner_priv
;
255 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
257 u32 divider
, ref
, p
, presc
, i
, result_freq
, vco_freq
;
258 s32 p_calc
, p_calc_opt
= 1000, r_div
, r_div_opt
= 0, p_val
;
261 dprintk("%s, freq=%d kHz, mclk=%d Hz\n", __func__
,
262 frequency
, priv
->mclk
);
264 /* K = (Reference / 1000000) - 16 */
265 priv
->regs
[RSTV6110_CTRL1
] &= ~(0x1f << 3);
266 priv
->regs
[RSTV6110_CTRL1
] |=
267 ((((priv
->mclk
/ 1000000) - 16) & 0x1f) << 3);
270 if (fe
->ops
.set_property
&& fe
->ops
.get_property
) {
271 srate
= c
->symbol_rate
;
272 dprintk("%s: Get Frontend parameters: srate=%d\n",
277 priv
->regs
[RSTV6110_CTRL2
] &= ~0x0f;
278 priv
->regs
[RSTV6110_CTRL2
] |= (priv
->gain
& 0x0f);
280 if (frequency
<= 1023000) {
283 } else if (frequency
<= 1300000) {
286 } else if (frequency
<= 2046000) {
294 priv
->regs
[RSTV6110_TUNING2
] &= ~(1 << 4);
295 priv
->regs
[RSTV6110_TUNING2
] |= (p
<< 4);
297 /* PRESC32ON = presc */
298 priv
->regs
[RSTV6110_TUNING2
] &= ~(1 << 5);
299 priv
->regs
[RSTV6110_TUNING2
] |= (presc
<< 5);
301 p_val
= (int)(1 << (p
+ 1)) * 10;/* P = 2 or P = 4 */
302 for (r_div
= 0; r_div
<= 3; r_div
++) {
303 p_calc
= (priv
->mclk
/ 100000);
304 p_calc
/= (1 << (r_div
+ 1));
305 if ((abssub(p_calc
, p_val
)) < (abssub(p_calc_opt
, p_val
)))
308 p_calc_opt
= (priv
->mclk
/ 100000);
309 p_calc_opt
/= (1 << (r_div_opt
+ 1));
312 ref
= priv
->mclk
/ ((1 << (r_div_opt
+ 1)) * (1 << (p
+ 1)));
313 divider
= (((frequency
* 1000) + (ref
>> 1)) / ref
);
315 /* RDIV = r_div_opt */
316 priv
->regs
[RSTV6110_TUNING2
] &= ~(3 << 6);
317 priv
->regs
[RSTV6110_TUNING2
] |= (((r_div_opt
) & 3) << 6);
319 /* NDIV_MSB = MSB(divider) */
320 priv
->regs
[RSTV6110_TUNING2
] &= ~0x0f;
321 priv
->regs
[RSTV6110_TUNING2
] |= (((divider
) >> 8) & 0x0f);
323 /* NDIV_LSB, LSB(divider) */
324 priv
->regs
[RSTV6110_TUNING1
] = (divider
& 0xff);
326 /* CALVCOSTRT = 1 VCO Auto Calibration */
327 priv
->regs
[RSTV6110_STAT1
] |= 0x04;
328 stv6110_write_regs(fe
, &priv
->regs
[RSTV6110_CTRL1
],
332 /* Wait for CALVCOSTRT == 0 */
333 while ((i
< 10) && (ret
!= 0)) {
334 ret
= ((stv6110_read_reg(fe
, RSTV6110_STAT1
)) & 0x04);
335 msleep(1); /* wait for VCO auto calibration */
339 ret
= stv6110_read_reg(fe
, RSTV6110_STAT1
);
340 stv6110_get_frequency(fe
, &result_freq
);
342 vco_freq
= divider
* ((priv
->mclk
/ 1000) / ((1 << (r_div_opt
+ 1))));
343 dprintk("%s, stat1=%x, lo_freq=%d kHz, vco_frec=%d kHz\n", __func__
,
344 ret
, result_freq
, vco_freq
);
349 static int stv6110_set_params(struct dvb_frontend
*fe
,
350 struct dvb_frontend_parameters
*params
)
352 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
353 u32 bandwidth
= carrier_width(c
->symbol_rate
, c
->rolloff
);
355 stv6110_set_frequency(fe
, c
->frequency
);
356 stv6110_set_bandwidth(fe
, bandwidth
);
361 static int stv6110_get_bandwidth(struct dvb_frontend
*fe
, u32
*bandwidth
)
363 struct stv6110_priv
*priv
= fe
->tuner_priv
;
365 u8 regs
[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
366 stv6110_read_regs(fe
, regs
, 0, 8);
369 r8
= priv
->regs
[RSTV6110_CTRL3
] & 0x1f;
370 *bandwidth
= (r8
+ 5) * 2000000;/* x2 for ZIF tuner BW/2 = F+5 Mhz */
375 static struct dvb_tuner_ops stv6110_tuner_ops
= {
377 .name
= "ST STV6110",
378 .frequency_min
= 950000,
379 .frequency_max
= 2150000,
380 .frequency_step
= 1000,
382 .init
= stv6110_init
,
383 .release
= stv6110_release
,
384 .sleep
= stv6110_sleep
,
385 .set_params
= stv6110_set_params
,
386 .get_frequency
= stv6110_get_frequency
,
387 .set_frequency
= stv6110_set_frequency
,
388 .get_bandwidth
= stv6110_get_bandwidth
,
389 .set_bandwidth
= stv6110_set_bandwidth
,
393 struct dvb_frontend
*stv6110_attach(struct dvb_frontend
*fe
,
394 const struct stv6110_config
*config
,
395 struct i2c_adapter
*i2c
)
397 struct stv6110_priv
*priv
= NULL
;
398 u8 reg0
[] = { 0x00, 0x07, 0x11, 0xdc, 0x85, 0x17, 0x01, 0xe6, 0x1e };
400 struct i2c_msg msg
[] = {
402 .addr
= config
->i2c_address
,
410 /* divisor value for the output clock */
412 reg0
[2] |= (config
->clk_div
<< 6);
414 if (fe
->ops
.i2c_gate_ctrl
)
415 fe
->ops
.i2c_gate_ctrl(fe
, 1);
417 ret
= i2c_transfer(i2c
, msg
, 1);
419 if (fe
->ops
.i2c_gate_ctrl
)
420 fe
->ops
.i2c_gate_ctrl(fe
, 0);
425 priv
= kzalloc(sizeof(struct stv6110_priv
), GFP_KERNEL
);
429 priv
->i2c_address
= config
->i2c_address
;
431 priv
->mclk
= config
->mclk
;
432 priv
->clk_div
= config
->clk_div
;
433 priv
->gain
= config
->gain
;
435 memcpy(&priv
->regs
, ®0
[1], 8);
437 memcpy(&fe
->ops
.tuner_ops
, &stv6110_tuner_ops
,
438 sizeof(struct dvb_tuner_ops
));
439 fe
->tuner_priv
= priv
;
440 printk(KERN_INFO
"STV6110 attached on addr=%x!\n", priv
->i2c_address
);
444 EXPORT_SYMBOL(stv6110_attach
);
446 module_param(debug
, int, 0644);
447 MODULE_PARM_DESC(debug
, "Turn on/off frontend debugging (default:off).");
449 MODULE_DESCRIPTION("ST STV6110 driver");
450 MODULE_AUTHOR("Igor M. Liplianin");
451 MODULE_LICENSE("GPL");