Commit | Line | Data |
---|---|---|
3c01ad20 | 1 | // SPDX-License-Identifier: GPL-2.0 |
44173fda DS |
2 | /* |
3 | * Driver for the ST STV6111 tuner | |
4 | * | |
5 | * Copyright (C) 2014 Digital Devices GmbH | |
6 | * | |
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. | |
10 | * | |
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. | |
44173fda DS |
15 | */ |
16 | ||
17 | #include <linux/kernel.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/moduleparam.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/delay.h> | |
22 | #include <linux/firmware.h> | |
23 | #include <linux/i2c.h> | |
24 | #include <asm/div64.h> | |
25 | ||
26 | #include "stv6111.h" | |
27 | ||
fada1935 | 28 | #include <media/dvb_frontend.h> |
44173fda DS |
29 | |
30 | struct stv { | |
31 | struct i2c_adapter *i2c; | |
32 | u8 adr; | |
33 | ||
34 | u8 reg[11]; | |
35 | u32 ref_freq; | |
36 | u32 frequency; | |
37 | }; | |
38 | ||
39 | struct slookup { | |
40 | s16 value; | |
41 | u16 reg_value; | |
42 | }; | |
43 | ||
20e671df | 44 | static const struct slookup lnagain_nf_lookup[] = { |
85e36b47 | 45 | /* Gain *100dB // Reg */ |
44173fda DS |
46 | { 2572, 0 }, |
47 | { 2575, 1 }, | |
48 | { 2580, 2 }, | |
49 | { 2588, 3 }, | |
50 | { 2596, 4 }, | |
51 | { 2611, 5 }, | |
52 | { 2633, 6 }, | |
53 | { 2664, 7 }, | |
54 | { 2701, 8 }, | |
55 | { 2753, 9 }, | |
56 | { 2816, 10 }, | |
57 | { 2902, 11 }, | |
58 | { 2995, 12 }, | |
59 | { 3104, 13 }, | |
60 | { 3215, 14 }, | |
61 | { 3337, 15 }, | |
62 | { 3492, 16 }, | |
63 | { 3614, 17 }, | |
64 | { 3731, 18 }, | |
65 | { 3861, 19 }, | |
66 | { 3988, 20 }, | |
67 | { 4124, 21 }, | |
68 | { 4253, 22 }, | |
69 | { 4386, 23 }, | |
70 | { 4505, 24 }, | |
71 | { 4623, 25 }, | |
72 | { 4726, 26 }, | |
73 | { 4821, 27 }, | |
74 | { 4903, 28 }, | |
75 | { 4979, 29 }, | |
76 | { 5045, 30 }, | |
77 | { 5102, 31 } | |
78 | }; | |
79 | ||
20e671df | 80 | static const struct slookup lnagain_iip3_lookup[] = { |
85e36b47 | 81 | /* Gain *100dB // reg */ |
44173fda DS |
82 | { 1548, 0 }, |
83 | { 1552, 1 }, | |
84 | { 1569, 2 }, | |
85 | { 1565, 3 }, | |
86 | { 1577, 4 }, | |
87 | { 1594, 5 }, | |
88 | { 1627, 6 }, | |
89 | { 1656, 7 }, | |
90 | { 1700, 8 }, | |
91 | { 1748, 9 }, | |
92 | { 1805, 10 }, | |
93 | { 1896, 11 }, | |
94 | { 1995, 12 }, | |
95 | { 2113, 13 }, | |
96 | { 2233, 14 }, | |
97 | { 2366, 15 }, | |
98 | { 2543, 16 }, | |
99 | { 2687, 17 }, | |
100 | { 2842, 18 }, | |
101 | { 2999, 19 }, | |
102 | { 3167, 20 }, | |
103 | { 3342, 21 }, | |
104 | { 3507, 22 }, | |
105 | { 3679, 23 }, | |
106 | { 3827, 24 }, | |
107 | { 3970, 25 }, | |
108 | { 4094, 26 }, | |
109 | { 4210, 27 }, | |
110 | { 4308, 28 }, | |
111 | { 4396, 29 }, | |
112 | { 4468, 30 }, | |
113 | { 4535, 31 } | |
114 | }; | |
115 | ||
20e671df | 116 | static const struct slookup gain_rfagc_lookup[] = { |
85e36b47 | 117 | /* Gain *100dB // reg */ |
44173fda DS |
118 | { 4870, 0x3000 }, |
119 | { 4850, 0x3C00 }, | |
120 | { 4800, 0x4500 }, | |
121 | { 4750, 0x4800 }, | |
122 | { 4700, 0x4B00 }, | |
123 | { 4650, 0x4D00 }, | |
124 | { 4600, 0x4F00 }, | |
125 | { 4550, 0x5100 }, | |
126 | { 4500, 0x5200 }, | |
127 | { 4420, 0x5500 }, | |
128 | { 4316, 0x5800 }, | |
129 | { 4200, 0x5B00 }, | |
130 | { 4119, 0x5D00 }, | |
131 | { 3999, 0x6000 }, | |
132 | { 3950, 0x6100 }, | |
133 | { 3876, 0x6300 }, | |
134 | { 3755, 0x6600 }, | |
135 | { 3641, 0x6900 }, | |
136 | { 3567, 0x6B00 }, | |
137 | { 3425, 0x6F00 }, | |
138 | { 3350, 0x7100 }, | |
139 | { 3236, 0x7400 }, | |
140 | { 3118, 0x7700 }, | |
141 | { 3004, 0x7A00 }, | |
142 | { 2917, 0x7C00 }, | |
143 | { 2776, 0x7F00 }, | |
144 | { 2635, 0x8200 }, | |
145 | { 2516, 0x8500 }, | |
146 | { 2406, 0x8800 }, | |
147 | { 2290, 0x8B00 }, | |
148 | { 2170, 0x8E00 }, | |
149 | { 2073, 0x9100 }, | |
150 | { 1949, 0x9400 }, | |
151 | { 1836, 0x9700 }, | |
152 | { 1712, 0x9A00 }, | |
153 | { 1631, 0x9C00 }, | |
154 | { 1515, 0x9F00 }, | |
155 | { 1400, 0xA200 }, | |
156 | { 1323, 0xA400 }, | |
157 | { 1203, 0xA700 }, | |
158 | { 1091, 0xAA00 }, | |
159 | { 1011, 0xAC00 }, | |
160 | { 904, 0xAF00 }, | |
161 | { 787, 0xB200 }, | |
162 | { 685, 0xB500 }, | |
163 | { 571, 0xB800 }, | |
164 | { 464, 0xBB00 }, | |
165 | { 374, 0xBE00 }, | |
166 | { 275, 0xC200 }, | |
167 | { 181, 0xC600 }, | |
168 | { 102, 0xCC00 }, | |
169 | { 49, 0xD900 } | |
170 | }; | |
171 | ||
172 | /* | |
173 | * This table is 6 dB too low comapred to the others (probably created with | |
174 | * a different BB_MAG setting) | |
175 | */ | |
20e671df | 176 | static const struct slookup gain_channel_agc_nf_lookup[] = { |
85e36b47 | 177 | /* Gain *100dB // reg */ |
44173fda DS |
178 | { 7082, 0x3000 }, |
179 | { 7052, 0x4000 }, | |
180 | { 7007, 0x4600 }, | |
181 | { 6954, 0x4A00 }, | |
182 | { 6909, 0x4D00 }, | |
183 | { 6833, 0x5100 }, | |
184 | { 6753, 0x5400 }, | |
185 | { 6659, 0x5700 }, | |
186 | { 6561, 0x5A00 }, | |
187 | { 6472, 0x5C00 }, | |
188 | { 6366, 0x5F00 }, | |
189 | { 6259, 0x6100 }, | |
190 | { 6151, 0x6400 }, | |
191 | { 6026, 0x6700 }, | |
192 | { 5920, 0x6900 }, | |
193 | { 5835, 0x6B00 }, | |
194 | { 5770, 0x6C00 }, | |
195 | { 5681, 0x6E00 }, | |
196 | { 5596, 0x7000 }, | |
197 | { 5503, 0x7200 }, | |
198 | { 5429, 0x7300 }, | |
199 | { 5319, 0x7500 }, | |
200 | { 5220, 0x7700 }, | |
201 | { 5111, 0x7900 }, | |
202 | { 4983, 0x7B00 }, | |
203 | { 4876, 0x7D00 }, | |
204 | { 4755, 0x7F00 }, | |
205 | { 4635, 0x8100 }, | |
206 | { 4499, 0x8300 }, | |
207 | { 4405, 0x8500 }, | |
208 | { 4323, 0x8600 }, | |
209 | { 4233, 0x8800 }, | |
210 | { 4156, 0x8A00 }, | |
211 | { 4038, 0x8C00 }, | |
212 | { 3935, 0x8E00 }, | |
213 | { 3823, 0x9000 }, | |
214 | { 3712, 0x9200 }, | |
215 | { 3601, 0x9500 }, | |
216 | { 3511, 0x9700 }, | |
217 | { 3413, 0x9900 }, | |
218 | { 3309, 0x9B00 }, | |
219 | { 3213, 0x9D00 }, | |
220 | { 3088, 0x9F00 }, | |
221 | { 2992, 0xA100 }, | |
222 | { 2878, 0xA400 }, | |
223 | { 2769, 0xA700 }, | |
224 | { 2645, 0xAA00 }, | |
225 | { 2538, 0xAD00 }, | |
226 | { 2441, 0xB000 }, | |
227 | { 2350, 0xB600 }, | |
228 | { 2237, 0xBA00 }, | |
229 | { 2137, 0xBF00 }, | |
230 | { 2039, 0xC500 }, | |
231 | { 1938, 0xDF00 }, | |
232 | { 1927, 0xFF00 } | |
233 | }; | |
234 | ||
20e671df | 235 | static const struct slookup gain_channel_agc_iip3_lookup[] = { |
85e36b47 | 236 | /* Gain *100dB // reg */ |
44173fda DS |
237 | { 7070, 0x3000 }, |
238 | { 7028, 0x4000 }, | |
239 | { 7019, 0x4600 }, | |
240 | { 6900, 0x4A00 }, | |
241 | { 6811, 0x4D00 }, | |
242 | { 6763, 0x5100 }, | |
243 | { 6690, 0x5400 }, | |
244 | { 6644, 0x5700 }, | |
245 | { 6617, 0x5A00 }, | |
246 | { 6598, 0x5C00 }, | |
247 | { 6462, 0x5F00 }, | |
248 | { 6348, 0x6100 }, | |
249 | { 6197, 0x6400 }, | |
250 | { 6154, 0x6700 }, | |
251 | { 6098, 0x6900 }, | |
252 | { 5893, 0x6B00 }, | |
253 | { 5812, 0x6C00 }, | |
254 | { 5773, 0x6E00 }, | |
255 | { 5723, 0x7000 }, | |
256 | { 5661, 0x7200 }, | |
257 | { 5579, 0x7300 }, | |
258 | { 5460, 0x7500 }, | |
259 | { 5308, 0x7700 }, | |
260 | { 5099, 0x7900 }, | |
261 | { 4910, 0x7B00 }, | |
262 | { 4800, 0x7D00 }, | |
263 | { 4785, 0x7F00 }, | |
264 | { 4635, 0x8100 }, | |
265 | { 4466, 0x8300 }, | |
266 | { 4314, 0x8500 }, | |
267 | { 4295, 0x8600 }, | |
268 | { 4144, 0x8800 }, | |
269 | { 3920, 0x8A00 }, | |
270 | { 3889, 0x8C00 }, | |
271 | { 3771, 0x8E00 }, | |
272 | { 3655, 0x9000 }, | |
273 | { 3446, 0x9200 }, | |
274 | { 3298, 0x9500 }, | |
275 | { 3083, 0x9700 }, | |
276 | { 3015, 0x9900 }, | |
277 | { 2833, 0x9B00 }, | |
278 | { 2746, 0x9D00 }, | |
279 | { 2632, 0x9F00 }, | |
280 | { 2598, 0xA100 }, | |
281 | { 2480, 0xA400 }, | |
282 | { 2236, 0xA700 }, | |
283 | { 2171, 0xAA00 }, | |
284 | { 2060, 0xAD00 }, | |
285 | { 1999, 0xB000 }, | |
286 | { 1974, 0xB600 }, | |
287 | { 1820, 0xBA00 }, | |
288 | { 1741, 0xBF00 }, | |
289 | { 1655, 0xC500 }, | |
290 | { 1444, 0xDF00 }, | |
291 | { 1325, 0xFF00 }, | |
292 | }; | |
293 | ||
294 | static inline u32 muldiv32(u32 a, u32 b, u32 c) | |
295 | { | |
296 | u64 tmp64; | |
297 | ||
298 | tmp64 = (u64)a * (u64)b; | |
299 | do_div(tmp64, c); | |
300 | ||
2af07a49 | 301 | return (u32)tmp64; |
44173fda DS |
302 | } |
303 | ||
304 | static int i2c_read(struct i2c_adapter *adap, | |
305 | u8 adr, u8 *msg, int len, u8 *answ, int alen) | |
306 | { | |
307 | struct i2c_msg msgs[2] = { { .addr = adr, .flags = 0, | |
308 | .buf = msg, .len = len}, | |
309 | { .addr = adr, .flags = I2C_M_RD, | |
310 | .buf = answ, .len = alen } }; | |
311 | if (i2c_transfer(adap, msgs, 2) != 2) { | |
312 | dev_err(&adap->dev, "i2c read error\n"); | |
313 | return -EIO; | |
314 | } | |
315 | return 0; | |
316 | } | |
317 | ||
318 | static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len) | |
319 | { | |
320 | struct i2c_msg msg = {.addr = adr, .flags = 0, | |
321 | .buf = data, .len = len}; | |
322 | ||
323 | if (i2c_transfer(adap, &msg, 1) != 1) { | |
324 | dev_err(&adap->dev, "i2c write error\n"); | |
325 | return -EIO; | |
326 | } | |
327 | return 0; | |
328 | } | |
329 | ||
330 | static int write_regs(struct stv *state, int reg, int len) | |
331 | { | |
332 | u8 d[12]; | |
333 | ||
334 | memcpy(&d[1], &state->reg[reg], len); | |
335 | d[0] = reg; | |
336 | return i2c_write(state->i2c, state->adr, d, len + 1); | |
337 | } | |
338 | ||
339 | static int write_reg(struct stv *state, u8 reg, u8 val) | |
340 | { | |
341 | u8 d[2] = {reg, val}; | |
342 | ||
343 | return i2c_write(state->i2c, state->adr, d, 2); | |
344 | } | |
345 | ||
346 | static int read_reg(struct stv *state, u8 reg, u8 *val) | |
347 | { | |
348 | return i2c_read(state->i2c, state->adr, ®, 1, val, 1); | |
349 | } | |
350 | ||
351 | static int wait_for_call_done(struct stv *state, u8 mask) | |
352 | { | |
353 | int status = 0; | |
354 | u32 lock_retry_count = 10; | |
355 | ||
356 | while (lock_retry_count > 0) { | |
357 | u8 regval; | |
358 | ||
359 | status = read_reg(state, 9, ®val); | |
360 | if (status < 0) | |
361 | return status; | |
362 | ||
363 | if ((regval & mask) == 0) | |
364 | break; | |
365 | usleep_range(4000, 6000); | |
366 | lock_retry_count -= 1; | |
367 | ||
368 | status = -EIO; | |
369 | } | |
370 | return status; | |
371 | } | |
372 | ||
373 | static void init_state(struct stv *state) | |
374 | { | |
375 | u32 clkdiv = 0; | |
376 | u32 agcmode = 0; | |
377 | u32 agcref = 2; | |
378 | u32 agcset = 0xffffffff; | |
379 | u32 bbmode = 0xffffffff; | |
380 | ||
381 | state->reg[0] = 0x08; | |
382 | state->reg[1] = 0x41; | |
383 | state->reg[2] = 0x8f; | |
384 | state->reg[3] = 0x00; | |
385 | state->reg[4] = 0xce; | |
386 | state->reg[5] = 0x54; | |
387 | state->reg[6] = 0x55; | |
388 | state->reg[7] = 0x45; | |
389 | state->reg[8] = 0x46; | |
390 | state->reg[9] = 0xbd; | |
391 | state->reg[10] = 0x11; | |
392 | ||
393 | state->ref_freq = 16000; | |
394 | ||
395 | if (clkdiv <= 3) | |
396 | state->reg[0x00] |= (clkdiv & 0x03); | |
397 | if (agcmode <= 3) { | |
398 | state->reg[0x03] |= (agcmode << 5); | |
399 | if (agcmode == 0x01) | |
400 | state->reg[0x01] |= 0x30; | |
401 | } | |
402 | if (bbmode <= 3) | |
403 | state->reg[0x01] = (state->reg[0x01] & ~0x30) | (bbmode << 4); | |
404 | if (agcref <= 7) | |
405 | state->reg[0x03] |= agcref; | |
406 | if (agcset <= 31) | |
407 | state->reg[0x02] = (state->reg[0x02] & ~0x1F) | agcset | 0x40; | |
408 | } | |
409 | ||
410 | static int attach_init(struct stv *state) | |
411 | { | |
412 | if (write_regs(state, 0, 11)) | |
413 | return -ENODEV; | |
414 | return 0; | |
415 | } | |
416 | ||
417 | static void release(struct dvb_frontend *fe) | |
418 | { | |
419 | kfree(fe->tuner_priv); | |
420 | fe->tuner_priv = NULL; | |
421 | } | |
422 | ||
423 | static int set_bandwidth(struct dvb_frontend *fe, u32 cutoff_frequency) | |
424 | { | |
425 | struct stv *state = fe->tuner_priv; | |
426 | u32 index = (cutoff_frequency + 999999) / 1000000; | |
fd7849d7 | 427 | int stat = 0; |
44173fda DS |
428 | |
429 | if (index < 6) | |
430 | index = 6; | |
431 | if (index > 50) | |
432 | index = 50; | |
2af07a49 | 433 | if ((state->reg[0x08] & ~0xFC) == ((index - 6) << 2)) |
44173fda DS |
434 | return 0; |
435 | ||
2af07a49 | 436 | state->reg[0x08] = (state->reg[0x08] & ~0xFC) | ((index - 6) << 2); |
44173fda DS |
437 | state->reg[0x09] = (state->reg[0x09] & ~0x0C) | 0x08; |
438 | if (fe->ops.i2c_gate_ctrl) | |
fd7849d7 DS |
439 | stat = fe->ops.i2c_gate_ctrl(fe, 1); |
440 | if (!stat) { | |
441 | write_regs(state, 0x08, 2); | |
442 | wait_for_call_done(state, 0x08); | |
443 | } | |
444 | if (fe->ops.i2c_gate_ctrl && !stat) | |
44173fda | 445 | fe->ops.i2c_gate_ctrl(fe, 0); |
fd7849d7 | 446 | return stat; |
44173fda DS |
447 | } |
448 | ||
449 | static int set_lof(struct stv *state, u32 local_frequency, u32 cutoff_frequency) | |
450 | { | |
451 | u32 index = (cutoff_frequency + 999999) / 1000000; | |
452 | u32 frequency = (local_frequency + 500) / 1000; | |
453 | u32 p = 1, psel = 0, fvco, div, frac; | |
454 | u8 icp, tmp; | |
455 | ||
456 | if (index < 6) | |
457 | index = 6; | |
458 | if (index > 50) | |
459 | index = 50; | |
460 | ||
461 | if (frequency <= 1300000) { | |
462 | p = 4; | |
463 | psel = 1; | |
464 | } else { | |
465 | p = 2; | |
466 | psel = 0; | |
467 | } | |
468 | fvco = frequency * p; | |
469 | div = fvco / state->ref_freq; | |
470 | frac = fvco % state->ref_freq; | |
471 | frac = muldiv32(frac, 0x40000, state->ref_freq); | |
472 | ||
473 | icp = 0; | |
474 | if (fvco < 2700000) | |
475 | icp = 0; | |
476 | else if (fvco < 2950000) | |
477 | icp = 1; | |
478 | else if (fvco < 3300000) | |
479 | icp = 2; | |
480 | else if (fvco < 3700000) | |
481 | icp = 3; | |
482 | else if (fvco < 4200000) | |
483 | icp = 5; | |
484 | else if (fvco < 4800000) | |
485 | icp = 6; | |
486 | else | |
487 | icp = 7; | |
488 | ||
85e36b47 | 489 | state->reg[0x02] |= 0x80; /* LNA IIP3 Mode */ |
44173fda DS |
490 | |
491 | state->reg[0x03] = (state->reg[0x03] & ~0x80) | (psel << 7); | |
492 | state->reg[0x04] = (div & 0xFF); | |
493 | state->reg[0x05] = (((div >> 8) & 0x01) | ((frac & 0x7F) << 1)) & 0xff; | |
494 | state->reg[0x06] = ((frac >> 7) & 0xFF); | |
495 | state->reg[0x07] = (state->reg[0x07] & ~0x07) | ((frac >> 15) & 0x07); | |
496 | state->reg[0x07] = (state->reg[0x07] & ~0xE0) | (icp << 5); | |
497 | ||
498 | state->reg[0x08] = (state->reg[0x08] & ~0xFC) | ((index - 6) << 2); | |
499 | /* Start cal vco,CF */ | |
500 | state->reg[0x09] = (state->reg[0x09] & ~0x0C) | 0x0C; | |
501 | write_regs(state, 2, 8); | |
502 | ||
503 | wait_for_call_done(state, 0x0C); | |
504 | ||
505 | usleep_range(10000, 12000); | |
506 | ||
507 | read_reg(state, 0x03, &tmp); | |
508 | if (tmp & 0x10) { | |
85e36b47 | 509 | state->reg[0x02] &= ~0x80; /* LNA NF Mode */ |
44173fda DS |
510 | write_regs(state, 2, 1); |
511 | } | |
512 | read_reg(state, 0x08, &tmp); | |
513 | ||
514 | state->frequency = frequency; | |
515 | ||
516 | return 0; | |
517 | } | |
518 | ||
519 | static int set_params(struct dvb_frontend *fe) | |
520 | { | |
521 | struct stv *state = fe->tuner_priv; | |
522 | struct dtv_frontend_properties *p = &fe->dtv_property_cache; | |
523 | u32 freq, cutoff; | |
fd7849d7 | 524 | int stat = 0; |
44173fda DS |
525 | |
526 | if (p->delivery_system != SYS_DVBS && p->delivery_system != SYS_DVBS2) | |
527 | return -EINVAL; | |
528 | ||
529 | freq = p->frequency * 1000; | |
530 | cutoff = 5000000 + muldiv32(p->symbol_rate, 135, 200); | |
531 | ||
532 | if (fe->ops.i2c_gate_ctrl) | |
fd7849d7 DS |
533 | stat = fe->ops.i2c_gate_ctrl(fe, 1); |
534 | if (!stat) | |
535 | set_lof(state, freq, cutoff); | |
536 | if (fe->ops.i2c_gate_ctrl && !stat) | |
44173fda DS |
537 | fe->ops.i2c_gate_ctrl(fe, 0); |
538 | return 0; | |
539 | } | |
540 | ||
20e671df DS |
541 | static s32 table_lookup(const struct slookup *table, |
542 | int table_size, u16 reg_value) | |
44173fda DS |
543 | { |
544 | s32 gain; | |
545 | s32 reg_diff; | |
546 | int imin = 0; | |
547 | int imax = table_size - 1; | |
548 | int i; | |
549 | ||
550 | /* Assumes Table[0].RegValue < Table[imax].RegValue */ | |
2af07a49 | 551 | if (reg_value <= table[0].reg_value) { |
44173fda | 552 | gain = table[0].value; |
2af07a49 | 553 | } else if (reg_value >= table[imax].reg_value) { |
44173fda | 554 | gain = table[imax].value; |
2af07a49 DS |
555 | } else { |
556 | while ((imax - imin) > 1) { | |
44173fda DS |
557 | i = (imax + imin) / 2; |
558 | if ((table[imin].reg_value <= reg_value) && | |
559 | (reg_value <= table[i].reg_value)) | |
560 | imax = i; | |
561 | else | |
562 | imin = i; | |
563 | } | |
564 | reg_diff = table[imax].reg_value - table[imin].reg_value; | |
565 | gain = table[imin].value; | |
566 | if (reg_diff != 0) | |
2af07a49 | 567 | gain += ((s32)(reg_value - table[imin].reg_value) * |
44173fda | 568 | (s32)(table[imax].value |
2af07a49 | 569 | - table[imin].value)) / reg_diff; |
44173fda DS |
570 | } |
571 | return gain; | |
572 | } | |
573 | ||
574 | static int get_rf_strength(struct dvb_frontend *fe, u16 *st) | |
575 | { | |
576 | struct stv *state = fe->tuner_priv; | |
577 | u16 rfagc = *st; | |
578 | s32 gain; | |
579 | ||
580 | if ((state->reg[0x03] & 0x60) == 0) { | |
581 | /* RF Mode, Read AGC ADC */ | |
582 | u8 reg = 0; | |
fd7849d7 | 583 | int stat = 0; |
44173fda DS |
584 | |
585 | if (fe->ops.i2c_gate_ctrl) | |
fd7849d7 DS |
586 | stat = fe->ops.i2c_gate_ctrl(fe, 1); |
587 | if (!stat) { | |
588 | write_reg(state, 0x02, state->reg[0x02] | 0x20); | |
44173fda | 589 | read_reg(state, 2, ®); |
fd7849d7 DS |
590 | if (reg & 0x20) |
591 | read_reg(state, 2, ®); | |
592 | } | |
593 | if (fe->ops.i2c_gate_ctrl && !stat) | |
44173fda DS |
594 | fe->ops.i2c_gate_ctrl(fe, 0); |
595 | ||
596 | if ((state->reg[0x02] & 0x80) == 0) | |
597 | /* NF */ | |
598 | gain = table_lookup(lnagain_nf_lookup, | |
2af07a49 DS |
599 | ARRAY_SIZE(lnagain_nf_lookup), |
600 | reg & 0x1F); | |
44173fda DS |
601 | else |
602 | /* IIP3 */ | |
603 | gain = table_lookup(lnagain_iip3_lookup, | |
2af07a49 DS |
604 | ARRAY_SIZE(lnagain_iip3_lookup), |
605 | reg & 0x1F); | |
44173fda DS |
606 | |
607 | gain += table_lookup(gain_rfagc_lookup, | |
2af07a49 DS |
608 | ARRAY_SIZE(gain_rfagc_lookup), rfagc); |
609 | ||
44173fda DS |
610 | gain -= 2400; |
611 | } else { | |
612 | /* Channel Mode */ | |
613 | if ((state->reg[0x02] & 0x80) == 0) { | |
614 | /* NF */ | |
2af07a49 DS |
615 | gain = table_lookup( |
616 | gain_channel_agc_nf_lookup, | |
44173fda | 617 | ARRAY_SIZE(gain_channel_agc_nf_lookup), rfagc); |
2af07a49 | 618 | |
44173fda DS |
619 | gain += 600; |
620 | } else { | |
621 | /* IIP3 */ | |
2af07a49 DS |
622 | gain = table_lookup( |
623 | gain_channel_agc_iip3_lookup, | |
44173fda | 624 | ARRAY_SIZE(gain_channel_agc_iip3_lookup), |
2af07a49 | 625 | rfagc); |
44173fda DS |
626 | } |
627 | } | |
628 | ||
629 | if (state->frequency > 0) | |
630 | /* Tilt correction ( 0.00016 dB/MHz ) */ | |
631 | gain -= ((((s32)(state->frequency / 1000) - 1550) * 2) / 12); | |
632 | ||
633 | /* + (BBGain * 10); */ | |
634 | gain += (s32)((state->reg[0x01] & 0xC0) >> 6) * 600 - 1300; | |
635 | ||
636 | if (gain < 0) | |
637 | gain = 0; | |
638 | else if (gain > 10000) | |
639 | gain = 10000; | |
640 | ||
641 | *st = 10000 - gain; | |
642 | ||
643 | return 0; | |
644 | } | |
645 | ||
20e671df | 646 | static const struct dvb_tuner_ops tuner_ops = { |
44173fda | 647 | .info = { |
20e671df | 648 | .name = "ST STV6111", |
a3f90c75 MCC |
649 | .frequency_min_hz = 950 * MHz, |
650 | .frequency_max_hz = 2150 * MHz, | |
44173fda | 651 | }, |
85e36b47 DS |
652 | .set_params = set_params, |
653 | .release = release, | |
654 | .get_rf_strength = get_rf_strength, | |
655 | .set_bandwidth = set_bandwidth, | |
44173fda DS |
656 | }; |
657 | ||
658 | struct dvb_frontend *stv6111_attach(struct dvb_frontend *fe, | |
659 | struct i2c_adapter *i2c, u8 adr) | |
660 | { | |
661 | struct stv *state; | |
fd7849d7 DS |
662 | int stat = -ENODEV; |
663 | int gatestat = 0; | |
44173fda | 664 | |
2af07a49 | 665 | state = kzalloc(sizeof(*state), GFP_KERNEL); |
44173fda DS |
666 | if (!state) |
667 | return NULL; | |
668 | state->adr = adr; | |
669 | state->i2c = i2c; | |
670 | memcpy(&fe->ops.tuner_ops, &tuner_ops, sizeof(struct dvb_tuner_ops)); | |
671 | init_state(state); | |
672 | ||
673 | if (fe->ops.i2c_gate_ctrl) | |
fd7849d7 DS |
674 | gatestat = fe->ops.i2c_gate_ctrl(fe, 1); |
675 | if (!gatestat) | |
676 | stat = attach_init(state); | |
677 | if (fe->ops.i2c_gate_ctrl && !gatestat) | |
44173fda DS |
678 | fe->ops.i2c_gate_ctrl(fe, 0); |
679 | if (stat < 0) { | |
680 | kfree(state); | |
7112b490 | 681 | return NULL; |
44173fda DS |
682 | } |
683 | fe->tuner_priv = state; | |
684 | return fe; | |
685 | } | |
686 | EXPORT_SYMBOL_GPL(stv6111_attach); | |
687 | ||
20e671df | 688 | MODULE_DESCRIPTION("ST STV6111 satellite tuner driver"); |
44173fda | 689 | MODULE_AUTHOR("Ralph Metzler, Manfred Voelkel"); |
229b6ea6 | 690 | MODULE_LICENSE("GPL v2"); |