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