projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'akpm' (patches from Andrew)
[deliverable/linux.git] / drivers / media / dvb-frontends / cx24116.c
1 /*
2 Conexant cx24116/cx24118 - DVBS/S2 Satellite demod/tuner driver
3
4 Copyright (C) 2006-2008 Steven Toth <stoth@hauppauge.com>
5 Copyright (C) 2006-2007 Georg Acher
6 Copyright (C) 2007-2008 Darron Broad
7 March 2007
8 Fixed some bugs.
9 Added diseqc support.
10 Added corrected signal strength support.
11 August 2007
12 Sync with legacy version.
13 Some clean ups.
14 Copyright (C) 2008 Igor Liplianin
15 September, 9th 2008
16 Fixed locking on high symbol rates (>30000).
17 Implement MPEG initialization parameter.
18 January, 17th 2009
19 Fill set_voltage with actually control voltage code.
20 Correct set tone to not affect voltage.
21
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
26
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
31
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 */
36
37 #include <linux/slab.h>
38 #include <linux/kernel.h>
39 #include <linux/module.h>
40 #include <linux/moduleparam.h>
41 #include <linux/init.h>
42 #include <linux/firmware.h>
43
44 #include "dvb_frontend.h"
45 #include "cx24116.h"
46
47 static int debug;
48 module_param(debug, int, 0644);
49 MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
50
51 #define dprintk(args...) \
52 do { \
53 if (debug) \
54 printk(KERN_INFO "cx24116: " args); \
55 } while (0)
56
57 #define CX24116_DEFAULT_FIRMWARE "dvb-fe-cx24116.fw"
58 #define CX24116_SEARCH_RANGE_KHZ 5000
59
60 /* known registers */
61 #define CX24116_REG_COMMAND (0x00) /* command args 0x00..0x1e */
62 #define CX24116_REG_EXECUTE (0x1f) /* execute command */
63 #define CX24116_REG_MAILBOX (0x96) /* FW or multipurpose mailbox? */
64 #define CX24116_REG_RESET (0x20) /* reset status > 0 */
65 #define CX24116_REG_SIGNAL (0x9e) /* signal low */
66 #define CX24116_REG_SSTATUS (0x9d) /* signal high / status */
67 #define CX24116_REG_QUALITY8 (0xa3)
68 #define CX24116_REG_QSTATUS (0xbc)
69 #define CX24116_REG_QUALITY0 (0xd5)
70 #define CX24116_REG_BER0 (0xc9)
71 #define CX24116_REG_BER8 (0xc8)
72 #define CX24116_REG_BER16 (0xc7)
73 #define CX24116_REG_BER24 (0xc6)
74 #define CX24116_REG_UCB0 (0xcb)
75 #define CX24116_REG_UCB8 (0xca)
76 #define CX24116_REG_CLKDIV (0xf3)
77 #define CX24116_REG_RATEDIV (0xf9)
78
79 /* configured fec (not tuned) or actual FEC (tuned) 1=1/2 2=2/3 etc */
80 #define CX24116_REG_FECSTATUS (0x9c)
81
82 /* FECSTATUS bits */
83 /* mask to determine configured fec (not tuned) or actual fec (tuned) */
84 #define CX24116_FEC_FECMASK (0x1f)
85
86 /* Select DVB-S demodulator, else DVB-S2 */
87 #define CX24116_FEC_DVBS (0x20)
88 #define CX24116_FEC_UNKNOWN (0x40) /* Unknown/unused */
89
90 /* Pilot mode requested when tuning else always reset when tuned */
91 #define CX24116_FEC_PILOT (0x80)
92
93 /* arg buffer size */
94 #define CX24116_ARGLEN (0x1e)
95
96 /* rolloff */
97 #define CX24116_ROLLOFF_020 (0x00)
98 #define CX24116_ROLLOFF_025 (0x01)
99 #define CX24116_ROLLOFF_035 (0x02)
100
101 /* pilot bit */
102 #define CX24116_PILOT_OFF (0x00)
103 #define CX24116_PILOT_ON (0x40)
104
105 /* signal status */
106 #define CX24116_HAS_SIGNAL (0x01)
107 #define CX24116_HAS_CARRIER (0x02)
108 #define CX24116_HAS_VITERBI (0x04)
109 #define CX24116_HAS_SYNCLOCK (0x08)
110 #define CX24116_HAS_UNKNOWN1 (0x10)
111 #define CX24116_HAS_UNKNOWN2 (0x20)
112 #define CX24116_STATUS_MASK (0x0f)
113 #define CX24116_SIGNAL_MASK (0xc0)
114
115 #define CX24116_DISEQC_TONEOFF (0) /* toneburst never sent */
116 #define CX24116_DISEQC_TONECACHE (1) /* toneburst cached */
117 #define CX24116_DISEQC_MESGCACHE (2) /* message cached */
118
119 /* arg offset for DiSEqC */
120 #define CX24116_DISEQC_BURST (1)
121 #define CX24116_DISEQC_ARG2_2 (2) /* unknown value=2 */
122 #define CX24116_DISEQC_ARG3_0 (3) /* unknown value=0 */
123 #define CX24116_DISEQC_ARG4_0 (4) /* unknown value=0 */
124 #define CX24116_DISEQC_MSGLEN (5)
125 #define CX24116_DISEQC_MSGOFS (6)
126
127 /* DiSEqC burst */
128 #define CX24116_DISEQC_MINI_A (0)
129 #define CX24116_DISEQC_MINI_B (1)
130
131 /* DiSEqC tone burst */
132 static int toneburst = 1;
133 module_param(toneburst, int, 0644);
134 MODULE_PARM_DESC(toneburst, "DiSEqC toneburst 0=OFF, 1=TONE CACHE, "\
135 "2=MESSAGE CACHE (default:1)");
136
137 /* SNR measurements */
138 static int esno_snr;
139 module_param(esno_snr, int, 0644);
140 MODULE_PARM_DESC(esno_snr, "SNR return units, 0=PERCENTAGE 0-100, "\
141 "1=ESNO(db * 10) (default:0)");
142
143 enum cmds {
144 CMD_SET_VCO = 0x10,
145 CMD_TUNEREQUEST = 0x11,
146 CMD_MPEGCONFIG = 0x13,
147 CMD_TUNERINIT = 0x14,
148 CMD_BANDWIDTH = 0x15,
149 CMD_GETAGC = 0x19,
150 CMD_LNBCONFIG = 0x20,
151 CMD_LNBSEND = 0x21, /* Formerly CMD_SEND_DISEQC */
152 CMD_LNBDCLEVEL = 0x22,
153 CMD_SET_TONE = 0x23,
154 CMD_UPDFWVERS = 0x35,
155 CMD_TUNERSLEEP = 0x36,
156 CMD_AGCCONTROL = 0x3b, /* Unknown */
157 };
158
159 /* The Demod/Tuner can't easily provide these, we cache them */
160 struct cx24116_tuning {
161 u32 frequency;
162 u32 symbol_rate;
163 enum fe_spectral_inversion inversion;
164 enum fe_code_rate fec;
165
166 enum fe_delivery_system delsys;
167 enum fe_modulation modulation;
168 enum fe_pilot pilot;
169 enum fe_rolloff rolloff;
170
171 /* Demod values */
172 u8 fec_val;
173 u8 fec_mask;
174 u8 inversion_val;
175 u8 pilot_val;
176 u8 rolloff_val;
177 };
178
179 /* Basic commands that are sent to the firmware */
180 struct cx24116_cmd {
181 u8 len;
182 u8 args[CX24116_ARGLEN];
183 };
184
185 struct cx24116_state {
186 struct i2c_adapter *i2c;
187 const struct cx24116_config *config;
188
189 struct dvb_frontend frontend;
190
191 struct cx24116_tuning dcur;
192 struct cx24116_tuning dnxt;
193
194 u8 skip_fw_load;
195 u8 burst;
196 struct cx24116_cmd dsec_cmd;
197 };
198
199 static int cx24116_writereg(struct cx24116_state *state, int reg, int data)
200 {
201 u8 buf[] = { reg, data };
202 struct i2c_msg msg = { .addr = state->config->demod_address,
203 .flags = 0, .buf = buf, .len = 2 };
204 int err;
205
206 if (debug > 1)
207 printk("cx24116: %s: write reg 0x%02x, value 0x%02x\n",
208 __func__, reg, data);
209
210 err = i2c_transfer(state->i2c, &msg, 1);
211 if (err != 1) {
212 printk(KERN_ERR "%s: writereg error(err == %i, reg == 0x%02x,"
213 " value == 0x%02x)\n", __func__, err, reg, data);
214 return -EREMOTEIO;
215 }
216
217 return 0;
218 }
219
220 /* Bulk byte writes to a single I2C address, for 32k firmware load */
221 static int cx24116_writeregN(struct cx24116_state *state, int reg,
222 const u8 *data, u16 len)
223 {
224 int ret = -EREMOTEIO;
225 struct i2c_msg msg;
226 u8 *buf;
227
228 buf = kmalloc(len + 1, GFP_KERNEL);
229 if (buf == NULL) {
230 printk("Unable to kmalloc\n");
231 ret = -ENOMEM;
232 goto error;
233 }
234
235 *(buf) = reg;
236 memcpy(buf + 1, data, len);
237
238 msg.addr = state->config->demod_address;
239 msg.flags = 0;
240 msg.buf = buf;
241 msg.len = len + 1;
242
243 if (debug > 1)
244 printk(KERN_INFO "cx24116: %s: write regN 0x%02x, len = %d\n",
245 __func__, reg, len);
246
247 ret = i2c_transfer(state->i2c, &msg, 1);
248 if (ret != 1) {
249 printk(KERN_ERR "%s: writereg error(err == %i, reg == 0x%02x\n",
250 __func__, ret, reg);
251 ret = -EREMOTEIO;
252 }
253
254 error:
255 kfree(buf);
256
257 return ret;
258 }
259
260 static int cx24116_readreg(struct cx24116_state *state, u8 reg)
261 {
262 int ret;
263 u8 b0[] = { reg };
264 u8 b1[] = { 0 };
265 struct i2c_msg msg[] = {
266 { .addr = state->config->demod_address, .flags = 0,
267 .buf = b0, .len = 1 },
268 { .addr = state->config->demod_address, .flags = I2C_M_RD,
269 .buf = b1, .len = 1 }
270 };
271
272 ret = i2c_transfer(state->i2c, msg, 2);
273
274 if (ret != 2) {
275 printk(KERN_ERR "%s: reg=0x%x (error=%d)\n",
276 __func__, reg, ret);
277 return ret;
278 }
279
280 if (debug > 1)
281 printk(KERN_INFO "cx24116: read reg 0x%02x, value 0x%02x\n",
282 reg, b1[0]);
283
284 return b1[0];
285 }
286
287 static int cx24116_set_inversion(struct cx24116_state *state,
288 enum fe_spectral_inversion inversion)
289 {
290 dprintk("%s(%d)\n", __func__, inversion);
291
292 switch (inversion) {
293 case INVERSION_OFF:
294 state->dnxt.inversion_val = 0x00;
295 break;
296 case INVERSION_ON:
297 state->dnxt.inversion_val = 0x04;
298 break;
299 case INVERSION_AUTO:
300 state->dnxt.inversion_val = 0x0C;
301 break;
302 default:
303 return -EINVAL;
304 }
305
306 state->dnxt.inversion = inversion;
307
308 return 0;
309 }
310
311 /*
312 * modfec (modulation and FEC)
313 * ===========================
314 *
315 * MOD FEC mask/val standard
316 * ---- -------- ----------- --------
317 * QPSK FEC_1_2 0x02 0x02+X DVB-S
318 * QPSK FEC_2_3 0x04 0x02+X DVB-S
319 * QPSK FEC_3_4 0x08 0x02+X DVB-S
320 * QPSK FEC_4_5 0x10 0x02+X DVB-S (?)
321 * QPSK FEC_5_6 0x20 0x02+X DVB-S
322 * QPSK FEC_6_7 0x40 0x02+X DVB-S
323 * QPSK FEC_7_8 0x80 0x02+X DVB-S
324 * QPSK FEC_8_9 0x01 0x02+X DVB-S (?) (NOT SUPPORTED?)
325 * QPSK AUTO 0xff 0x02+X DVB-S
326 *
327 * For DVB-S high byte probably represents FEC
328 * and low byte selects the modulator. The high
329 * byte is search range mask. Bit 5 may turn
330 * on DVB-S and remaining bits represent some
331 * kind of calibration (how/what i do not know).
332 *
333 * Eg.(2/3) szap "Zone Horror"
334 *
335 * mask/val = 0x04, 0x20
336 * status 1f | signal c3c0 | snr a333 | ber 00000098 | unc 0 | FE_HAS_LOCK
337 *
338 * mask/val = 0x04, 0x30
339 * status 1f | signal c3c0 | snr a333 | ber 00000000 | unc 0 | FE_HAS_LOCK
340 *
341 * After tuning FECSTATUS contains actual FEC
342 * in use numbered 1 through to 8 for 1/2 .. 2/3 etc
343 *
344 * NBC=NOT/NON BACKWARD COMPATIBLE WITH DVB-S (DVB-S2 only)
345 *
346 * NBC-QPSK FEC_1_2 0x00, 0x04 DVB-S2
347 * NBC-QPSK FEC_3_5 0x00, 0x05 DVB-S2
348 * NBC-QPSK FEC_2_3 0x00, 0x06 DVB-S2
349 * NBC-QPSK FEC_3_4 0x00, 0x07 DVB-S2
350 * NBC-QPSK FEC_4_5 0x00, 0x08 DVB-S2
351 * NBC-QPSK FEC_5_6 0x00, 0x09 DVB-S2
352 * NBC-QPSK FEC_8_9 0x00, 0x0a DVB-S2
353 * NBC-QPSK FEC_9_10 0x00, 0x0b DVB-S2
354 *
355 * NBC-8PSK FEC_3_5 0x00, 0x0c DVB-S2
356 * NBC-8PSK FEC_2_3 0x00, 0x0d DVB-S2
357 * NBC-8PSK FEC_3_4 0x00, 0x0e DVB-S2
358 * NBC-8PSK FEC_5_6 0x00, 0x0f DVB-S2
359 * NBC-8PSK FEC_8_9 0x00, 0x10 DVB-S2
360 * NBC-8PSK FEC_9_10 0x00, 0x11 DVB-S2
361 *
362 * For DVB-S2 low bytes selects both modulator
363 * and FEC. High byte is meaningless here. To
364 * set pilot, bit 6 (0x40) is set. When inspecting
365 * FECSTATUS bit 7 (0x80) represents the pilot
366 * selection whilst not tuned. When tuned, actual FEC
367 * in use is found in FECSTATUS as per above. Pilot
368 * value is reset.
369 */
370
371 /* A table of modulation, fec and configuration bytes for the demod.
372 * Not all S2 mmodulation schemes are support and not all rates with
373 * a scheme are support. Especially, no auto detect when in S2 mode.
374 */
375 static struct cx24116_modfec {
376 enum fe_delivery_system delivery_system;
377 enum fe_modulation modulation;
378 enum fe_code_rate fec;
379 u8 mask; /* In DVBS mode this is used to autodetect */
380 u8 val; /* Passed to the firmware to indicate mode selection */
381 } CX24116_MODFEC_MODES[] = {
382 /* QPSK. For unknown rates we set hardware to auto detect 0xfe 0x30 */
383
384 /*mod fec mask val */
385 { SYS_DVBS, QPSK, FEC_NONE, 0xfe, 0x30 },
386 { SYS_DVBS, QPSK, FEC_1_2, 0x02, 0x2e }, /* 00000010 00101110 */
387 { SYS_DVBS, QPSK, FEC_2_3, 0x04, 0x2f }, /* 00000100 00101111 */
388 { SYS_DVBS, QPSK, FEC_3_4, 0x08, 0x30 }, /* 00001000 00110000 */
389 { SYS_DVBS, QPSK, FEC_4_5, 0xfe, 0x30 }, /* 000?0000 ? */
390 { SYS_DVBS, QPSK, FEC_5_6, 0x20, 0x31 }, /* 00100000 00110001 */
391 { SYS_DVBS, QPSK, FEC_6_7, 0xfe, 0x30 }, /* 0?000000 ? */
392 { SYS_DVBS, QPSK, FEC_7_8, 0x80, 0x32 }, /* 10000000 00110010 */
393 { SYS_DVBS, QPSK, FEC_8_9, 0xfe, 0x30 }, /* 0000000? ? */
394 { SYS_DVBS, QPSK, FEC_AUTO, 0xfe, 0x30 },
395 /* NBC-QPSK */
396 { SYS_DVBS2, QPSK, FEC_1_2, 0x00, 0x04 },
397 { SYS_DVBS2, QPSK, FEC_3_5, 0x00, 0x05 },
398 { SYS_DVBS2, QPSK, FEC_2_3, 0x00, 0x06 },
399 { SYS_DVBS2, QPSK, FEC_3_4, 0x00, 0x07 },
400 { SYS_DVBS2, QPSK, FEC_4_5, 0x00, 0x08 },
401 { SYS_DVBS2, QPSK, FEC_5_6, 0x00, 0x09 },
402 { SYS_DVBS2, QPSK, FEC_8_9, 0x00, 0x0a },
403 { SYS_DVBS2, QPSK, FEC_9_10, 0x00, 0x0b },
404 /* 8PSK */
405 { SYS_DVBS2, PSK_8, FEC_3_5, 0x00, 0x0c },
406 { SYS_DVBS2, PSK_8, FEC_2_3, 0x00, 0x0d },
407 { SYS_DVBS2, PSK_8, FEC_3_4, 0x00, 0x0e },
408 { SYS_DVBS2, PSK_8, FEC_5_6, 0x00, 0x0f },
409 { SYS_DVBS2, PSK_8, FEC_8_9, 0x00, 0x10 },
410 { SYS_DVBS2, PSK_8, FEC_9_10, 0x00, 0x11 },
411 /*
412 * `val' can be found in the FECSTATUS register when tuning.
413 * FECSTATUS will give the actual FEC in use if tuning was successful.
414 */
415 };
416
417 static int cx24116_lookup_fecmod(struct cx24116_state *state,
418 enum fe_delivery_system d, enum fe_modulation m, enum fe_code_rate f)
419 {
420 int i, ret = -EOPNOTSUPP;
421
422 dprintk("%s(0x%02x,0x%02x)\n", __func__, m, f);
423
424 for (i = 0; i < ARRAY_SIZE(CX24116_MODFEC_MODES); i++) {
425 if ((d == CX24116_MODFEC_MODES[i].delivery_system) &&
426 (m == CX24116_MODFEC_MODES[i].modulation) &&
427 (f == CX24116_MODFEC_MODES[i].fec)) {
428 ret = i;
429 break;
430 }
431 }
432
433 return ret;
434 }
435
436 static int cx24116_set_fec(struct cx24116_state *state,
437 enum fe_delivery_system delsys,
438 enum fe_modulation mod,
439 enum fe_code_rate fec)
440 {
441 int ret = 0;
442
443 dprintk("%s(0x%02x,0x%02x)\n", __func__, mod, fec);
444
445 ret = cx24116_lookup_fecmod(state, delsys, mod, fec);
446
447 if (ret < 0)
448 return ret;
449
450 state->dnxt.fec = fec;
451 state->dnxt.fec_val = CX24116_MODFEC_MODES[ret].val;
452 state->dnxt.fec_mask = CX24116_MODFEC_MODES[ret].mask;
453 dprintk("%s() mask/val = 0x%02x/0x%02x\n", __func__,
454 state->dnxt.fec_mask, state->dnxt.fec_val);
455
456 return 0;
457 }
458
459 static int cx24116_set_symbolrate(struct cx24116_state *state, u32 rate)
460 {
461 dprintk("%s(%d)\n", __func__, rate);
462
463 /* check if symbol rate is within limits */
464 if ((rate > state->frontend.ops.info.symbol_rate_max) ||
465 (rate < state->frontend.ops.info.symbol_rate_min)) {
466 dprintk("%s() unsupported symbol_rate = %d\n", __func__, rate);
467 return -EOPNOTSUPP;
468 }
469
470 state->dnxt.symbol_rate = rate;
471 dprintk("%s() symbol_rate = %d\n", __func__, rate);
472
473 return 0;
474 }
475
476 static int cx24116_load_firmware(struct dvb_frontend *fe,
477 const struct firmware *fw);
478
479 static int cx24116_firmware_ondemand(struct dvb_frontend *fe)
480 {
481 struct cx24116_state *state = fe->demodulator_priv;
482 const struct firmware *fw;
483 int ret = 0;
484
485 dprintk("%s()\n", __func__);
486
487 if (cx24116_readreg(state, 0x20) > 0) {
488
489 if (state->skip_fw_load)
490 return 0;
491
492 /* Load firmware */
493 /* request the firmware, this will block until loaded */
494 printk(KERN_INFO "%s: Waiting for firmware upload (%s)...\n",
495 __func__, CX24116_DEFAULT_FIRMWARE);
496 ret = request_firmware(&fw, CX24116_DEFAULT_FIRMWARE,
497 state->i2c->dev.parent);
498 printk(KERN_INFO "%s: Waiting for firmware upload(2)...\n",
499 __func__);
500 if (ret) {
501 printk(KERN_ERR "%s: No firmware uploaded "
502 "(timeout or file not found?)\n", __func__);
503 return ret;
504 }
505
506 /* Make sure we don't recurse back through here
507 * during loading */
508 state->skip_fw_load = 1;
509
510 ret = cx24116_load_firmware(fe, fw);
511 if (ret)
512 printk(KERN_ERR "%s: Writing firmware to device failed\n",
513 __func__);
514
515 release_firmware(fw);
516
517 printk(KERN_INFO "%s: Firmware upload %s\n", __func__,
518 ret == 0 ? "complete" : "failed");
519
520 /* Ensure firmware is always loaded if required */
521 state->skip_fw_load = 0;
522 }
523
524 return ret;
525 }
526
527 /* Take a basic firmware command structure, format it
528 * and forward it for processing
529 */
530 static int cx24116_cmd_execute(struct dvb_frontend *fe, struct cx24116_cmd *cmd)
531 {
532 struct cx24116_state *state = fe->demodulator_priv;
533 int i, ret;
534
535 dprintk("%s()\n", __func__);
536
537 /* Load the firmware if required */
538 ret = cx24116_firmware_ondemand(fe);
539 if (ret != 0) {
540 printk(KERN_ERR "%s(): Unable initialise the firmware\n",
541 __func__);
542 return ret;
543 }
544
545 /* Write the command */
546 for (i = 0; i < cmd->len ; i++) {
547 dprintk("%s: 0x%02x == 0x%02x\n", __func__, i, cmd->args[i]);
548 cx24116_writereg(state, i, cmd->args[i]);
549 }
550
551 /* Start execution and wait for cmd to terminate */
552 cx24116_writereg(state, CX24116_REG_EXECUTE, 0x01);
553 while (cx24116_readreg(state, CX24116_REG_EXECUTE)) {
554 msleep(10);
555 if (i++ > 64) {
556 /* Avoid looping forever if the firmware does
557 not respond */
558 printk(KERN_WARNING "%s() Firmware not responding\n",
559 __func__);
560 return -EREMOTEIO;
561 }
562 }
563 return 0;
564 }
565
566 static int cx24116_load_firmware(struct dvb_frontend *fe,
567 const struct firmware *fw)
568 {
569 struct cx24116_state *state = fe->demodulator_priv;
570 struct cx24116_cmd cmd;
571 int i, ret, len, max, remaining;
572 unsigned char vers[4];
573
574 dprintk("%s\n", __func__);
575 dprintk("Firmware is %zu bytes (%02x %02x .. %02x %02x)\n",
576 fw->size,
577 fw->data[0],
578 fw->data[1],
579 fw->data[fw->size-2],
580 fw->data[fw->size-1]);
581
582 /* Toggle 88x SRST pin to reset demod */
583 if (state->config->reset_device)
584 state->config->reset_device(fe);
585
586 /* Begin the firmware load process */
587 /* Prepare the demod, load the firmware, cleanup after load */
588
589 /* Init PLL */
590 cx24116_writereg(state, 0xE5, 0x00);
591 cx24116_writereg(state, 0xF1, 0x08);
592 cx24116_writereg(state, 0xF2, 0x13);
593
594 /* Start PLL */
595 cx24116_writereg(state, 0xe0, 0x03);
596 cx24116_writereg(state, 0xe0, 0x00);
597
598 /* Unknown */
599 cx24116_writereg(state, CX24116_REG_CLKDIV, 0x46);
600 cx24116_writereg(state, CX24116_REG_RATEDIV, 0x00);
601
602 /* Unknown */
603 cx24116_writereg(state, 0xF0, 0x03);
604 cx24116_writereg(state, 0xF4, 0x81);
605 cx24116_writereg(state, 0xF5, 0x00);
606 cx24116_writereg(state, 0xF6, 0x00);
607
608 /* Split firmware to the max I2C write len and write.
609 * Writes whole firmware as one write when i2c_wr_max is set to 0. */
610 if (state->config->i2c_wr_max)
611 max = state->config->i2c_wr_max;
612 else
613 max = INT_MAX; /* enough for 32k firmware */
614
615 for (remaining = fw->size; remaining > 0; remaining -= max - 1) {
616 len = remaining;
617 if (len > max - 1)
618 len = max - 1;
619
620 cx24116_writeregN(state, 0xF7, &fw->data[fw->size - remaining],
621 len);
622 }
623
624 cx24116_writereg(state, 0xF4, 0x10);
625 cx24116_writereg(state, 0xF0, 0x00);
626 cx24116_writereg(state, 0xF8, 0x06);
627
628 /* Firmware CMD 10: VCO config */
629 cmd.args[0x00] = CMD_SET_VCO;
630 cmd.args[0x01] = 0x05;
631 cmd.args[0x02] = 0xdc;
632 cmd.args[0x03] = 0xda;
633 cmd.args[0x04] = 0xae;
634 cmd.args[0x05] = 0xaa;
635 cmd.args[0x06] = 0x04;
636 cmd.args[0x07] = 0x9d;
637 cmd.args[0x08] = 0xfc;
638 cmd.args[0x09] = 0x06;
639 cmd.len = 0x0a;
640 ret = cx24116_cmd_execute(fe, &cmd);
641 if (ret != 0)
642 return ret;
643
644 cx24116_writereg(state, CX24116_REG_SSTATUS, 0x00);
645
646 /* Firmware CMD 14: Tuner config */
647 cmd.args[0x00] = CMD_TUNERINIT;
648 cmd.args[0x01] = 0x00;
649 cmd.args[0x02] = 0x00;
650 cmd.len = 0x03;
651 ret = cx24116_cmd_execute(fe, &cmd);
652 if (ret != 0)
653 return ret;
654
655 cx24116_writereg(state, 0xe5, 0x00);
656
657 /* Firmware CMD 13: MPEG config */
658 cmd.args[0x00] = CMD_MPEGCONFIG;
659 cmd.args[0x01] = 0x01;
660 cmd.args[0x02] = 0x75;
661 cmd.args[0x03] = 0x00;
662 if (state->config->mpg_clk_pos_pol)
663 cmd.args[0x04] = state->config->mpg_clk_pos_pol;
664 else
665 cmd.args[0x04] = 0x02;
666 cmd.args[0x05] = 0x00;
667 cmd.len = 0x06;
668 ret = cx24116_cmd_execute(fe, &cmd);
669 if (ret != 0)
670 return ret;
671
672 /* Firmware CMD 35: Get firmware version */
673 cmd.args[0x00] = CMD_UPDFWVERS;
674 cmd.len = 0x02;
675 for (i = 0; i < 4; i++) {
676 cmd.args[0x01] = i;
677 ret = cx24116_cmd_execute(fe, &cmd);
678 if (ret != 0)
679 return ret;
680 vers[i] = cx24116_readreg(state, CX24116_REG_MAILBOX);
681 }
682 printk(KERN_INFO "%s: FW version %i.%i.%i.%i\n", __func__,
683 vers[0], vers[1], vers[2], vers[3]);
684
685 return 0;
686 }
687
688 static int cx24116_read_status(struct dvb_frontend *fe, enum fe_status *status)
689 {
690 struct cx24116_state *state = fe->demodulator_priv;
691
692 int lock = cx24116_readreg(state, CX24116_REG_SSTATUS) &
693 CX24116_STATUS_MASK;
694
695 dprintk("%s: status = 0x%02x\n", __func__, lock);
696
697 *status = 0;
698
699 if (lock & CX24116_HAS_SIGNAL)
700 *status |= FE_HAS_SIGNAL;
701 if (lock & CX24116_HAS_CARRIER)
702 *status |= FE_HAS_CARRIER;
703 if (lock & CX24116_HAS_VITERBI)
704 *status |= FE_HAS_VITERBI;
705 if (lock & CX24116_HAS_SYNCLOCK)
706 *status |= FE_HAS_SYNC | FE_HAS_LOCK;
707
708 return 0;
709 }
710
711 static int cx24116_read_ber(struct dvb_frontend *fe, u32 *ber)
712 {
713 struct cx24116_state *state = fe->demodulator_priv;
714
715 dprintk("%s()\n", __func__);
716
717 *ber = (cx24116_readreg(state, CX24116_REG_BER24) << 24) |
718 (cx24116_readreg(state, CX24116_REG_BER16) << 16) |
719 (cx24116_readreg(state, CX24116_REG_BER8) << 8) |
720 cx24116_readreg(state, CX24116_REG_BER0);
721
722 return 0;
723 }
724
725 /* TODO Determine function and scale appropriately */
726 static int cx24116_read_signal_strength(struct dvb_frontend *fe,
727 u16 *signal_strength)
728 {
729 struct cx24116_state *state = fe->demodulator_priv;
730 struct cx24116_cmd cmd;
731 int ret;
732 u16 sig_reading;
733
734 dprintk("%s()\n", __func__);
735
736 /* Firmware CMD 19: Get AGC */
737 cmd.args[0x00] = CMD_GETAGC;
738 cmd.len = 0x01;
739 ret = cx24116_cmd_execute(fe, &cmd);
740 if (ret != 0)
741 return ret;
742
743 sig_reading =
744 (cx24116_readreg(state,
745 CX24116_REG_SSTATUS) & CX24116_SIGNAL_MASK) |
746 (cx24116_readreg(state, CX24116_REG_SIGNAL) << 6);
747 *signal_strength = 0 - sig_reading;
748
749 dprintk("%s: raw / cooked = 0x%04x / 0x%04x\n",
750 __func__, sig_reading, *signal_strength);
751
752 return 0;
753 }
754
755 /* SNR (0..100)% = (sig & 0xf0) * 10 + (sig & 0x0f) * 10 / 16 */
756 static int cx24116_read_snr_pct(struct dvb_frontend *fe, u16 *snr)
757 {
758 struct cx24116_state *state = fe->demodulator_priv;
759 u8 snr_reading;
760 static const u32 snr_tab[] = { /* 10 x Table (rounded up) */
761 0x00000, 0x0199A, 0x03333, 0x04ccD, 0x06667,
762 0x08000, 0x0999A, 0x0b333, 0x0cccD, 0x0e667,
763 0x10000, 0x1199A, 0x13333, 0x14ccD, 0x16667,
764 0x18000 };
765
766 dprintk("%s()\n", __func__);
767
768 snr_reading = cx24116_readreg(state, CX24116_REG_QUALITY0);
769
770 if (snr_reading >= 0xa0 /* 100% */)
771 *snr = 0xffff;
772 else
773 *snr = snr_tab[(snr_reading & 0xf0) >> 4] +
774 (snr_tab[(snr_reading & 0x0f)] >> 4);
775
776 dprintk("%s: raw / cooked = 0x%02x / 0x%04x\n", __func__,
777 snr_reading, *snr);
778
779 return 0;
780 }
781
782 /* The reelbox patches show the value in the registers represents
783 * ESNO, from 0->30db (values 0->300). We provide this value by
784 * default.
785 */
786 static int cx24116_read_snr_esno(struct dvb_frontend *fe, u16 *snr)
787 {
788 struct cx24116_state *state = fe->demodulator_priv;
789
790 dprintk("%s()\n", __func__);
791
792 *snr = cx24116_readreg(state, CX24116_REG_QUALITY8) << 8 |
793 cx24116_readreg(state, CX24116_REG_QUALITY0);
794
795 dprintk("%s: raw 0x%04x\n", __func__, *snr);
796
797 return 0;
798 }
799
800 static int cx24116_read_snr(struct dvb_frontend *fe, u16 *snr)
801 {
802 if (esno_snr == 1)
803 return cx24116_read_snr_esno(fe, snr);
804 else
805 return cx24116_read_snr_pct(fe, snr);
806 }
807
808 static int cx24116_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
809 {
810 struct cx24116_state *state = fe->demodulator_priv;
811
812 dprintk("%s()\n", __func__);
813
814 *ucblocks = (cx24116_readreg(state, CX24116_REG_UCB8) << 8) |
815 cx24116_readreg(state, CX24116_REG_UCB0);
816
817 return 0;
818 }
819
820 /* Overwrite the current tuning params, we are about to tune */
821 static void cx24116_clone_params(struct dvb_frontend *fe)
822 {
823 struct cx24116_state *state = fe->demodulator_priv;
824 state->dcur = state->dnxt;
825 }
826
827 /* Wait for LNB */
828 static int cx24116_wait_for_lnb(struct dvb_frontend *fe)
829 {
830 struct cx24116_state *state = fe->demodulator_priv;
831 int i;
832
833 dprintk("%s() qstatus = 0x%02x\n", __func__,
834 cx24116_readreg(state, CX24116_REG_QSTATUS));
835
836 /* Wait for up to 300 ms */
837 for (i = 0; i < 30 ; i++) {
838 if (cx24116_readreg(state, CX24116_REG_QSTATUS) & 0x20)
839 return 0;
840 msleep(10);
841 }
842
843 dprintk("%s(): LNB not ready\n", __func__);
844
845 return -ETIMEDOUT; /* -EBUSY ? */
846 }
847
848 static int cx24116_set_voltage(struct dvb_frontend *fe,
849 enum fe_sec_voltage voltage)
850 {
851 struct cx24116_cmd cmd;
852 int ret;
853
854 dprintk("%s: %s\n", __func__,
855 voltage == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
856 voltage == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
857
858 /* Wait for LNB ready */
859 ret = cx24116_wait_for_lnb(fe);
860 if (ret != 0)
861 return ret;
862
863 /* Wait for voltage/min repeat delay */
864 msleep(100);
865
866 cmd.args[0x00] = CMD_LNBDCLEVEL;
867 cmd.args[0x01] = (voltage == SEC_VOLTAGE_18 ? 0x01 : 0x00);
868 cmd.len = 0x02;
869
870 /* Min delay time before DiSEqC send */
871 msleep(15);
872
873 return cx24116_cmd_execute(fe, &cmd);
874 }
875
876 static int cx24116_set_tone(struct dvb_frontend *fe,
877 enum fe_sec_tone_mode tone)
878 {
879 struct cx24116_cmd cmd;
880 int ret;
881
882 dprintk("%s(%d)\n", __func__, tone);
883 if ((tone != SEC_TONE_ON) && (tone != SEC_TONE_OFF)) {
884 printk(KERN_ERR "%s: Invalid, tone=%d\n", __func__, tone);
885 return -EINVAL;
886 }
887
888 /* Wait for LNB ready */
889 ret = cx24116_wait_for_lnb(fe);
890 if (ret != 0)
891 return ret;
892
893 /* Min delay time after DiSEqC send */
894 msleep(15); /* XXX determine is FW does this, see send_diseqc/burst */
895
896 /* Now we set the tone */
897 cmd.args[0x00] = CMD_SET_TONE;
898 cmd.args[0x01] = 0x00;
899 cmd.args[0x02] = 0x00;
900
901 switch (tone) {
902 case SEC_TONE_ON:
903 dprintk("%s: setting tone on\n", __func__);
904 cmd.args[0x03] = 0x01;
905 break;
906 case SEC_TONE_OFF:
907 dprintk("%s: setting tone off\n", __func__);
908 cmd.args[0x03] = 0x00;
909 break;
910 }
911 cmd.len = 0x04;
912
913 /* Min delay time before DiSEqC send */
914 msleep(15); /* XXX determine is FW does this, see send_diseqc/burst */
915
916 return cx24116_cmd_execute(fe, &cmd);
917 }
918
919 /* Initialise DiSEqC */
920 static int cx24116_diseqc_init(struct dvb_frontend *fe)
921 {
922 struct cx24116_state *state = fe->demodulator_priv;
923 struct cx24116_cmd cmd;
924 int ret;
925
926 /* Firmware CMD 20: LNB/DiSEqC config */
927 cmd.args[0x00] = CMD_LNBCONFIG;
928 cmd.args[0x01] = 0x00;
929 cmd.args[0x02] = 0x10;
930 cmd.args[0x03] = 0x00;
931 cmd.args[0x04] = 0x8f;
932 cmd.args[0x05] = 0x28;
933 cmd.args[0x06] = (toneburst == CX24116_DISEQC_TONEOFF) ? 0x00 : 0x01;
934 cmd.args[0x07] = 0x01;
935 cmd.len = 0x08;
936 ret = cx24116_cmd_execute(fe, &cmd);
937 if (ret != 0)
938 return ret;
939
940 /* Prepare a DiSEqC command */
941 state->dsec_cmd.args[0x00] = CMD_LNBSEND;
942
943 /* DiSEqC burst */
944 state->dsec_cmd.args[CX24116_DISEQC_BURST] = CX24116_DISEQC_MINI_A;
945
946 /* Unknown */
947 state->dsec_cmd.args[CX24116_DISEQC_ARG2_2] = 0x02;
948 state->dsec_cmd.args[CX24116_DISEQC_ARG3_0] = 0x00;
949 /* Continuation flag? */
950 state->dsec_cmd.args[CX24116_DISEQC_ARG4_0] = 0x00;
951
952 /* DiSEqC message length */
953 state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] = 0x00;
954
955 /* Command length */
956 state->dsec_cmd.len = CX24116_DISEQC_MSGOFS;
957
958 return 0;
959 }
960
961 /* Send DiSEqC message with derived burst (hack) || previous burst */
962 static int cx24116_send_diseqc_msg(struct dvb_frontend *fe,
963 struct dvb_diseqc_master_cmd *d)
964 {
965 struct cx24116_state *state = fe->demodulator_priv;
966 int i, ret;
967
968 /* Validate length */
969 if (d->msg_len > sizeof(d->msg))
970 return -EINVAL;
971
972 /* Dump DiSEqC message */
973 if (debug) {
974 printk(KERN_INFO "cx24116: %s(", __func__);
975 for (i = 0 ; i < d->msg_len ;) {
976 printk(KERN_INFO "0x%02x", d->msg[i]);
977 if (++i < d->msg_len)
978 printk(KERN_INFO ", ");
979 }
980 printk(") toneburst=%d\n", toneburst);
981 }
982
983 /* DiSEqC message */
984 for (i = 0; i < d->msg_len; i++)
985 state->dsec_cmd.args[CX24116_DISEQC_MSGOFS + i] = d->msg[i];
986
987 /* DiSEqC message length */
988 state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] = d->msg_len;
989
990 /* Command length */
991 state->dsec_cmd.len = CX24116_DISEQC_MSGOFS +
992 state->dsec_cmd.args[CX24116_DISEQC_MSGLEN];
993
994 /* DiSEqC toneburst */
995 if (toneburst == CX24116_DISEQC_MESGCACHE)
996 /* Message is cached */
997 return 0;
998
999 else if (toneburst == CX24116_DISEQC_TONEOFF)
1000 /* Message is sent without burst */
1001 state->dsec_cmd.args[CX24116_DISEQC_BURST] = 0;
1002
1003 else if (toneburst == CX24116_DISEQC_TONECACHE) {
1004 /*
1005 * Message is sent with derived else cached burst
1006 *
1007 * WRITE PORT GROUP COMMAND 38
1008 *
1009 * 0/A/A: E0 10 38 F0..F3
1010 * 1/B/B: E0 10 38 F4..F7
1011 * 2/C/A: E0 10 38 F8..FB
1012 * 3/D/B: E0 10 38 FC..FF
1013 *
1014 * databyte[3]= 8421:8421
1015 * ABCD:WXYZ
1016 * CLR :SET
1017 *
1018 * WX= PORT SELECT 0..3 (X=TONEBURST)
1019 * Y = VOLTAGE (0=13V, 1=18V)
1020 * Z = BAND (0=LOW, 1=HIGH(22K))
1021 */
1022 if (d->msg_len >= 4 && d->msg[2] == 0x38)
1023 state->dsec_cmd.args[CX24116_DISEQC_BURST] =
1024 ((d->msg[3] & 4) >> 2);
1025 if (debug)
1026 dprintk("%s burst=%d\n", __func__,
1027 state->dsec_cmd.args[CX24116_DISEQC_BURST]);
1028 }
1029
1030 /* Wait for LNB ready */
1031 ret = cx24116_wait_for_lnb(fe);
1032 if (ret != 0)
1033 return ret;
1034
1035 /* Wait for voltage/min repeat delay */
1036 msleep(100);
1037
1038 /* Command */
1039 ret = cx24116_cmd_execute(fe, &state->dsec_cmd);
1040 if (ret != 0)
1041 return ret;
1042 /*
1043 * Wait for send
1044 *
1045 * Eutelsat spec:
1046 * >15ms delay + (XXX determine if FW does this, see set_tone)
1047 * 13.5ms per byte +
1048 * >15ms delay +
1049 * 12.5ms burst +
1050 * >15ms delay (XXX determine if FW does this, see set_tone)
1051 */
1052 msleep((state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] << 4) +
1053 ((toneburst == CX24116_DISEQC_TONEOFF) ? 30 : 60));
1054
1055 return 0;
1056 }
1057
1058 /* Send DiSEqC burst */
1059 static int cx24116_diseqc_send_burst(struct dvb_frontend *fe,
1060 enum fe_sec_mini_cmd burst)
1061 {
1062 struct cx24116_state *state = fe->demodulator_priv;
1063 int ret;
1064
1065 dprintk("%s(%d) toneburst=%d\n", __func__, burst, toneburst);
1066
1067 /* DiSEqC burst */
1068 if (burst == SEC_MINI_A)
1069 state->dsec_cmd.args[CX24116_DISEQC_BURST] =
1070 CX24116_DISEQC_MINI_A;
1071 else if (burst == SEC_MINI_B)
1072 state->dsec_cmd.args[CX24116_DISEQC_BURST] =
1073 CX24116_DISEQC_MINI_B;
1074 else
1075 return -EINVAL;
1076
1077 /* DiSEqC toneburst */
1078 if (toneburst != CX24116_DISEQC_MESGCACHE)
1079 /* Burst is cached */
1080 return 0;
1081
1082 /* Burst is to be sent with cached message */
1083
1084 /* Wait for LNB ready */
1085 ret = cx24116_wait_for_lnb(fe);
1086 if (ret != 0)
1087 return ret;
1088
1089 /* Wait for voltage/min repeat delay */
1090 msleep(100);
1091
1092 /* Command */
1093 ret = cx24116_cmd_execute(fe, &state->dsec_cmd);
1094 if (ret != 0)
1095 return ret;
1096
1097 /*
1098 * Wait for send
1099 *
1100 * Eutelsat spec:
1101 * >15ms delay + (XXX determine if FW does this, see set_tone)
1102 * 13.5ms per byte +
1103 * >15ms delay +
1104 * 12.5ms burst +
1105 * >15ms delay (XXX determine if FW does this, see set_tone)
1106 */
1107 msleep((state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] << 4) + 60);
1108
1109 return 0;
1110 }
1111
1112 static void cx24116_release(struct dvb_frontend *fe)
1113 {
1114 struct cx24116_state *state = fe->demodulator_priv;
1115 dprintk("%s\n", __func__);
1116 kfree(state);
1117 }
1118
1119 static struct dvb_frontend_ops cx24116_ops;
1120
1121 struct dvb_frontend *cx24116_attach(const struct cx24116_config *config,
1122 struct i2c_adapter *i2c)
1123 {
1124 struct cx24116_state *state = NULL;
1125 int ret;
1126
1127 dprintk("%s\n", __func__);
1128
1129 /* allocate memory for the internal state */
1130 state = kzalloc(sizeof(struct cx24116_state), GFP_KERNEL);
1131 if (state == NULL)
1132 goto error1;
1133
1134 state->config = config;
1135 state->i2c = i2c;
1136
1137 /* check if the demod is present */
1138 ret = (cx24116_readreg(state, 0xFF) << 8) |
1139 cx24116_readreg(state, 0xFE);
1140 if (ret != 0x0501) {
1141 printk(KERN_INFO "Invalid probe, probably not a CX24116 device\n");
1142 goto error2;
1143 }
1144
1145 /* create dvb_frontend */
1146 memcpy(&state->frontend.ops, &cx24116_ops,
1147 sizeof(struct dvb_frontend_ops));
1148 state->frontend.demodulator_priv = state;
1149 return &state->frontend;
1150
1151 error2: kfree(state);
1152 error1: return NULL;
1153 }
1154 EXPORT_SYMBOL(cx24116_attach);
1155
1156 /*
1157 * Initialise or wake up device
1158 *
1159 * Power config will reset and load initial firmware if required
1160 */
1161 static int cx24116_initfe(struct dvb_frontend *fe)
1162 {
1163 struct cx24116_state *state = fe->demodulator_priv;
1164 struct cx24116_cmd cmd;
1165 int ret;
1166
1167 dprintk("%s()\n", __func__);
1168
1169 /* Power on */
1170 cx24116_writereg(state, 0xe0, 0);
1171 cx24116_writereg(state, 0xe1, 0);
1172 cx24116_writereg(state, 0xea, 0);
1173
1174 /* Firmware CMD 36: Power config */
1175 cmd.args[0x00] = CMD_TUNERSLEEP;
1176 cmd.args[0x01] = 0;
1177 cmd.len = 0x02;
1178 ret = cx24116_cmd_execute(fe, &cmd);
1179 if (ret != 0)
1180 return ret;
1181
1182 ret = cx24116_diseqc_init(fe);
1183 if (ret != 0)
1184 return ret;
1185
1186 /* HVR-4000 needs this */
1187 return cx24116_set_voltage(fe, SEC_VOLTAGE_13);
1188 }
1189
1190 /*
1191 * Put device to sleep
1192 */
1193 static int cx24116_sleep(struct dvb_frontend *fe)
1194 {
1195 struct cx24116_state *state = fe->demodulator_priv;
1196 struct cx24116_cmd cmd;
1197 int ret;
1198
1199 dprintk("%s()\n", __func__);
1200
1201 /* Firmware CMD 36: Power config */
1202 cmd.args[0x00] = CMD_TUNERSLEEP;
1203 cmd.args[0x01] = 1;
1204 cmd.len = 0x02;
1205 ret = cx24116_cmd_execute(fe, &cmd);
1206 if (ret != 0)
1207 return ret;
1208
1209 /* Power off (Shutdown clocks) */
1210 cx24116_writereg(state, 0xea, 0xff);
1211 cx24116_writereg(state, 0xe1, 1);
1212 cx24116_writereg(state, 0xe0, 1);
1213
1214 return 0;
1215 }
1216
1217 /* dvb-core told us to tune, the tv property cache will be complete,
1218 * it's safe for is to pull values and use them for tuning purposes.
1219 */
1220 static int cx24116_set_frontend(struct dvb_frontend *fe)
1221 {
1222 struct cx24116_state *state = fe->demodulator_priv;
1223 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1224 struct cx24116_cmd cmd;
1225 enum fe_status tunerstat;
1226 int i, status, ret, retune = 1;
1227
1228 dprintk("%s()\n", __func__);
1229
1230 switch (c->delivery_system) {
1231 case SYS_DVBS:
1232 dprintk("%s: DVB-S delivery system selected\n", __func__);
1233
1234 /* Only QPSK is supported for DVB-S */
1235 if (c->modulation != QPSK) {
1236 dprintk("%s: unsupported modulation selected (%d)\n",
1237 __func__, c->modulation);
1238 return -EOPNOTSUPP;
1239 }
1240
1241 /* Pilot doesn't exist in DVB-S, turn bit off */
1242 state->dnxt.pilot_val = CX24116_PILOT_OFF;
1243
1244 /* DVB-S only supports 0.35 */
1245 if (c->rolloff != ROLLOFF_35) {
1246 dprintk("%s: unsupported rolloff selected (%d)\n",
1247 __func__, c->rolloff);
1248 return -EOPNOTSUPP;
1249 }
1250 state->dnxt.rolloff_val = CX24116_ROLLOFF_035;
1251 break;
1252
1253 case SYS_DVBS2:
1254 dprintk("%s: DVB-S2 delivery system selected\n", __func__);
1255
1256 /*
1257 * NBC 8PSK/QPSK with DVB-S is supported for DVB-S2,
1258 * but not hardware auto detection
1259 */
1260 if (c->modulation != PSK_8 && c->modulation != QPSK) {
1261 dprintk("%s: unsupported modulation selected (%d)\n",
1262 __func__, c->modulation);
1263 return -EOPNOTSUPP;
1264 }
1265
1266 switch (c->pilot) {
1267 case PILOT_AUTO: /* Not supported but emulated */
1268 state->dnxt.pilot_val = (c->modulation == QPSK)
1269 ? CX24116_PILOT_OFF : CX24116_PILOT_ON;
1270 retune++;
1271 break;
1272 case PILOT_OFF:
1273 state->dnxt.pilot_val = CX24116_PILOT_OFF;
1274 break;
1275 case PILOT_ON:
1276 state->dnxt.pilot_val = CX24116_PILOT_ON;
1277 break;
1278 default:
1279 dprintk("%s: unsupported pilot mode selected (%d)\n",
1280 __func__, c->pilot);
1281 return -EOPNOTSUPP;
1282 }
1283
1284 switch (c->rolloff) {
1285 case ROLLOFF_20:
1286 state->dnxt.rolloff_val = CX24116_ROLLOFF_020;
1287 break;
1288 case ROLLOFF_25:
1289 state->dnxt.rolloff_val = CX24116_ROLLOFF_025;
1290 break;
1291 case ROLLOFF_35:
1292 state->dnxt.rolloff_val = CX24116_ROLLOFF_035;
1293 break;
1294 case ROLLOFF_AUTO: /* Rolloff must be explicit */
1295 default:
1296 dprintk("%s: unsupported rolloff selected (%d)\n",
1297 __func__, c->rolloff);
1298 return -EOPNOTSUPP;
1299 }
1300 break;
1301
1302 default:
1303 dprintk("%s: unsupported delivery system selected (%d)\n",
1304 __func__, c->delivery_system);
1305 return -EOPNOTSUPP;
1306 }
1307 state->dnxt.delsys = c->delivery_system;
1308 state->dnxt.modulation = c->modulation;
1309 state->dnxt.frequency = c->frequency;
1310 state->dnxt.pilot = c->pilot;
1311 state->dnxt.rolloff = c->rolloff;
1312
1313 ret = cx24116_set_inversion(state, c->inversion);
1314 if (ret != 0)
1315 return ret;
1316
1317 /* FEC_NONE/AUTO for DVB-S2 is not supported and detected here */
1318 ret = cx24116_set_fec(state, c->delivery_system, c->modulation, c->fec_inner);
1319 if (ret != 0)
1320 return ret;
1321
1322 ret = cx24116_set_symbolrate(state, c->symbol_rate);
1323 if (ret != 0)
1324 return ret;
1325
1326 /* discard the 'current' tuning parameters and prepare to tune */
1327 cx24116_clone_params(fe);
1328
1329 dprintk("%s: delsys = %d\n", __func__, state->dcur.delsys);
1330 dprintk("%s: modulation = %d\n", __func__, state->dcur.modulation);
1331 dprintk("%s: frequency = %d\n", __func__, state->dcur.frequency);
1332 dprintk("%s: pilot = %d (val = 0x%02x)\n", __func__,
1333 state->dcur.pilot, state->dcur.pilot_val);
1334 dprintk("%s: retune = %d\n", __func__, retune);
1335 dprintk("%s: rolloff = %d (val = 0x%02x)\n", __func__,
1336 state->dcur.rolloff, state->dcur.rolloff_val);
1337 dprintk("%s: symbol_rate = %d\n", __func__, state->dcur.symbol_rate);
1338 dprintk("%s: FEC = %d (mask/val = 0x%02x/0x%02x)\n", __func__,
1339 state->dcur.fec, state->dcur.fec_mask, state->dcur.fec_val);
1340 dprintk("%s: Inversion = %d (val = 0x%02x)\n", __func__,
1341 state->dcur.inversion, state->dcur.inversion_val);
1342
1343 /* This is also done in advise/acquire on HVR4000 but not on LITE */
1344 if (state->config->set_ts_params)
1345 state->config->set_ts_params(fe, 0);
1346
1347 /* Set/Reset B/W */
1348 cmd.args[0x00] = CMD_BANDWIDTH;
1349 cmd.args[0x01] = 0x01;
1350 cmd.len = 0x02;
1351 ret = cx24116_cmd_execute(fe, &cmd);
1352 if (ret != 0)
1353 return ret;
1354
1355 /* Prepare a tune request */
1356 cmd.args[0x00] = CMD_TUNEREQUEST;
1357
1358 /* Frequency */
1359 cmd.args[0x01] = (state->dcur.frequency & 0xff0000) >> 16;
1360 cmd.args[0x02] = (state->dcur.frequency & 0x00ff00) >> 8;
1361 cmd.args[0x03] = (state->dcur.frequency & 0x0000ff);
1362
1363 /* Symbol Rate */
1364 cmd.args[0x04] = ((state->dcur.symbol_rate / 1000) & 0xff00) >> 8;
1365 cmd.args[0x05] = ((state->dcur.symbol_rate / 1000) & 0x00ff);
1366
1367 /* Automatic Inversion */
1368 cmd.args[0x06] = state->dcur.inversion_val;
1369
1370 /* Modulation / FEC / Pilot */
1371 cmd.args[0x07] = state->dcur.fec_val | state->dcur.pilot_val;
1372
1373 cmd.args[0x08] = CX24116_SEARCH_RANGE_KHZ >> 8;
1374 cmd.args[0x09] = CX24116_SEARCH_RANGE_KHZ & 0xff;
1375 cmd.args[0x0a] = 0x00;
1376 cmd.args[0x0b] = 0x00;
1377 cmd.args[0x0c] = state->dcur.rolloff_val;
1378 cmd.args[0x0d] = state->dcur.fec_mask;
1379
1380 if (state->dcur.symbol_rate > 30000000) {
1381 cmd.args[0x0e] = 0x04;
1382 cmd.args[0x0f] = 0x00;
1383 cmd.args[0x10] = 0x01;
1384 cmd.args[0x11] = 0x77;
1385 cmd.args[0x12] = 0x36;
1386 cx24116_writereg(state, CX24116_REG_CLKDIV, 0x44);
1387 cx24116_writereg(state, CX24116_REG_RATEDIV, 0x01);
1388 } else {
1389 cmd.args[0x0e] = 0x06;
1390 cmd.args[0x0f] = 0x00;
1391 cmd.args[0x10] = 0x00;
1392 cmd.args[0x11] = 0xFA;
1393 cmd.args[0x12] = 0x24;
1394 cx24116_writereg(state, CX24116_REG_CLKDIV, 0x46);
1395 cx24116_writereg(state, CX24116_REG_RATEDIV, 0x00);
1396 }
1397
1398 cmd.len = 0x13;
1399
1400 /* We need to support pilot and non-pilot tuning in the
1401 * driver automatically. This is a workaround for because
1402 * the demod does not support autodetect.
1403 */
1404 do {
1405 /* Reset status register */
1406 status = cx24116_readreg(state, CX24116_REG_SSTATUS)
1407 & CX24116_SIGNAL_MASK;
1408 cx24116_writereg(state, CX24116_REG_SSTATUS, status);
1409
1410 /* Tune */
1411 ret = cx24116_cmd_execute(fe, &cmd);
1412 if (ret != 0)
1413 break;
1414
1415 /*
1416 * Wait for up to 500 ms before retrying
1417 *
1418 * If we are able to tune then generally it occurs within 100ms.
1419 * If it takes longer, try a different toneburst setting.
1420 */
1421 for (i = 0; i < 50 ; i++) {
1422 cx24116_read_status(fe, &tunerstat);
1423 status = tunerstat & (FE_HAS_SIGNAL | FE_HAS_SYNC);
1424 if (status == (FE_HAS_SIGNAL | FE_HAS_SYNC)) {
1425 dprintk("%s: Tuned\n", __func__);
1426 goto tuned;
1427 }
1428 msleep(10);
1429 }
1430
1431 dprintk("%s: Not tuned\n", __func__);
1432
1433 /* Toggle pilot bit when in auto-pilot */
1434 if (state->dcur.pilot == PILOT_AUTO)
1435 cmd.args[0x07] ^= CX24116_PILOT_ON;
1436 } while (--retune);
1437
1438 tuned: /* Set/Reset B/W */
1439 cmd.args[0x00] = CMD_BANDWIDTH;
1440 cmd.args[0x01] = 0x00;
1441 cmd.len = 0x02;
1442 return cx24116_cmd_execute(fe, &cmd);
1443 }
1444
1445 static int cx24116_tune(struct dvb_frontend *fe, bool re_tune,
1446 unsigned int mode_flags, unsigned int *delay, enum fe_status *status)
1447 {
1448 /*
1449 * It is safe to discard "params" here, as the DVB core will sync
1450 * fe->dtv_property_cache with fepriv->parameters_in, where the
1451 * DVBv3 params are stored. The only practical usage for it indicate
1452 * that re-tuning is needed, e. g. (fepriv->state & FESTATE_RETUNE) is
1453 * true.
1454 */
1455
1456 *delay = HZ / 5;
1457 if (re_tune) {
1458 int ret = cx24116_set_frontend(fe);
1459 if (ret)
1460 return ret;
1461 }
1462 return cx24116_read_status(fe, status);
1463 }
1464
1465 static int cx24116_get_algo(struct dvb_frontend *fe)
1466 {
1467 return DVBFE_ALGO_HW;
1468 }
1469
1470 static struct dvb_frontend_ops cx24116_ops = {
1471 .delsys = { SYS_DVBS, SYS_DVBS2 },
1472 .info = {
1473 .name = "Conexant CX24116/CX24118",
1474 .frequency_min = 950000,
1475 .frequency_max = 2150000,
1476 .frequency_stepsize = 1011, /* kHz for QPSK frontends */
1477 .frequency_tolerance = 5000,
1478 .symbol_rate_min = 1000000,
1479 .symbol_rate_max = 45000000,
1480 .caps = FE_CAN_INVERSION_AUTO |
1481 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1482 FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
1483 FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1484 FE_CAN_2G_MODULATION |
1485 FE_CAN_QPSK | FE_CAN_RECOVER
1486 },
1487
1488 .release = cx24116_release,
1489
1490 .init = cx24116_initfe,
1491 .sleep = cx24116_sleep,
1492 .read_status = cx24116_read_status,
1493 .read_ber = cx24116_read_ber,
1494 .read_signal_strength = cx24116_read_signal_strength,
1495 .read_snr = cx24116_read_snr,
1496 .read_ucblocks = cx24116_read_ucblocks,
1497 .set_tone = cx24116_set_tone,
1498 .set_voltage = cx24116_set_voltage,
1499 .diseqc_send_master_cmd = cx24116_send_diseqc_msg,
1500 .diseqc_send_burst = cx24116_diseqc_send_burst,
1501 .get_frontend_algo = cx24116_get_algo,
1502 .tune = cx24116_tune,
1503
1504 .set_frontend = cx24116_set_frontend,
1505 };
1506
1507 MODULE_DESCRIPTION("DVB Frontend module for Conexant cx24116/cx24118 hardware");
1508 MODULE_AUTHOR("Steven Toth");
1509 MODULE_LICENSE("GPL");
1510
Linux kernel - Deliverables
This page took 0.238161 seconds and 5 git commands to generate.