]>
Commit | Line | Data |
---|---|---|
e415c689 MA |
1 | /* |
2 | STV6110(A) Silicon tuner driver | |
3 | ||
4 | Copyright (C) Manu Abraham <abraham.manu@gmail.com> | |
5 | ||
6 | Copyright (C) ST Microelectronics | |
7 | ||
8 | This program is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2 of the License, or | |
11 | (at your option) any later version. | |
12 | ||
13 | This program is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
21 | */ | |
22 | ||
23 | #include <linux/init.h> | |
24 | #include <linux/kernel.h> | |
25 | #include <linux/module.h> | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
e415c689 MA |
27 | #include <linux/string.h> |
28 | ||
29 | #include "dvb_frontend.h" | |
30 | ||
31 | #include "stv6110x_reg.h" | |
32 | #include "stv6110x.h" | |
33 | #include "stv6110x_priv.h" | |
34 | ||
8393796d MCC |
35 | /* Max transfer size done by I2C transfer functions */ |
36 | #define MAX_XFER_SIZE 64 | |
37 | ||
e415c689 MA |
38 | static unsigned int verbose; |
39 | module_param(verbose, int, 0644); | |
40 | MODULE_PARM_DESC(verbose, "Set Verbosity level"); | |
41 | ||
e415c689 MA |
42 | static int stv6110x_read_reg(struct stv6110x_state *stv6110x, u8 reg, u8 *data) |
43 | { | |
44 | int ret; | |
45 | const struct stv6110x_config *config = stv6110x->config; | |
46 | u8 b0[] = { reg }; | |
47 | u8 b1[] = { 0 }; | |
48 | struct i2c_msg msg[] = { | |
49 | { .addr = config->addr, .flags = 0, .buf = b0, .len = 1 }, | |
50 | { .addr = config->addr, .flags = I2C_M_RD, .buf = b1, .len = 1 } | |
51 | }; | |
52 | ||
53 | ret = i2c_transfer(stv6110x->i2c, msg, 2); | |
54 | if (ret != 2) { | |
55 | dprintk(FE_ERROR, 1, "I/O Error"); | |
56 | return -EREMOTEIO; | |
57 | } | |
f2b2fd40 | 58 | *data = b1[0]; |
e415c689 MA |
59 | |
60 | return 0; | |
61 | } | |
62 | ||
0c3f9fd8 | 63 | static int stv6110x_write_regs(struct stv6110x_state *stv6110x, int start, u8 data[], int len) |
e415c689 MA |
64 | { |
65 | int ret; | |
66 | const struct stv6110x_config *config = stv6110x->config; | |
8393796d MCC |
67 | u8 buf[MAX_XFER_SIZE]; |
68 | ||
0c3f9fd8 AR |
69 | struct i2c_msg msg = { |
70 | .addr = config->addr, | |
71 | .flags = 0, | |
72 | .buf = buf, | |
73 | .len = len + 1 | |
74 | }; | |
75 | ||
8393796d MCC |
76 | if (1 + len > sizeof(buf)) { |
77 | printk(KERN_WARNING | |
78 | "%s: i2c wr: len=%d is too big!\n", | |
79 | KBUILD_MODNAME, len); | |
80 | return -EINVAL; | |
81 | } | |
82 | ||
0c3f9fd8 AR |
83 | if (start + len > 8) |
84 | return -EINVAL; | |
85 | ||
86 | buf[0] = start; | |
87 | memcpy(&buf[1], data, len); | |
e415c689 MA |
88 | |
89 | ret = i2c_transfer(stv6110x->i2c, &msg, 1); | |
90 | if (ret != 1) { | |
91 | dprintk(FE_ERROR, 1, "I/O Error"); | |
92 | return -EREMOTEIO; | |
93 | } | |
94 | ||
95 | return 0; | |
96 | } | |
97 | ||
0c3f9fd8 AR |
98 | static int stv6110x_write_reg(struct stv6110x_state *stv6110x, u8 reg, u8 data) |
99 | { | |
100 | return stv6110x_write_regs(stv6110x, reg, &data, 1); | |
101 | } | |
102 | ||
e415c689 MA |
103 | static int stv6110x_init(struct dvb_frontend *fe) |
104 | { | |
105 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
106 | int ret; | |
e415c689 | 107 | |
ec2d3a62 AR |
108 | ret = stv6110x_write_regs(stv6110x, 0, stv6110x->regs, |
109 | ARRAY_SIZE(stv6110x->regs)); | |
0c3f9fd8 AR |
110 | if (ret < 0) { |
111 | dprintk(FE_ERROR, 1, "Initialization failed"); | |
112 | return -1; | |
e415c689 MA |
113 | } |
114 | ||
115 | return 0; | |
116 | } | |
117 | ||
118 | static int stv6110x_set_frequency(struct dvb_frontend *fe, u32 frequency) | |
119 | { | |
120 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
121 | u32 rDiv, divider; | |
7c236e37 | 122 | s32 pVal, pCalc, rDivOpt = 0, pCalcOpt = 1000; |
e415c689 MA |
123 | u8 i; |
124 | ||
ec2d3a62 | 125 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_K, (REFCLOCK_MHz - 16)); |
e415c689 MA |
126 | |
127 | if (frequency <= 1023000) { | |
ec2d3a62 AR |
128 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 1); |
129 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 0); | |
e415c689 MA |
130 | pVal = 40; |
131 | } else if (frequency <= 1300000) { | |
ec2d3a62 AR |
132 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 1); |
133 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 1); | |
e415c689 MA |
134 | pVal = 40; |
135 | } else if (frequency <= 2046000) { | |
ec2d3a62 AR |
136 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 0); |
137 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 0); | |
e415c689 MA |
138 | pVal = 20; |
139 | } else { | |
ec2d3a62 AR |
140 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_DIV4SEL, 0); |
141 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_PRESC32_ON, 1); | |
e415c689 MA |
142 | pVal = 20; |
143 | } | |
144 | ||
145 | for (rDiv = 0; rDiv <= 3; rDiv++) { | |
146 | pCalc = (REFCLOCK_kHz / 100) / R_DIV(rDiv); | |
147 | ||
7c236e37 | 148 | if ((abs((s32)(pCalc - pVal))) < (abs((s32)(pCalcOpt - pVal)))) |
e415c689 | 149 | rDivOpt = rDiv; |
7c236e37 AR |
150 | |
151 | pCalcOpt = (REFCLOCK_kHz / 100) / R_DIV(rDivOpt); | |
e415c689 MA |
152 | } |
153 | ||
154 | divider = (frequency * R_DIV(rDivOpt) * pVal) / REFCLOCK_kHz; | |
155 | divider = (divider + 5) / 10; | |
156 | ||
ec2d3a62 AR |
157 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_R_DIV, rDivOpt); |
158 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG1], TNG1_N_DIV_11_8, MSB(divider)); | |
159 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_TNG0], TNG0_N_DIV_7_0, LSB(divider)); | |
e415c689 MA |
160 | |
161 | /* VCO Auto calibration */ | |
ec2d3a62 | 162 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_STAT1], STAT1_CALVCO_STRT, 1); |
e415c689 | 163 | |
ec2d3a62 AR |
164 | stv6110x_write_reg(stv6110x, STV6110x_CTRL1, stv6110x->regs[STV6110x_CTRL1]); |
165 | stv6110x_write_reg(stv6110x, STV6110x_TNG1, stv6110x->regs[STV6110x_TNG1]); | |
166 | stv6110x_write_reg(stv6110x, STV6110x_TNG0, stv6110x->regs[STV6110x_TNG0]); | |
167 | stv6110x_write_reg(stv6110x, STV6110x_STAT1, stv6110x->regs[STV6110x_STAT1]); | |
e415c689 MA |
168 | |
169 | for (i = 0; i < TRIALS; i++) { | |
ec2d3a62 AR |
170 | stv6110x_read_reg(stv6110x, STV6110x_STAT1, &stv6110x->regs[STV6110x_STAT1]); |
171 | if (!STV6110x_GETFIELD(STAT1_CALVCO_STRT, stv6110x->regs[STV6110x_STAT1])) | |
e415c689 MA |
172 | break; |
173 | msleep(1); | |
174 | } | |
175 | ||
176 | return 0; | |
177 | } | |
178 | ||
179 | static int stv6110x_get_frequency(struct dvb_frontend *fe, u32 *frequency) | |
180 | { | |
181 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
182 | ||
ec2d3a62 AR |
183 | stv6110x_read_reg(stv6110x, STV6110x_TNG1, &stv6110x->regs[STV6110x_TNG1]); |
184 | stv6110x_read_reg(stv6110x, STV6110x_TNG0, &stv6110x->regs[STV6110x_TNG0]); | |
e415c689 | 185 | |
ec2d3a62 AR |
186 | *frequency = (MAKEWORD16(STV6110x_GETFIELD(TNG1_N_DIV_11_8, stv6110x->regs[STV6110x_TNG1]), |
187 | STV6110x_GETFIELD(TNG0_N_DIV_7_0, stv6110x->regs[STV6110x_TNG0]))) * REFCLOCK_kHz; | |
e415c689 | 188 | |
ec2d3a62 AR |
189 | *frequency /= (1 << (STV6110x_GETFIELD(TNG1_R_DIV, stv6110x->regs[STV6110x_TNG1]) + |
190 | STV6110x_GETFIELD(TNG1_DIV4SEL, stv6110x->regs[STV6110x_TNG1]))); | |
e415c689 MA |
191 | |
192 | *frequency >>= 2; | |
193 | ||
194 | return 0; | |
195 | } | |
196 | ||
197 | static int stv6110x_set_bandwidth(struct dvb_frontend *fe, u32 bandwidth) | |
198 | { | |
199 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
200 | u32 halfbw; | |
201 | u8 i; | |
202 | ||
203 | halfbw = bandwidth >> 1; | |
204 | ||
205 | if (halfbw > 36000000) | |
ec2d3a62 | 206 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_CF, 31); /* LPF */ |
e415c689 | 207 | else if (halfbw < 5000000) |
ec2d3a62 | 208 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_CF, 0); /* LPF */ |
e415c689 | 209 | else |
ec2d3a62 | 210 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_CF, ((halfbw / 1000000) - 5)); /* LPF */ |
e415c689 MA |
211 | |
212 | ||
ec2d3a62 AR |
213 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_RCCLK_OFF, 0x0); /* cal. clk activated */ |
214 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_STAT1], STAT1_CALRC_STRT, 0x1); /* LPF auto cal */ | |
e415c689 | 215 | |
ec2d3a62 AR |
216 | stv6110x_write_reg(stv6110x, STV6110x_CTRL3, stv6110x->regs[STV6110x_CTRL3]); |
217 | stv6110x_write_reg(stv6110x, STV6110x_STAT1, stv6110x->regs[STV6110x_STAT1]); | |
e415c689 MA |
218 | |
219 | for (i = 0; i < TRIALS; i++) { | |
ec2d3a62 AR |
220 | stv6110x_read_reg(stv6110x, STV6110x_STAT1, &stv6110x->regs[STV6110x_STAT1]); |
221 | if (!STV6110x_GETFIELD(STAT1_CALRC_STRT, stv6110x->regs[STV6110x_STAT1])) | |
e415c689 MA |
222 | break; |
223 | msleep(1); | |
224 | } | |
ec2d3a62 AR |
225 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL3], CTRL3_RCCLK_OFF, 0x1); /* cal. done */ |
226 | stv6110x_write_reg(stv6110x, STV6110x_CTRL3, stv6110x->regs[STV6110x_CTRL3]); | |
e415c689 MA |
227 | |
228 | return 0; | |
229 | } | |
230 | ||
231 | static int stv6110x_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) | |
232 | { | |
233 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
234 | ||
ec2d3a62 AR |
235 | stv6110x_read_reg(stv6110x, STV6110x_CTRL3, &stv6110x->regs[STV6110x_CTRL3]); |
236 | *bandwidth = (STV6110x_GETFIELD(CTRL3_CF, stv6110x->regs[STV6110x_CTRL3]) + 5) * 2000000; | |
e415c689 MA |
237 | |
238 | return 0; | |
239 | } | |
240 | ||
241 | static int stv6110x_set_refclock(struct dvb_frontend *fe, u32 refclock) | |
242 | { | |
243 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
244 | ||
245 | /* setup divider */ | |
246 | switch (refclock) { | |
247 | default: | |
248 | case 1: | |
ec2d3a62 | 249 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 0); |
e415c689 MA |
250 | break; |
251 | case 2: | |
ec2d3a62 | 252 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 1); |
e415c689 MA |
253 | break; |
254 | case 4: | |
ec2d3a62 | 255 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 2); |
e415c689 MA |
256 | break; |
257 | case 8: | |
258 | case 0: | |
ec2d3a62 | 259 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 3); |
e415c689 MA |
260 | break; |
261 | } | |
ec2d3a62 | 262 | stv6110x_write_reg(stv6110x, STV6110x_CTRL2, stv6110x->regs[STV6110x_CTRL2]); |
e415c689 MA |
263 | |
264 | return 0; | |
265 | } | |
266 | ||
267 | static int stv6110x_get_bbgain(struct dvb_frontend *fe, u32 *gain) | |
268 | { | |
269 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
270 | ||
ec2d3a62 AR |
271 | stv6110x_read_reg(stv6110x, STV6110x_CTRL2, &stv6110x->regs[STV6110x_CTRL2]); |
272 | *gain = 2 * STV6110x_GETFIELD(CTRL2_BBGAIN, stv6110x->regs[STV6110x_CTRL2]); | |
e415c689 MA |
273 | |
274 | return 0; | |
275 | } | |
276 | ||
277 | static int stv6110x_set_bbgain(struct dvb_frontend *fe, u32 gain) | |
278 | { | |
279 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
280 | ||
ec2d3a62 AR |
281 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_BBGAIN, gain / 2); |
282 | stv6110x_write_reg(stv6110x, STV6110x_CTRL2, stv6110x->regs[STV6110x_CTRL2]); | |
e415c689 MA |
283 | |
284 | return 0; | |
285 | } | |
286 | ||
287 | static int stv6110x_set_mode(struct dvb_frontend *fe, enum tuner_mode mode) | |
288 | { | |
289 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
290 | int ret; | |
291 | ||
292 | switch (mode) { | |
293 | case TUNER_SLEEP: | |
ec2d3a62 AR |
294 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_SYN, 0); |
295 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_RX, 0); | |
296 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_LPT, 0); | |
e415c689 MA |
297 | break; |
298 | ||
299 | case TUNER_WAKE: | |
ec2d3a62 AR |
300 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_SYN, 1); |
301 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_RX, 1); | |
302 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL1], CTRL1_LPT, 1); | |
e415c689 MA |
303 | break; |
304 | } | |
305 | ||
ec2d3a62 | 306 | ret = stv6110x_write_reg(stv6110x, STV6110x_CTRL1, stv6110x->regs[STV6110x_CTRL1]); |
e415c689 MA |
307 | if (ret < 0) { |
308 | dprintk(FE_ERROR, 1, "I/O Error"); | |
309 | return -EIO; | |
310 | } | |
311 | ||
312 | return 0; | |
313 | } | |
314 | ||
315 | static int stv6110x_sleep(struct dvb_frontend *fe) | |
316 | { | |
e65f8c4e GM |
317 | if (fe->tuner_priv) |
318 | return stv6110x_set_mode(fe, TUNER_SLEEP); | |
319 | ||
320 | return 0; | |
e415c689 MA |
321 | } |
322 | ||
323 | static int stv6110x_get_status(struct dvb_frontend *fe, u32 *status) | |
324 | { | |
325 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
326 | ||
ec2d3a62 | 327 | stv6110x_read_reg(stv6110x, STV6110x_STAT1, &stv6110x->regs[STV6110x_STAT1]); |
e415c689 | 328 | |
ec2d3a62 | 329 | if (STV6110x_GETFIELD(STAT1_LOCK, stv6110x->regs[STV6110x_STAT1])) |
e415c689 MA |
330 | *status = TUNER_PHASELOCKED; |
331 | else | |
332 | *status = 0; | |
333 | ||
334 | return 0; | |
335 | } | |
336 | ||
337 | ||
338 | static int stv6110x_release(struct dvb_frontend *fe) | |
339 | { | |
340 | struct stv6110x_state *stv6110x = fe->tuner_priv; | |
341 | ||
342 | fe->tuner_priv = NULL; | |
343 | kfree(stv6110x); | |
344 | ||
345 | return 0; | |
346 | } | |
347 | ||
348 | static struct dvb_tuner_ops stv6110x_ops = { | |
349 | .info = { | |
350 | .name = "STV6110(A) Silicon Tuner", | |
351 | .frequency_min = 950000, | |
352 | .frequency_max = 2150000, | |
353 | .frequency_step = 0, | |
354 | }, | |
e415c689 MA |
355 | .release = stv6110x_release |
356 | }; | |
357 | ||
358 | static struct stv6110x_devctl stv6110x_ctl = { | |
359 | .tuner_init = stv6110x_init, | |
c5b74b0f | 360 | .tuner_sleep = stv6110x_sleep, |
e415c689 MA |
361 | .tuner_set_mode = stv6110x_set_mode, |
362 | .tuner_set_frequency = stv6110x_set_frequency, | |
363 | .tuner_get_frequency = stv6110x_get_frequency, | |
364 | .tuner_set_bandwidth = stv6110x_set_bandwidth, | |
365 | .tuner_get_bandwidth = stv6110x_get_bandwidth, | |
366 | .tuner_set_bbgain = stv6110x_set_bbgain, | |
367 | .tuner_get_bbgain = stv6110x_get_bbgain, | |
368 | .tuner_set_refclk = stv6110x_set_refclock, | |
369 | .tuner_get_status = stv6110x_get_status, | |
370 | }; | |
371 | ||
372 | struct stv6110x_devctl *stv6110x_attach(struct dvb_frontend *fe, | |
373 | const struct stv6110x_config *config, | |
374 | struct i2c_adapter *i2c) | |
375 | { | |
376 | struct stv6110x_state *stv6110x; | |
ec2d3a62 | 377 | u8 default_regs[] = {0x07, 0x11, 0xdc, 0x85, 0x17, 0x01, 0xe6, 0x1e}; |
e415c689 MA |
378 | |
379 | stv6110x = kzalloc(sizeof (struct stv6110x_state), GFP_KERNEL); | |
83b6601c DC |
380 | if (!stv6110x) |
381 | return NULL; | |
e415c689 MA |
382 | |
383 | stv6110x->i2c = i2c; | |
384 | stv6110x->config = config; | |
385 | stv6110x->devctl = &stv6110x_ctl; | |
ec2d3a62 | 386 | memcpy(stv6110x->regs, default_regs, 8); |
e415c689 | 387 | |
ca108b39 AR |
388 | /* setup divider */ |
389 | switch (stv6110x->config->clk_div) { | |
390 | default: | |
391 | case 1: | |
392 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 0); | |
393 | break; | |
394 | case 2: | |
395 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 1); | |
396 | break; | |
397 | case 4: | |
398 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 2); | |
399 | break; | |
400 | case 8: | |
401 | case 0: | |
402 | STV6110x_SETFIELD(stv6110x->regs[STV6110x_CTRL2], CTRL2_CO_DIV, 3); | |
403 | break; | |
404 | } | |
405 | ||
e415c689 MA |
406 | fe->tuner_priv = stv6110x; |
407 | fe->ops.tuner_ops = stv6110x_ops; | |
408 | ||
83b6601c | 409 | printk(KERN_INFO "%s: Attaching STV6110x\n", __func__); |
e415c689 | 410 | return stv6110x->devctl; |
e415c689 MA |
411 | } |
412 | EXPORT_SYMBOL(stv6110x_attach); | |
413 | ||
414 | MODULE_AUTHOR("Manu Abraham"); | |
415 | MODULE_DESCRIPTION("STV6110x Silicon tuner"); | |
416 | MODULE_LICENSE("GPL"); |