1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Conexant cx24123/cx24109 - DVB QPSK Satellite demod/tuner driver |
4 | * |
5 | * Copyright (C) 2005 Steven Toth <stoth@linuxtv.org> |
6 | * |
7 | * Support for KWorld DVB-S 100 by Vadim Catana <skystar@moldova.cc> |
8 | * |
9 | * Support for CX24123/CX24113-NIM by Patrick Boettcher <pb@linuxtv.org> |
10 | */ |
11 | |
12 | #include <linux/slab.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/module.h> |
15 | #include <linux/init.h> |
16 | #include <asm/div64.h> |
17 | |
18 | #include <media/dvb_frontend.h> |
19 | #include "cx24123.h" |
20 | |
21 | #define XTAL 10111000 |
22 | |
23 | static int force_band; |
24 | module_param(force_band, int, 0644); |
25 | MODULE_PARM_DESC(force_band, "Force a specific band select " \ |
26 | "(1-9, default:off)." ); |
27 | |
28 | static int debug; |
29 | module_param(debug, int, 0644); |
30 | MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)" ); |
31 | |
32 | #define info(args...) do { printk(KERN_INFO "CX24123: " args); } while (0) |
33 | #define err(args...) do { printk(KERN_ERR "CX24123: " args); } while (0) |
34 | |
35 | #define dprintk(args...) \ |
36 | do { \ |
37 | if (debug) { \ |
38 | printk(KERN_DEBUG "CX24123: %s: ", __func__); \ |
39 | printk(args); \ |
40 | } \ |
41 | } while (0) |
42 | |
43 | struct cx24123_state { |
44 | struct i2c_adapter *i2c; |
45 | const struct cx24123_config *config; |
46 | |
47 | struct dvb_frontend frontend; |
48 | |
49 | /* Some PLL specifics for tuning */ |
50 | u32 VCAarg; |
51 | u32 VGAarg; |
52 | u32 bandselectarg; |
53 | u32 pllarg; |
54 | u32 FILTune; |
55 | |
56 | struct i2c_adapter tuner_i2c_adapter; |
57 | |
58 | u8 demod_rev; |
59 | |
60 | /* The Demod/Tuner can't easily provide these, we cache them */ |
61 | u32 currentfreq; |
62 | u32 currentsymbolrate; |
63 | }; |
64 | |
65 | /* Various tuner defaults need to be established for a given symbol rate Sps */ |
66 | static struct cx24123_AGC_val { |
67 | u32 symbolrate_low; |
68 | u32 symbolrate_high; |
69 | u32 VCAprogdata; |
70 | u32 VGAprogdata; |
71 | u32 FILTune; |
72 | } cx24123_AGC_vals[] = |
73 | { |
74 | { |
75 | .symbolrate_low = 1000000, |
76 | .symbolrate_high = 4999999, |
77 | /* the specs recommend other values for VGA offsets, |
78 | but tests show they are wrong */ |
79 | .VGAprogdata = (1 << 19) | (0x180 << 9) | 0x1e0, |
80 | .VCAprogdata = (2 << 19) | (0x07 << 9) | 0x07, |
81 | .FILTune = 0x27f /* 0.41 V */ |
82 | }, |
83 | { |
84 | .symbolrate_low = 5000000, |
85 | .symbolrate_high = 14999999, |
86 | .VGAprogdata = (1 << 19) | (0x180 << 9) | 0x1e0, |
87 | .VCAprogdata = (2 << 19) | (0x07 << 9) | 0x1f, |
88 | .FILTune = 0x317 /* 0.90 V */ |
89 | }, |
90 | { |
91 | .symbolrate_low = 15000000, |
92 | .symbolrate_high = 45000000, |
93 | .VGAprogdata = (1 << 19) | (0x100 << 9) | 0x180, |
94 | .VCAprogdata = (2 << 19) | (0x07 << 9) | 0x3f, |
95 | .FILTune = 0x145 /* 2.70 V */ |
96 | }, |
97 | }; |
98 | |
99 | /* |
100 | * Various tuner defaults need to be established for a given frequency kHz. |
101 | * fixme: The bounds on the bands do not match the doc in real life. |
102 | * fixme: Some of them have been moved, other might need adjustment. |
103 | */ |
104 | static struct cx24123_bandselect_val { |
105 | u32 freq_low; |
106 | u32 freq_high; |
107 | u32 VCOdivider; |
108 | u32 progdata; |
109 | } cx24123_bandselect_vals[] = |
110 | { |
111 | /* band 1 */ |
112 | { |
113 | .freq_low = 950000, |
114 | .freq_high = 1074999, |
115 | .VCOdivider = 4, |
116 | .progdata = (0 << 19) | (0 << 9) | 0x40, |
117 | }, |
118 | |
119 | /* band 2 */ |
120 | { |
121 | .freq_low = 1075000, |
122 | .freq_high = 1177999, |
123 | .VCOdivider = 4, |
124 | .progdata = (0 << 19) | (0 << 9) | 0x80, |
125 | }, |
126 | |
127 | /* band 3 */ |
128 | { |
129 | .freq_low = 1178000, |
130 | .freq_high = 1295999, |
131 | .VCOdivider = 2, |
132 | .progdata = (0 << 19) | (1 << 9) | 0x01, |
133 | }, |
134 | |
135 | /* band 4 */ |
136 | { |
137 | .freq_low = 1296000, |
138 | .freq_high = 1431999, |
139 | .VCOdivider = 2, |
140 | .progdata = (0 << 19) | (1 << 9) | 0x02, |
141 | }, |
142 | |
143 | /* band 5 */ |
144 | { |
145 | .freq_low = 1432000, |
146 | .freq_high = 1575999, |
147 | .VCOdivider = 2, |
148 | .progdata = (0 << 19) | (1 << 9) | 0x04, |
149 | }, |
150 | |
151 | /* band 6 */ |
152 | { |
153 | .freq_low = 1576000, |
154 | .freq_high = 1717999, |
155 | .VCOdivider = 2, |
156 | .progdata = (0 << 19) | (1 << 9) | 0x08, |
157 | }, |
158 | |
159 | /* band 7 */ |
160 | { |
161 | .freq_low = 1718000, |
162 | .freq_high = 1855999, |
163 | .VCOdivider = 2, |
164 | .progdata = (0 << 19) | (1 << 9) | 0x10, |
165 | }, |
166 | |
167 | /* band 8 */ |
168 | { |
169 | .freq_low = 1856000, |
170 | .freq_high = 2035999, |
171 | .VCOdivider = 2, |
172 | .progdata = (0 << 19) | (1 << 9) | 0x20, |
173 | }, |
174 | |
175 | /* band 9 */ |
176 | { |
177 | .freq_low = 2036000, |
178 | .freq_high = 2150000, |
179 | .VCOdivider = 2, |
180 | .progdata = (0 << 19) | (1 << 9) | 0x40, |
181 | }, |
182 | }; |
183 | |
184 | static struct { |
185 | u8 reg; |
186 | u8 data; |
187 | } cx24123_regdata[] = |
188 | { |
189 | {0x00, 0x03}, /* Reset system */ |
190 | {0x00, 0x00}, /* Clear reset */ |
191 | {0x03, 0x07}, /* QPSK, DVB, Auto Acquisition (default) */ |
192 | {0x04, 0x10}, /* MPEG */ |
193 | {0x05, 0x04}, /* MPEG */ |
194 | {0x06, 0x31}, /* MPEG (default) */ |
195 | {0x0b, 0x00}, /* Freq search start point (default) */ |
196 | {0x0c, 0x00}, /* Demodulator sample gain (default) */ |
197 | {0x0d, 0x7f}, /* Force driver to shift until the maximum (+-10 MHz) */ |
198 | {0x0e, 0x03}, /* Default non-inverted, FEC 3/4 (default) */ |
199 | {0x0f, 0xfe}, /* FEC search mask (all supported codes) */ |
200 | {0x10, 0x01}, /* Default search inversion, no repeat (default) */ |
201 | {0x16, 0x00}, /* Enable reading of frequency */ |
202 | {0x17, 0x01}, /* Enable EsNO Ready Counter */ |
203 | {0x1c, 0x80}, /* Enable error counter */ |
204 | {0x20, 0x00}, /* Tuner burst clock rate = 500KHz */ |
205 | {0x21, 0x15}, /* Tuner burst mode, word length = 0x15 */ |
206 | {0x28, 0x00}, /* Enable FILTERV with positive pol., DiSEqC 2.x off */ |
207 | {0x29, 0x00}, /* DiSEqC LNB_DC off */ |
208 | {0x2a, 0xb0}, /* DiSEqC Parameters (default) */ |
209 | {0x2b, 0x73}, /* DiSEqC Tone Frequency (default) */ |
210 | {0x2c, 0x00}, /* DiSEqC Message (0x2c - 0x31) */ |
211 | {0x2d, 0x00}, |
212 | {0x2e, 0x00}, |
213 | {0x2f, 0x00}, |
214 | {0x30, 0x00}, |
215 | {0x31, 0x00}, |
216 | {0x32, 0x8c}, /* DiSEqC Parameters (default) */ |
217 | {0x33, 0x00}, /* Interrupts off (0x33 - 0x34) */ |
218 | {0x34, 0x00}, |
219 | {0x35, 0x03}, /* DiSEqC Tone Amplitude (default) */ |
220 | {0x36, 0x02}, /* DiSEqC Parameters (default) */ |
221 | {0x37, 0x3a}, /* DiSEqC Parameters (default) */ |
222 | {0x3a, 0x00}, /* Enable AGC accumulator (for signal strength) */ |
223 | {0x44, 0x00}, /* Constellation (default) */ |
224 | {0x45, 0x00}, /* Symbol count (default) */ |
225 | {0x46, 0x0d}, /* Symbol rate estimator on (default) */ |
226 | {0x56, 0xc1}, /* Error Counter = Viterbi BER */ |
227 | {0x57, 0xff}, /* Error Counter Window (default) */ |
228 | {0x5c, 0x20}, /* Acquisition AFC Expiration window (default is 0x10) */ |
229 | {0x67, 0x83}, /* Non-DCII symbol clock */ |
230 | }; |
231 | |
232 | static int cx24123_i2c_writereg(struct cx24123_state *state, |
233 | u8 i2c_addr, int reg, int data) |
234 | { |
235 | u8 buf[] = { reg, data }; |
236 | struct i2c_msg msg = { |
237 | .addr = i2c_addr, .flags = 0, .buf = buf, .len = 2 |
238 | }; |
239 | int err; |
240 | |
241 | /* printk(KERN_DEBUG "wr(%02x): %02x %02x\n", i2c_addr, reg, data); */ |
242 | |
243 | err = i2c_transfer(adap: state->i2c, msgs: &msg, num: 1); |
244 | if (err != 1) { |
245 | printk("%s: writereg error(err == %i, reg == 0x%02x, data == 0x%02x)\n" , |
246 | __func__, err, reg, data); |
247 | return err; |
248 | } |
249 | |
250 | return 0; |
251 | } |
252 | |
253 | static int cx24123_i2c_readreg(struct cx24123_state *state, u8 i2c_addr, u8 reg) |
254 | { |
255 | int ret; |
256 | u8 b = 0; |
257 | struct i2c_msg msg[] = { |
258 | { .addr = i2c_addr, .flags = 0, .buf = ®, .len = 1 }, |
259 | { .addr = i2c_addr, .flags = I2C_M_RD, .buf = &b, .len = 1 } |
260 | }; |
261 | |
262 | ret = i2c_transfer(adap: state->i2c, msgs: msg, num: 2); |
263 | |
264 | if (ret != 2) { |
265 | err("%s: reg=0x%x (error=%d)\n" , __func__, reg, ret); |
266 | return ret; |
267 | } |
268 | |
269 | /* printk(KERN_DEBUG "rd(%02x): %02x %02x\n", i2c_addr, reg, b); */ |
270 | |
271 | return b; |
272 | } |
273 | |
274 | #define cx24123_readreg(state, reg) \ |
275 | cx24123_i2c_readreg(state, state->config->demod_address, reg) |
276 | #define cx24123_writereg(state, reg, val) \ |
277 | cx24123_i2c_writereg(state, state->config->demod_address, reg, val) |
278 | |
279 | static int cx24123_set_inversion(struct cx24123_state *state, |
280 | enum fe_spectral_inversion inversion) |
281 | { |
282 | u8 nom_reg = cx24123_readreg(state, 0x0e); |
283 | u8 auto_reg = cx24123_readreg(state, 0x10); |
284 | |
285 | switch (inversion) { |
286 | case INVERSION_OFF: |
287 | dprintk("inversion off\n" ); |
288 | cx24123_writereg(state, 0x0e, nom_reg & ~0x80); |
289 | cx24123_writereg(state, 0x10, auto_reg | 0x80); |
290 | break; |
291 | case INVERSION_ON: |
292 | dprintk("inversion on\n" ); |
293 | cx24123_writereg(state, 0x0e, nom_reg | 0x80); |
294 | cx24123_writereg(state, 0x10, auto_reg | 0x80); |
295 | break; |
296 | case INVERSION_AUTO: |
297 | dprintk("inversion auto\n" ); |
298 | cx24123_writereg(state, 0x10, auto_reg & ~0x80); |
299 | break; |
300 | default: |
301 | return -EINVAL; |
302 | } |
303 | |
304 | return 0; |
305 | } |
306 | |
307 | static int cx24123_get_inversion(struct cx24123_state *state, |
308 | enum fe_spectral_inversion *inversion) |
309 | { |
310 | u8 val; |
311 | |
312 | val = cx24123_readreg(state, 0x1b) >> 7; |
313 | |
314 | if (val == 0) { |
315 | dprintk("read inversion off\n" ); |
316 | *inversion = INVERSION_OFF; |
317 | } else { |
318 | dprintk("read inversion on\n" ); |
319 | *inversion = INVERSION_ON; |
320 | } |
321 | |
322 | return 0; |
323 | } |
324 | |
325 | static int cx24123_set_fec(struct cx24123_state *state, enum fe_code_rate fec) |
326 | { |
327 | u8 nom_reg = cx24123_readreg(state, 0x0e) & ~0x07; |
328 | |
329 | if (((int)fec < FEC_NONE) || (fec > FEC_AUTO)) |
330 | fec = FEC_AUTO; |
331 | |
332 | /* Set the soft decision threshold */ |
333 | if (fec == FEC_1_2) |
334 | cx24123_writereg(state, 0x43, |
335 | cx24123_readreg(state, 0x43) | 0x01); |
336 | else |
337 | cx24123_writereg(state, 0x43, |
338 | cx24123_readreg(state, 0x43) & ~0x01); |
339 | |
340 | switch (fec) { |
341 | case FEC_1_2: |
342 | dprintk("set FEC to 1/2\n" ); |
343 | cx24123_writereg(state, 0x0e, nom_reg | 0x01); |
344 | cx24123_writereg(state, 0x0f, 0x02); |
345 | break; |
346 | case FEC_2_3: |
347 | dprintk("set FEC to 2/3\n" ); |
348 | cx24123_writereg(state, 0x0e, nom_reg | 0x02); |
349 | cx24123_writereg(state, 0x0f, 0x04); |
350 | break; |
351 | case FEC_3_4: |
352 | dprintk("set FEC to 3/4\n" ); |
353 | cx24123_writereg(state, 0x0e, nom_reg | 0x03); |
354 | cx24123_writereg(state, 0x0f, 0x08); |
355 | break; |
356 | case FEC_4_5: |
357 | dprintk("set FEC to 4/5\n" ); |
358 | cx24123_writereg(state, 0x0e, nom_reg | 0x04); |
359 | cx24123_writereg(state, 0x0f, 0x10); |
360 | break; |
361 | case FEC_5_6: |
362 | dprintk("set FEC to 5/6\n" ); |
363 | cx24123_writereg(state, 0x0e, nom_reg | 0x05); |
364 | cx24123_writereg(state, 0x0f, 0x20); |
365 | break; |
366 | case FEC_6_7: |
367 | dprintk("set FEC to 6/7\n" ); |
368 | cx24123_writereg(state, 0x0e, nom_reg | 0x06); |
369 | cx24123_writereg(state, 0x0f, 0x40); |
370 | break; |
371 | case FEC_7_8: |
372 | dprintk("set FEC to 7/8\n" ); |
373 | cx24123_writereg(state, 0x0e, nom_reg | 0x07); |
374 | cx24123_writereg(state, 0x0f, 0x80); |
375 | break; |
376 | case FEC_AUTO: |
377 | dprintk("set FEC to auto\n" ); |
378 | cx24123_writereg(state, 0x0f, 0xfe); |
379 | break; |
380 | default: |
381 | return -EOPNOTSUPP; |
382 | } |
383 | |
384 | return 0; |
385 | } |
386 | |
387 | static int cx24123_get_fec(struct cx24123_state *state, enum fe_code_rate *fec) |
388 | { |
389 | int ret; |
390 | |
391 | ret = cx24123_readreg(state, 0x1b); |
392 | if (ret < 0) |
393 | return ret; |
394 | ret = ret & 0x07; |
395 | |
396 | switch (ret) { |
397 | case 1: |
398 | *fec = FEC_1_2; |
399 | break; |
400 | case 2: |
401 | *fec = FEC_2_3; |
402 | break; |
403 | case 3: |
404 | *fec = FEC_3_4; |
405 | break; |
406 | case 4: |
407 | *fec = FEC_4_5; |
408 | break; |
409 | case 5: |
410 | *fec = FEC_5_6; |
411 | break; |
412 | case 6: |
413 | *fec = FEC_6_7; |
414 | break; |
415 | case 7: |
416 | *fec = FEC_7_8; |
417 | break; |
418 | default: |
419 | /* this can happen when there's no lock */ |
420 | *fec = FEC_NONE; |
421 | } |
422 | |
423 | return 0; |
424 | } |
425 | |
426 | /* Approximation of closest integer of log2(a/b). It actually gives the |
427 | lowest integer i such that 2^i >= round(a/b) */ |
428 | static u32 cx24123_int_log2(u32 a, u32 b) |
429 | { |
430 | u32 exp, nearest = 0; |
431 | u32 div = a / b; |
432 | if (a % b >= b / 2) |
433 | ++div; |
434 | if (div < (1UL << 31)) { |
435 | for (exp = 1; div > exp; nearest++) |
436 | exp += exp; |
437 | } |
438 | return nearest; |
439 | } |
440 | |
441 | static int cx24123_set_symbolrate(struct cx24123_state *state, u32 srate) |
442 | { |
443 | u64 tmp; |
444 | u32 sample_rate, ratio, sample_gain; |
445 | u8 pll_mult; |
446 | |
447 | /* check if symbol rate is within limits */ |
448 | if ((srate > state->frontend.ops.info.symbol_rate_max) || |
449 | (srate < state->frontend.ops.info.symbol_rate_min)) |
450 | return -EOPNOTSUPP; |
451 | |
452 | /* choose the sampling rate high enough for the required operation, |
453 | while optimizing the power consumed by the demodulator */ |
454 | if (srate < (XTAL*2)/2) |
455 | pll_mult = 2; |
456 | else if (srate < (XTAL*3)/2) |
457 | pll_mult = 3; |
458 | else if (srate < (XTAL*4)/2) |
459 | pll_mult = 4; |
460 | else if (srate < (XTAL*5)/2) |
461 | pll_mult = 5; |
462 | else if (srate < (XTAL*6)/2) |
463 | pll_mult = 6; |
464 | else if (srate < (XTAL*7)/2) |
465 | pll_mult = 7; |
466 | else if (srate < (XTAL*8)/2) |
467 | pll_mult = 8; |
468 | else |
469 | pll_mult = 9; |
470 | |
471 | |
472 | sample_rate = pll_mult * XTAL; |
473 | |
474 | /* SYSSymbolRate[21:0] = (srate << 23) / sample_rate */ |
475 | |
476 | tmp = ((u64)srate) << 23; |
477 | do_div(tmp, sample_rate); |
478 | ratio = (u32) tmp; |
479 | |
480 | cx24123_writereg(state, 0x01, pll_mult * 6); |
481 | |
482 | cx24123_writereg(state, 0x08, (ratio >> 16) & 0x3f); |
483 | cx24123_writereg(state, 0x09, (ratio >> 8) & 0xff); |
484 | cx24123_writereg(state, 0x0a, ratio & 0xff); |
485 | |
486 | /* also set the demodulator sample gain */ |
487 | sample_gain = cx24123_int_log2(a: sample_rate, b: srate); |
488 | tmp = cx24123_readreg(state, 0x0c) & ~0xe0; |
489 | cx24123_writereg(state, 0x0c, tmp | sample_gain << 5); |
490 | |
491 | dprintk("srate=%d, ratio=0x%08x, sample_rate=%i sample_gain=%d\n" , |
492 | srate, ratio, sample_rate, sample_gain); |
493 | |
494 | return 0; |
495 | } |
496 | |
497 | /* |
498 | * Based on the required frequency and symbolrate, the tuner AGC has |
499 | * to be configured and the correct band selected. |
500 | * Calculate those values. |
501 | */ |
502 | static int cx24123_pll_calculate(struct dvb_frontend *fe) |
503 | { |
504 | struct dtv_frontend_properties *p = &fe->dtv_property_cache; |
505 | struct cx24123_state *state = fe->demodulator_priv; |
506 | u32 ndiv = 0, adiv = 0, vco_div = 0; |
507 | int i = 0; |
508 | int pump = 2; |
509 | int band = 0; |
510 | int num_bands = ARRAY_SIZE(cx24123_bandselect_vals); |
511 | struct cx24123_bandselect_val *bsv = NULL; |
512 | struct cx24123_AGC_val *agcv = NULL; |
513 | |
514 | /* Defaults for low freq, low rate */ |
515 | state->VCAarg = cx24123_AGC_vals[0].VCAprogdata; |
516 | state->VGAarg = cx24123_AGC_vals[0].VGAprogdata; |
517 | state->bandselectarg = cx24123_bandselect_vals[0].progdata; |
518 | vco_div = cx24123_bandselect_vals[0].VCOdivider; |
519 | |
520 | /* For the given symbol rate, determine the VCA, VGA and |
521 | * FILTUNE programming bits */ |
522 | for (i = 0; i < ARRAY_SIZE(cx24123_AGC_vals); i++) { |
523 | agcv = &cx24123_AGC_vals[i]; |
524 | if ((agcv->symbolrate_low <= p->symbol_rate) && |
525 | (agcv->symbolrate_high >= p->symbol_rate)) { |
526 | state->VCAarg = agcv->VCAprogdata; |
527 | state->VGAarg = agcv->VGAprogdata; |
528 | state->FILTune = agcv->FILTune; |
529 | } |
530 | } |
531 | |
532 | /* determine the band to use */ |
533 | if (force_band < 1 || force_band > num_bands) { |
534 | for (i = 0; i < num_bands; i++) { |
535 | bsv = &cx24123_bandselect_vals[i]; |
536 | if ((bsv->freq_low <= p->frequency) && |
537 | (bsv->freq_high >= p->frequency)) |
538 | band = i; |
539 | } |
540 | } else |
541 | band = force_band - 1; |
542 | |
543 | state->bandselectarg = cx24123_bandselect_vals[band].progdata; |
544 | vco_div = cx24123_bandselect_vals[band].VCOdivider; |
545 | |
546 | /* determine the charge pump current */ |
547 | if (p->frequency < (cx24123_bandselect_vals[band].freq_low + |
548 | cx24123_bandselect_vals[band].freq_high) / 2) |
549 | pump = 0x01; |
550 | else |
551 | pump = 0x02; |
552 | |
553 | /* Determine the N/A dividers for the requested lband freq (in kHz). */ |
554 | /* Note: the reference divider R=10, frequency is in KHz, |
555 | * XTAL is in Hz */ |
556 | ndiv = (((p->frequency * vco_div * 10) / |
557 | (2 * XTAL / 1000)) / 32) & 0x1ff; |
558 | adiv = (((p->frequency * vco_div * 10) / |
559 | (2 * XTAL / 1000)) % 32) & 0x1f; |
560 | |
561 | if (adiv == 0 && ndiv > 0) |
562 | ndiv--; |
563 | |
564 | /* control bits 11, refdiv 11, charge pump polarity 1, |
565 | * charge pump current, ndiv, adiv */ |
566 | state->pllarg = (3 << 19) | (3 << 17) | (1 << 16) | |
567 | (pump << 14) | (ndiv << 5) | adiv; |
568 | |
569 | return 0; |
570 | } |
571 | |
572 | /* |
573 | * Tuner data is 21 bits long, must be left-aligned in data. |
574 | * Tuner cx24109 is written through a dedicated 3wire interface |
575 | * on the demod chip. |
576 | */ |
577 | static int cx24123_pll_writereg(struct dvb_frontend *fe, u32 data) |
578 | { |
579 | struct cx24123_state *state = fe->demodulator_priv; |
580 | unsigned long timeout; |
581 | |
582 | dprintk("pll writereg called, data=0x%08x\n" , data); |
583 | |
584 | /* align the 21 bytes into to bit23 boundary */ |
585 | data = data << 3; |
586 | |
587 | /* Reset the demod pll word length to 0x15 bits */ |
588 | cx24123_writereg(state, 0x21, 0x15); |
589 | |
590 | /* write the msb 8 bits, wait for the send to be completed */ |
591 | timeout = jiffies + msecs_to_jiffies(m: 40); |
592 | cx24123_writereg(state, 0x22, (data >> 16) & 0xff); |
593 | while ((cx24123_readreg(state, 0x20) & 0x40) == 0) { |
594 | if (time_after(jiffies, timeout)) { |
595 | err("%s: demodulator is not responding, " \ |
596 | "possibly hung, aborting.\n" , __func__); |
597 | return -EREMOTEIO; |
598 | } |
599 | msleep(msecs: 10); |
600 | } |
601 | |
602 | /* send another 8 bytes, wait for the send to be completed */ |
603 | timeout = jiffies + msecs_to_jiffies(m: 40); |
604 | cx24123_writereg(state, 0x22, (data >> 8) & 0xff); |
605 | while ((cx24123_readreg(state, 0x20) & 0x40) == 0) { |
606 | if (time_after(jiffies, timeout)) { |
607 | err("%s: demodulator is not responding, " \ |
608 | "possibly hung, aborting.\n" , __func__); |
609 | return -EREMOTEIO; |
610 | } |
611 | msleep(msecs: 10); |
612 | } |
613 | |
614 | /* send the lower 5 bits of this byte, padded with 3 LBB, |
615 | * wait for the send to be completed */ |
616 | timeout = jiffies + msecs_to_jiffies(m: 40); |
617 | cx24123_writereg(state, 0x22, (data) & 0xff); |
618 | while ((cx24123_readreg(state, 0x20) & 0x80)) { |
619 | if (time_after(jiffies, timeout)) { |
620 | err("%s: demodulator is not responding," \ |
621 | "possibly hung, aborting.\n" , __func__); |
622 | return -EREMOTEIO; |
623 | } |
624 | msleep(msecs: 10); |
625 | } |
626 | |
627 | /* Trigger the demod to configure the tuner */ |
628 | cx24123_writereg(state, 0x20, cx24123_readreg(state, 0x20) | 2); |
629 | cx24123_writereg(state, 0x20, cx24123_readreg(state, 0x20) & 0xfd); |
630 | |
631 | return 0; |
632 | } |
633 | |
634 | static int cx24123_pll_tune(struct dvb_frontend *fe) |
635 | { |
636 | struct dtv_frontend_properties *p = &fe->dtv_property_cache; |
637 | struct cx24123_state *state = fe->demodulator_priv; |
638 | u8 val; |
639 | |
640 | dprintk("frequency=%i\n" , p->frequency); |
641 | |
642 | if (cx24123_pll_calculate(fe) != 0) { |
643 | err("%s: cx24123_pll_calculate failed\n" , __func__); |
644 | return -EINVAL; |
645 | } |
646 | |
647 | /* Write the new VCO/VGA */ |
648 | cx24123_pll_writereg(fe, data: state->VCAarg); |
649 | cx24123_pll_writereg(fe, data: state->VGAarg); |
650 | |
651 | /* Write the new bandselect and pll args */ |
652 | cx24123_pll_writereg(fe, data: state->bandselectarg); |
653 | cx24123_pll_writereg(fe, data: state->pllarg); |
654 | |
655 | /* set the FILTUNE voltage */ |
656 | val = cx24123_readreg(state, 0x28) & ~0x3; |
657 | cx24123_writereg(state, 0x27, state->FILTune >> 2); |
658 | cx24123_writereg(state, 0x28, val | (state->FILTune & 0x3)); |
659 | |
660 | dprintk("pll tune VCA=%d, band=%d, pll=%d\n" , state->VCAarg, |
661 | state->bandselectarg, state->pllarg); |
662 | |
663 | return 0; |
664 | } |
665 | |
666 | |
667 | /* |
668 | * 0x23: |
669 | * [7:7] = BTI enabled |
670 | * [6:6] = I2C repeater enabled |
671 | * [5:5] = I2C repeater start |
672 | * [0:0] = BTI start |
673 | */ |
674 | |
675 | /* mode == 1 -> i2c-repeater, 0 -> bti */ |
676 | static int cx24123_repeater_mode(struct cx24123_state *state, u8 mode, u8 start) |
677 | { |
678 | u8 r = cx24123_readreg(state, 0x23) & 0x1e; |
679 | if (mode) |
680 | r |= (1 << 6) | (start << 5); |
681 | else |
682 | r |= (1 << 7) | (start); |
683 | return cx24123_writereg(state, 0x23, r); |
684 | } |
685 | |
686 | static int cx24123_initfe(struct dvb_frontend *fe) |
687 | { |
688 | struct cx24123_state *state = fe->demodulator_priv; |
689 | int i; |
690 | |
691 | dprintk("init frontend\n" ); |
692 | |
693 | /* Configure the demod to a good set of defaults */ |
694 | for (i = 0; i < ARRAY_SIZE(cx24123_regdata); i++) |
695 | cx24123_writereg(state, cx24123_regdata[i].reg, |
696 | cx24123_regdata[i].data); |
697 | |
698 | /* Set the LNB polarity */ |
699 | if (state->config->lnb_polarity) |
700 | cx24123_writereg(state, 0x32, |
701 | cx24123_readreg(state, 0x32) | 0x02); |
702 | |
703 | if (state->config->dont_use_pll) |
704 | cx24123_repeater_mode(state, mode: 1, start: 0); |
705 | |
706 | return 0; |
707 | } |
708 | |
709 | static int cx24123_set_voltage(struct dvb_frontend *fe, |
710 | enum fe_sec_voltage voltage) |
711 | { |
712 | struct cx24123_state *state = fe->demodulator_priv; |
713 | u8 val; |
714 | |
715 | val = cx24123_readreg(state, 0x29) & ~0x40; |
716 | |
717 | switch (voltage) { |
718 | case SEC_VOLTAGE_13: |
719 | dprintk("setting voltage 13V\n" ); |
720 | return cx24123_writereg(state, 0x29, val & 0x7f); |
721 | case SEC_VOLTAGE_18: |
722 | dprintk("setting voltage 18V\n" ); |
723 | return cx24123_writereg(state, 0x29, val | 0x80); |
724 | case SEC_VOLTAGE_OFF: |
725 | /* already handled in cx88-dvb */ |
726 | return 0; |
727 | default: |
728 | return -EINVAL; |
729 | } |
730 | |
731 | return 0; |
732 | } |
733 | |
734 | /* wait for diseqc queue to become ready (or timeout) */ |
735 | static void cx24123_wait_for_diseqc(struct cx24123_state *state) |
736 | { |
737 | unsigned long timeout = jiffies + msecs_to_jiffies(m: 200); |
738 | while (!(cx24123_readreg(state, 0x29) & 0x40)) { |
739 | if (time_after(jiffies, timeout)) { |
740 | err("%s: diseqc queue not ready, " \ |
741 | "command may be lost.\n" , __func__); |
742 | break; |
743 | } |
744 | msleep(msecs: 10); |
745 | } |
746 | } |
747 | |
748 | static int cx24123_send_diseqc_msg(struct dvb_frontend *fe, |
749 | struct dvb_diseqc_master_cmd *cmd) |
750 | { |
751 | struct cx24123_state *state = fe->demodulator_priv; |
752 | int i, val, tone; |
753 | |
754 | dprintk("\n" ); |
755 | |
756 | /* stop continuous tone if enabled */ |
757 | tone = cx24123_readreg(state, 0x29); |
758 | if (tone & 0x10) |
759 | cx24123_writereg(state, 0x29, tone & ~0x50); |
760 | |
761 | /* wait for diseqc queue ready */ |
762 | cx24123_wait_for_diseqc(state); |
763 | |
764 | /* select tone mode */ |
765 | cx24123_writereg(state, 0x2a, cx24123_readreg(state, 0x2a) & 0xfb); |
766 | |
767 | for (i = 0; i < cmd->msg_len; i++) |
768 | cx24123_writereg(state, 0x2C + i, cmd->msg[i]); |
769 | |
770 | val = cx24123_readreg(state, 0x29); |
771 | cx24123_writereg(state, 0x29, ((val & 0x90) | 0x40) | |
772 | ((cmd->msg_len-3) & 3)); |
773 | |
774 | /* wait for diseqc message to finish sending */ |
775 | cx24123_wait_for_diseqc(state); |
776 | |
777 | /* restart continuous tone if enabled */ |
778 | if (tone & 0x10) |
779 | cx24123_writereg(state, 0x29, tone & ~0x40); |
780 | |
781 | return 0; |
782 | } |
783 | |
784 | static int cx24123_diseqc_send_burst(struct dvb_frontend *fe, |
785 | enum fe_sec_mini_cmd burst) |
786 | { |
787 | struct cx24123_state *state = fe->demodulator_priv; |
788 | int val, tone; |
789 | |
790 | dprintk("\n" ); |
791 | |
792 | /* stop continuous tone if enabled */ |
793 | tone = cx24123_readreg(state, 0x29); |
794 | if (tone & 0x10) |
795 | cx24123_writereg(state, 0x29, tone & ~0x50); |
796 | |
797 | /* wait for diseqc queue ready */ |
798 | cx24123_wait_for_diseqc(state); |
799 | |
800 | /* select tone mode */ |
801 | cx24123_writereg(state, 0x2a, cx24123_readreg(state, 0x2a) | 0x4); |
802 | msleep(msecs: 30); |
803 | val = cx24123_readreg(state, 0x29); |
804 | if (burst == SEC_MINI_A) |
805 | cx24123_writereg(state, 0x29, ((val & 0x90) | 0x40 | 0x00)); |
806 | else if (burst == SEC_MINI_B) |
807 | cx24123_writereg(state, 0x29, ((val & 0x90) | 0x40 | 0x08)); |
808 | else |
809 | return -EINVAL; |
810 | |
811 | cx24123_wait_for_diseqc(state); |
812 | cx24123_writereg(state, 0x2a, cx24123_readreg(state, 0x2a) & 0xfb); |
813 | |
814 | /* restart continuous tone if enabled */ |
815 | if (tone & 0x10) |
816 | cx24123_writereg(state, 0x29, tone & ~0x40); |
817 | |
818 | return 0; |
819 | } |
820 | |
821 | static int cx24123_read_status(struct dvb_frontend *fe, enum fe_status *status) |
822 | { |
823 | struct cx24123_state *state = fe->demodulator_priv; |
824 | int sync = cx24123_readreg(state, 0x14); |
825 | |
826 | *status = 0; |
827 | if (state->config->dont_use_pll) { |
828 | u32 tun_status = 0; |
829 | if (fe->ops.tuner_ops.get_status) |
830 | fe->ops.tuner_ops.get_status(fe, &tun_status); |
831 | if (tun_status & TUNER_STATUS_LOCKED) |
832 | *status |= FE_HAS_SIGNAL; |
833 | } else { |
834 | int lock = cx24123_readreg(state, 0x20); |
835 | if (lock & 0x01) |
836 | *status |= FE_HAS_SIGNAL; |
837 | } |
838 | |
839 | if (sync & 0x02) |
840 | *status |= FE_HAS_CARRIER; /* Phase locked */ |
841 | if (sync & 0x04) |
842 | *status |= FE_HAS_VITERBI; |
843 | |
844 | /* Reed-Solomon Status */ |
845 | if (sync & 0x08) |
846 | *status |= FE_HAS_SYNC; |
847 | if (sync & 0x80) |
848 | *status |= FE_HAS_LOCK; /*Full Sync */ |
849 | |
850 | return 0; |
851 | } |
852 | |
853 | /* |
854 | * Configured to return the measurement of errors in blocks, |
855 | * because no UCBLOCKS value is available, so this value doubles up |
856 | * to satisfy both measurements. |
857 | */ |
858 | static int cx24123_read_ber(struct dvb_frontend *fe, u32 *ber) |
859 | { |
860 | struct cx24123_state *state = fe->demodulator_priv; |
861 | |
862 | /* The true bit error rate is this value divided by |
863 | the window size (set as 256 * 255) */ |
864 | *ber = ((cx24123_readreg(state, 0x1c) & 0x3f) << 16) | |
865 | (cx24123_readreg(state, 0x1d) << 8 | |
866 | cx24123_readreg(state, 0x1e)); |
867 | |
868 | dprintk("BER = %d\n" , *ber); |
869 | |
870 | return 0; |
871 | } |
872 | |
873 | static int cx24123_read_signal_strength(struct dvb_frontend *fe, |
874 | u16 *signal_strength) |
875 | { |
876 | struct cx24123_state *state = fe->demodulator_priv; |
877 | |
878 | /* larger = better */ |
879 | *signal_strength = cx24123_readreg(state, 0x3b) << 8; |
880 | |
881 | dprintk("Signal strength = %d\n" , *signal_strength); |
882 | |
883 | return 0; |
884 | } |
885 | |
886 | static int cx24123_read_snr(struct dvb_frontend *fe, u16 *snr) |
887 | { |
888 | struct cx24123_state *state = fe->demodulator_priv; |
889 | |
890 | /* Inverted raw Es/N0 count, totally bogus but better than the |
891 | BER threshold. */ |
892 | *snr = 65535 - (((u16)cx24123_readreg(state, 0x18) << 8) | |
893 | (u16)cx24123_readreg(state, 0x19)); |
894 | |
895 | dprintk("read S/N index = %d\n" , *snr); |
896 | |
897 | return 0; |
898 | } |
899 | |
900 | static int cx24123_set_frontend(struct dvb_frontend *fe) |
901 | { |
902 | struct cx24123_state *state = fe->demodulator_priv; |
903 | struct dtv_frontend_properties *p = &fe->dtv_property_cache; |
904 | |
905 | dprintk("\n" ); |
906 | |
907 | if (state->config->set_ts_params) |
908 | state->config->set_ts_params(fe, 0); |
909 | |
910 | state->currentfreq = p->frequency; |
911 | state->currentsymbolrate = p->symbol_rate; |
912 | |
913 | cx24123_set_inversion(state, inversion: p->inversion); |
914 | cx24123_set_fec(state, fec: p->fec_inner); |
915 | cx24123_set_symbolrate(state, srate: p->symbol_rate); |
916 | |
917 | if (!state->config->dont_use_pll) |
918 | cx24123_pll_tune(fe); |
919 | else if (fe->ops.tuner_ops.set_params) |
920 | fe->ops.tuner_ops.set_params(fe); |
921 | else |
922 | err("it seems I don't have a tuner..." ); |
923 | |
924 | /* Enable automatic acquisition and reset cycle */ |
925 | cx24123_writereg(state, 0x03, (cx24123_readreg(state, 0x03) | 0x07)); |
926 | cx24123_writereg(state, 0x00, 0x10); |
927 | cx24123_writereg(state, 0x00, 0); |
928 | |
929 | if (state->config->agc_callback) |
930 | state->config->agc_callback(fe); |
931 | |
932 | return 0; |
933 | } |
934 | |
935 | static int cx24123_get_frontend(struct dvb_frontend *fe, |
936 | struct dtv_frontend_properties *p) |
937 | { |
938 | struct cx24123_state *state = fe->demodulator_priv; |
939 | |
940 | dprintk("\n" ); |
941 | |
942 | if (cx24123_get_inversion(state, inversion: &p->inversion) != 0) { |
943 | err("%s: Failed to get inversion status\n" , __func__); |
944 | return -EREMOTEIO; |
945 | } |
946 | if (cx24123_get_fec(state, fec: &p->fec_inner) != 0) { |
947 | err("%s: Failed to get fec status\n" , __func__); |
948 | return -EREMOTEIO; |
949 | } |
950 | p->frequency = state->currentfreq; |
951 | p->symbol_rate = state->currentsymbolrate; |
952 | |
953 | return 0; |
954 | } |
955 | |
956 | static int cx24123_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone) |
957 | { |
958 | struct cx24123_state *state = fe->demodulator_priv; |
959 | u8 val; |
960 | |
961 | /* wait for diseqc queue ready */ |
962 | cx24123_wait_for_diseqc(state); |
963 | |
964 | val = cx24123_readreg(state, 0x29) & ~0x40; |
965 | |
966 | switch (tone) { |
967 | case SEC_TONE_ON: |
968 | dprintk("setting tone on\n" ); |
969 | return cx24123_writereg(state, 0x29, val | 0x10); |
970 | case SEC_TONE_OFF: |
971 | dprintk("setting tone off\n" ); |
972 | return cx24123_writereg(state, 0x29, val & 0xef); |
973 | default: |
974 | err("CASE reached default with tone=%d\n" , tone); |
975 | return -EINVAL; |
976 | } |
977 | |
978 | return 0; |
979 | } |
980 | |
981 | static int cx24123_tune(struct dvb_frontend *fe, |
982 | bool re_tune, |
983 | unsigned int mode_flags, |
984 | unsigned int *delay, |
985 | enum fe_status *status) |
986 | { |
987 | int retval = 0; |
988 | |
989 | if (re_tune) |
990 | retval = cx24123_set_frontend(fe); |
991 | |
992 | if (!(mode_flags & FE_TUNE_MODE_ONESHOT)) |
993 | cx24123_read_status(fe, status); |
994 | *delay = HZ/10; |
995 | |
996 | return retval; |
997 | } |
998 | |
999 | static enum dvbfe_algo cx24123_get_algo(struct dvb_frontend *fe) |
1000 | { |
1001 | return DVBFE_ALGO_HW; |
1002 | } |
1003 | |
1004 | static void cx24123_release(struct dvb_frontend *fe) |
1005 | { |
1006 | struct cx24123_state *state = fe->demodulator_priv; |
1007 | dprintk("\n" ); |
1008 | i2c_del_adapter(adap: &state->tuner_i2c_adapter); |
1009 | kfree(objp: state); |
1010 | } |
1011 | |
1012 | static int cx24123_tuner_i2c_tuner_xfer(struct i2c_adapter *i2c_adap, |
1013 | struct i2c_msg msg[], int num) |
1014 | { |
1015 | struct cx24123_state *state = i2c_get_adapdata(adap: i2c_adap); |
1016 | /* this repeater closes after the first stop */ |
1017 | cx24123_repeater_mode(state, mode: 1, start: 1); |
1018 | return i2c_transfer(adap: state->i2c, msgs: msg, num); |
1019 | } |
1020 | |
1021 | static u32 cx24123_tuner_i2c_func(struct i2c_adapter *adapter) |
1022 | { |
1023 | return I2C_FUNC_I2C; |
1024 | } |
1025 | |
1026 | static const struct i2c_algorithm cx24123_tuner_i2c_algo = { |
1027 | .master_xfer = cx24123_tuner_i2c_tuner_xfer, |
1028 | .functionality = cx24123_tuner_i2c_func, |
1029 | }; |
1030 | |
1031 | struct i2c_adapter * |
1032 | cx24123_get_tuner_i2c_adapter(struct dvb_frontend *fe) |
1033 | { |
1034 | struct cx24123_state *state = fe->demodulator_priv; |
1035 | return &state->tuner_i2c_adapter; |
1036 | } |
1037 | EXPORT_SYMBOL(cx24123_get_tuner_i2c_adapter); |
1038 | |
1039 | static const struct dvb_frontend_ops cx24123_ops; |
1040 | |
1041 | struct dvb_frontend *cx24123_attach(const struct cx24123_config *config, |
1042 | struct i2c_adapter *i2c) |
1043 | { |
1044 | /* allocate memory for the internal state */ |
1045 | struct cx24123_state *state = |
1046 | kzalloc(size: sizeof(struct cx24123_state), GFP_KERNEL); |
1047 | |
1048 | dprintk("\n" ); |
1049 | if (state == NULL) { |
1050 | err("Unable to kzalloc\n" ); |
1051 | goto error; |
1052 | } |
1053 | |
1054 | /* setup the state */ |
1055 | state->config = config; |
1056 | state->i2c = i2c; |
1057 | |
1058 | /* check if the demod is there */ |
1059 | state->demod_rev = cx24123_readreg(state, 0x00); |
1060 | switch (state->demod_rev) { |
1061 | case 0xe1: |
1062 | info("detected CX24123C\n" ); |
1063 | break; |
1064 | case 0xd1: |
1065 | info("detected CX24123\n" ); |
1066 | break; |
1067 | default: |
1068 | err("wrong demod revision: %x\n" , state->demod_rev); |
1069 | goto error; |
1070 | } |
1071 | |
1072 | /* create dvb_frontend */ |
1073 | memcpy(&state->frontend.ops, &cx24123_ops, |
1074 | sizeof(struct dvb_frontend_ops)); |
1075 | state->frontend.demodulator_priv = state; |
1076 | |
1077 | /* create tuner i2c adapter */ |
1078 | if (config->dont_use_pll) |
1079 | cx24123_repeater_mode(state, mode: 1, start: 0); |
1080 | |
1081 | strscpy(p: state->tuner_i2c_adapter.name, q: "CX24123 tuner I2C bus" , |
1082 | size: sizeof(state->tuner_i2c_adapter.name)); |
1083 | state->tuner_i2c_adapter.algo = &cx24123_tuner_i2c_algo; |
1084 | state->tuner_i2c_adapter.algo_data = NULL; |
1085 | state->tuner_i2c_adapter.dev.parent = i2c->dev.parent; |
1086 | i2c_set_adapdata(adap: &state->tuner_i2c_adapter, data: state); |
1087 | if (i2c_add_adapter(adap: &state->tuner_i2c_adapter) < 0) { |
1088 | err("tuner i2c bus could not be initialized\n" ); |
1089 | goto error; |
1090 | } |
1091 | |
1092 | return &state->frontend; |
1093 | |
1094 | error: |
1095 | kfree(objp: state); |
1096 | |
1097 | return NULL; |
1098 | } |
1099 | EXPORT_SYMBOL_GPL(cx24123_attach); |
1100 | |
1101 | static const struct dvb_frontend_ops cx24123_ops = { |
1102 | .delsys = { SYS_DVBS }, |
1103 | .info = { |
1104 | .name = "Conexant CX24123/CX24109" , |
1105 | .frequency_min_hz = 950 * MHz, |
1106 | .frequency_max_hz = 2150 * MHz, |
1107 | .frequency_stepsize_hz = 1011 * kHz, |
1108 | .frequency_tolerance_hz = 5 * MHz, |
1109 | .symbol_rate_min = 1000000, |
1110 | .symbol_rate_max = 45000000, |
1111 | .caps = FE_CAN_INVERSION_AUTO | |
1112 | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | |
1113 | FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 | |
1114 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | |
1115 | FE_CAN_QPSK | FE_CAN_RECOVER |
1116 | }, |
1117 | |
1118 | .release = cx24123_release, |
1119 | |
1120 | .init = cx24123_initfe, |
1121 | .set_frontend = cx24123_set_frontend, |
1122 | .get_frontend = cx24123_get_frontend, |
1123 | .read_status = cx24123_read_status, |
1124 | .read_ber = cx24123_read_ber, |
1125 | .read_signal_strength = cx24123_read_signal_strength, |
1126 | .read_snr = cx24123_read_snr, |
1127 | .diseqc_send_master_cmd = cx24123_send_diseqc_msg, |
1128 | .diseqc_send_burst = cx24123_diseqc_send_burst, |
1129 | .set_tone = cx24123_set_tone, |
1130 | .set_voltage = cx24123_set_voltage, |
1131 | .tune = cx24123_tune, |
1132 | .get_frontend_algo = cx24123_get_algo, |
1133 | }; |
1134 | |
1135 | MODULE_DESCRIPTION("DVB Frontend module for Conexant " \ |
1136 | "CX24123/CX24109/CX24113 hardware" ); |
1137 | MODULE_AUTHOR("Steven Toth" ); |
1138 | MODULE_LICENSE("GPL" ); |
1139 | |
1140 | |