blob: 1402086a5c442e8f5683fa9641539e72a3f9c8a5 [file] [log] [blame]
Steven Toth0d467482008-09-04 01:14:43 -03001/*
2 Conexant cx24116/cx24118 - DVBS/S2 Satellite demod/tuner driver
3
4 Copyright (C) 2006-2008 Steven Toth <stoth@hauppauge.com>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21/*
22 * Updates by Darron Broad 2007.
23 *
24 * March
25 * Fixed some bugs.
26 * Added diseqc support.
27 * Added corrected signal strength support.
28 *
29 * August
30 * Sync with legacy version.
31 * Some clean ups.
32 */
33
34#include <linux/slab.h>
35#include <linux/kernel.h>
36#include <linux/module.h>
37#include <linux/moduleparam.h>
38#include <linux/init.h>
39#include <linux/firmware.h>
40
41#include "dvb_frontend.h"
42#include "cx24116.h"
43
44/*
45 * Fetch firmware in the following manner.
46 *
47 * #!/bin/sh
48 * wget ftp://167.206.143.11/outgoing/Oxford/88x_2_117_24275_1_INF.zip
49 * unzip 88x_2_117_24275_1_INF.zip
50 * dd if=Driver88/hcw88bda.sys of=dvb-fe-cx24116.fw skip=81768 bs=1 count=32522
51 */
52#define CX24116_DEFAULT_FIRMWARE "dvb-fe-cx24116.fw"
53#define CX24116_SEARCH_RANGE_KHZ 5000
54
55/* registers (TO BE COMPLETED) */
56#define CX24116_REG_SIGNAL (0xd5)
57
58/* arg buffer size */
59#define CX24116_ARGLEN (0x1e)
60
61/* arg offset for DiSEqC */
62#define CX24116_DISEQC_BURST (1)
63#define CX24116_DISEQC_ARG2_2 (2) /* unknown value=2 */
64#define CX24116_DISEQC_ARG3_0 (3) /* unknown value=0 */
65#define CX24116_DISEQC_ARG4_0 (4) /* unknown value=0 */
66#define CX24116_DISEQC_MSGLEN (5)
67#define CX24116_DISEQC_MSGOFS (6)
68
69/* DiSEqC burst */
70#define CX24116_DISEQC_MINI_A (0)
71#define CX24116_DISEQC_MINI_B (1)
72
73static int debug = 0;
74#define dprintk(args...) \
75 do { \
76 if (debug) printk ("cx24116: " args); \
77 } while (0)
78
79enum cmds
80{
81 CMD_INIT_CMD10 = 0x10,
82 CMD_TUNEREQUEST = 0x11,
83 CMD_INIT_CMD13 = 0x13,
84 CMD_INIT_CMD14 = 0x14,
85 CMD_SEND_DISEQC = 0x21,
86 CMD_SET_TONEPRE = 0x22,
87 CMD_SET_TONE = 0x23,
88};
89
90/* The Demod/Tuner can't easily provide these, we cache them */
91struct cx24116_tuning
92{
93 u32 frequency;
94 u32 symbol_rate;
95 fe_spectral_inversion_t inversion;
96 fe_code_rate_t fec;
97
98 fe_modulation_t modulation;
99
100 /* Demod values */
101 u8 fec_val;
102 u8 fec_mask;
103 u8 inversion_val;
104};
105
106/* Basic commands that are sent to the firmware */
107struct cx24116_cmd
108{
109 u8 len;
110 u8 args[CX24116_ARGLEN];
111};
112
113struct cx24116_state
114{
115 struct i2c_adapter* i2c;
116 const struct cx24116_config* config;
117
118 struct dvb_frontend frontend;
119
120 struct cx24116_tuning dcur;
121 struct cx24116_tuning dnxt;
122
123 u8 skip_fw_load;
124 u8 burst;
125};
126
127static int cx24116_writereg(struct cx24116_state* state, int reg, int data)
128{
129 u8 buf[] = { reg, data };
130 struct i2c_msg msg = { .addr = state->config->demod_address,
131 .flags = 0, .buf = buf, .len = 2 };
132 int err;
133
134 if (debug>1)
135 printk("cx24116: %s: write reg 0x%02x, value 0x%02x\n",
136 __func__,reg, data);
137
138 if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
139 printk("%s: writereg error(err == %i, reg == 0x%02x,"
140 " value == 0x%02x)\n", __func__, err, reg, data);
141 return -EREMOTEIO;
142 }
143
144 return 0;
145}
146
147/* Bulk byte writes to a single I2C address, for 32k firmware load */
148static int cx24116_writeregN(struct cx24116_state* state, int reg, u8 *data, u16 len)
149{
150 int ret = -EREMOTEIO;
151 struct i2c_msg msg;
152 u8 *buf;
153
154 buf = kmalloc(len + 1, GFP_KERNEL);
155 if (buf == NULL) {
156 printk("Unable to kmalloc\n");
157 ret = -ENOMEM;
158 goto error;
159 }
160
161 *(buf) = reg;
162 memcpy(buf + 1, data, len);
163
164 msg.addr = state->config->demod_address;
165 msg.flags = 0;
166 msg.buf = buf;
167 msg.len = len + 1;
168
169 if (debug>1)
170 printk("cx24116: %s: write regN 0x%02x, len = %d\n",
171 __func__,reg, len);
172
173 if ((ret = i2c_transfer(state->i2c, &msg, 1)) != 1) {
174 printk("%s: writereg error(err == %i, reg == 0x%02x\n",
175 __func__, ret, reg);
176 ret = -EREMOTEIO;
177 }
178
179error:
180 kfree(buf);
181
182 return ret;
183}
184
185static int cx24116_readreg(struct cx24116_state* state, u8 reg)
186{
187 int ret;
188 u8 b0[] = { reg };
189 u8 b1[] = { 0 };
190 struct i2c_msg msg[] = {
191 { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 1 },
192 { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 }
193 };
194
195 ret = i2c_transfer(state->i2c, msg, 2);
196
197 if (ret != 2) {
198 printk("%s: reg=0x%x (error=%d)\n", __func__, reg, ret);
199 return ret;
200 }
201
202 if (debug>1)
203 printk("cx24116: read reg 0x%02x, value 0x%02x\n",reg, b1[0]);
204
205 return b1[0];
206}
207
208static int cx24116_set_inversion(struct cx24116_state* state, fe_spectral_inversion_t inversion)
209{
210 dprintk("%s(%d)\n", __func__, inversion);
211
212 switch (inversion) {
213 case INVERSION_OFF:
214 state->dnxt.inversion_val = 0x00;
215 break;
216 case INVERSION_ON:
217 state->dnxt.inversion_val = 0x04;
218 break;
219 case INVERSION_AUTO:
220 state->dnxt.inversion_val = 0x0C;
221 break;
222 default:
223 return -EINVAL;
224 }
225
226 state->dnxt.inversion = inversion;
227
228 return 0;
229}
230
231/* A table of modulation, fec and configuration bytes for the demod.
232 * Not all S2 mmodulation schemes are support and not all rates with
233 * a scheme are support. Especially, no auto detect when in S2 mode.
234 */
235struct cx24116_modfec {
236 fe_modulation_t modulation;
237 fe_code_rate_t fec;
238 u8 mask; /* In DVBS mode this is used to autodetect */
239 u8 val; /* Passed to the firmware to indicate mode selection */
240} CX24116_MODFEC_MODES[] = {
241 /* QPSK. For unknown rates we set hardware to auto detect 0xfe 0x30 */
242 { QPSK, FEC_NONE, 0xfe, 0x30 },
243 { QPSK, FEC_1_2, 0x02, 0x2e },
244 { QPSK, FEC_2_3, 0x04, 0x2f },
245 { QPSK, FEC_3_4, 0x08, 0x30 },
246 { QPSK, FEC_4_5, 0xfe, 0x30 },
247 { QPSK, FEC_5_6, 0x20, 0x31 },
248 { QPSK, FEC_6_7, 0xfe, 0x30 },
249 { QPSK, FEC_7_8, 0x80, 0x32 },
250 { QPSK, FEC_8_9, 0xfe, 0x30 },
251 { QPSK, FEC_AUTO, 0xfe, 0x30 },
252 /* NBC-QPSK */
253 { NBC_QPSK, FEC_1_2, 0x00, 0x04 },
254 { NBC_QPSK, FEC_3_5, 0x00, 0x05 },
255 { NBC_QPSK, FEC_2_3, 0x00, 0x06 },
256 { NBC_QPSK, FEC_3_4, 0x00, 0x07 },
257 { NBC_QPSK, FEC_4_5, 0x00, 0x08 },
258 { NBC_QPSK, FEC_5_6, 0x00, 0x09 },
259 { NBC_QPSK, FEC_8_9, 0x00, 0x0a },
260 { NBC_QPSK, FEC_9_10, 0x00, 0x0b },
261 /* 8PSK */
262 { _8PSK, FEC_3_5, 0x00, 0x0c },
263 { _8PSK, FEC_2_3, 0x00, 0x0d },
264 { _8PSK, FEC_3_4, 0x00, 0x0e },
265 { _8PSK, FEC_5_6, 0x00, 0x0f },
266 { _8PSK, FEC_9_10, 0x00, 0x11 },
267};
268
269static int cx24116_lookup_fecmod(struct cx24116_state* state,
270 fe_modulation_t m, fe_code_rate_t f)
271{
272 int i, ret = -EOPNOTSUPP;
273
274 for(i=0 ; i < sizeof(CX24116_MODFEC_MODES) / sizeof(struct cx24116_modfec) ; i++)
275 {
276 if( (m == CX24116_MODFEC_MODES[i].modulation) &&
277 (f == CX24116_MODFEC_MODES[i].fec) )
278 {
279 ret = i;
280 break;
281 }
282 }
283
284 return ret;
285}
286
287static int cx24116_set_fec(struct cx24116_state* state, fe_modulation_t mod, fe_code_rate_t fec)
288{
289 int ret = 0;
290 dprintk("%s()\n", __func__);
291
292 ret = cx24116_lookup_fecmod(state, mod, fec);
293
294 if(ret < 0)
295 return ret;
296
297 state->dnxt.fec_val = CX24116_MODFEC_MODES[ret].val;
298 state->dnxt.fec_mask = CX24116_MODFEC_MODES[ret].mask;
299 dprintk("%s() fec_val/mask = 0x%02x/0x%02x\n", __func__,
300 state->dnxt.fec_val, state->dnxt.fec_mask);
301
302 return 0;
303}
304
305static int cx24116_set_symbolrate(struct cx24116_state* state, u32 rate)
306{
307 int ret = 0;
308
309 dprintk("%s()\n", __func__);
310
311 state->dnxt.symbol_rate = rate;
312
313 dprintk("%s() symbol_rate = %d\n", __func__, state->dnxt.symbol_rate);
314
315 /* check if symbol rate is within limits */
316 if ((state->dnxt.symbol_rate > state->frontend.ops.info.symbol_rate_max) ||
317 (state->dnxt.symbol_rate < state->frontend.ops.info.symbol_rate_min))
318 ret = -EOPNOTSUPP;
319
320 return ret;
321}
322
323static int cx24116_load_firmware (struct dvb_frontend* fe, const struct firmware *fw);
324
325static int cx24116_firmware_ondemand(struct dvb_frontend* fe)
326{
327 struct cx24116_state *state = fe->demodulator_priv;
328 const struct firmware *fw;
329 int ret = 0;
330
331 dprintk("%s()\n",__func__);
332
333 if (cx24116_readreg(state, 0x20) > 0)
334 {
335
336 if (state->skip_fw_load)
337 return 0;
338
339 /* Load firmware */
340 /* request the firmware, this will block until someone uploads it */
341 printk("%s: Waiting for firmware upload (%s)...\n", __func__, CX24116_DEFAULT_FIRMWARE);
342 ret = request_firmware(&fw, CX24116_DEFAULT_FIRMWARE, &state->i2c->dev);
343 printk("%s: Waiting for firmware upload(2)...\n", __func__);
344 if (ret) {
345 printk("%s: No firmware uploaded (timeout or file not found?)\n", __func__);
346 return ret;
347 }
348
349 /* Make sure we don't recurse back through here during loading */
350 state->skip_fw_load = 1;
351
352 ret = cx24116_load_firmware(fe, fw);
353 if (ret)
354 printk("%s: Writing firmware to device failed\n", __func__);
355
356 release_firmware(fw);
357
358 printk("%s: Firmware upload %s\n", __func__, ret == 0 ? "complete" : "failed");
359
360 /* Ensure firmware is always loaded if required */
361 state->skip_fw_load = 0;
362 }
363
364 return ret;
365}
366
367/* Take a basic firmware command structure, format it and forward it for processing */
368static int cx24116_cmd_execute(struct dvb_frontend* fe, struct cx24116_cmd *cmd)
369{
370 struct cx24116_state *state = fe->demodulator_priv;
371 int i, ret;
372
373 dprintk("%s()\n", __func__);
374
375 /* Load the firmware if required */
376 if ( (ret = cx24116_firmware_ondemand(fe)) != 0)
377 {
378 printk("%s(): Unable initialise the firmware\n", __func__);
379 return ret;
380 }
381
382 /* Write the command */
383 for(i = 0; i < cmd->len ; i++)
384 {
385 dprintk("%s: 0x%02x == 0x%02x\n", __func__, i, cmd->args[i]);
386 cx24116_writereg(state, i, cmd->args[i]);
387 }
388
389 /* Start execution and wait for cmd to terminate */
390 cx24116_writereg(state, 0x1f, 0x01);
391 while( cx24116_readreg(state, 0x1f) )
392 {
393 msleep(10);
394 if(i++ > 64)
395 {
396 /* Avoid looping forever if the firmware does no respond */
397 printk("%s() Firmware not responding\n", __func__);
398 return -EREMOTEIO;
399 }
400 }
401 return 0;
402}
403
404static int cx24116_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
405{
406 struct cx24116_state* state = fe->demodulator_priv;
407 struct cx24116_cmd cmd;
408 int ret;
409
410 dprintk("%s\n", __func__);
411 dprintk("Firmware is %zu bytes (%02x %02x .. %02x %02x)\n"
412 ,fw->size
413 ,fw->data[0]
414 ,fw->data[1]
415 ,fw->data[ fw->size-2 ]
416 ,fw->data[ fw->size-1 ]
417 );
418
419 /* Toggle 88x SRST pin to reset demod */
420 if (state->config->reset_device)
421 state->config->reset_device(fe);
422
423 /* Begin the firmware load process */
424 /* Prepare the demod, load the firmware, cleanup after load */
425 cx24116_writereg(state, 0xF1, 0x08);
426 cx24116_writereg(state, 0xF2, cx24116_readreg(state, 0xF2) | 0x03);
427 cx24116_writereg(state, 0xF3, 0x46);
428 cx24116_writereg(state, 0xF9, 0x00);
429
430 cx24116_writereg(state, 0xF0, 0x03);
431 cx24116_writereg(state, 0xF4, 0x81);
432 cx24116_writereg(state, 0xF5, 0x00);
433 cx24116_writereg(state, 0xF6, 0x00);
434
435 /* write the entire firmware as one transaction */
436 cx24116_writeregN(state, 0xF7, fw->data, fw->size);
437
438 cx24116_writereg(state, 0xF4, 0x10);
439 cx24116_writereg(state, 0xF0, 0x00);
440 cx24116_writereg(state, 0xF8, 0x06);
441
442 /* Firmware CMD 10: Chip config? */
443 cmd.args[0x00] = CMD_INIT_CMD10;
444 cmd.args[0x01] = 0x05;
445 cmd.args[0x02] = 0xdc;
446 cmd.args[0x03] = 0xda;
447 cmd.args[0x04] = 0xae;
448 cmd.args[0x05] = 0xaa;
449 cmd.args[0x06] = 0x04;
450 cmd.args[0x07] = 0x9d;
451 cmd.args[0x08] = 0xfc;
452 cmd.args[0x09] = 0x06;
453 cmd.len= 0x0a;
454 ret = cx24116_cmd_execute(fe, &cmd);
455 if (ret != 0)
456 return ret;
457
458 cx24116_writereg(state, 0x9d, 0x00);
459
460 /* Firmware CMD 14: Unknown */
461 cmd.args[0x00] = CMD_INIT_CMD14;
462 cmd.args[0x01] = 0x00;
463 cmd.args[0x02] = 0x00;
464 cmd.len= 0x03;
465 ret = cx24116_cmd_execute(fe, &cmd);
466 if (ret != 0)
467 return ret;
468
469 cx24116_writereg(state, 0xe5, 0x00);
470
471 /* Firmware CMD 13: Unknown - Firmware config? */
472 cmd.args[0x00] = CMD_INIT_CMD13;
473 cmd.args[0x01] = 0x01;
474 cmd.args[0x02] = 0x75;
475 cmd.args[0x03] = 0x00;
476 cmd.args[0x04] = 0x02;
477 cmd.args[0x05] = 0x00;
478 cmd.len= 0x06;
479 ret = cx24116_cmd_execute(fe, &cmd);
480 if (ret != 0)
481 return ret;
482
483 return 0;
484}
485
486static int cx24116_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
487{
488 /* The isl6421 module will override this function in the fops. */
489 dprintk("%s() This should never appear if the isl6421 module is loaded correctly\n",__func__);
490
491 return -EOPNOTSUPP;
492}
493
494static int cx24116_read_status(struct dvb_frontend* fe, fe_status_t* status)
495{
496 struct cx24116_state *state = fe->demodulator_priv;
497
498 int lock = cx24116_readreg(state, 0x9d);
499
500 dprintk("%s: status = 0x%02x\n", __func__, lock);
501
502 *status = 0;
503
504 if (lock & 0x01)
505 *status |= FE_HAS_SIGNAL;
506 if (lock & 0x02)
507 *status |= FE_HAS_CARRIER;
508 if (lock & 0x04)
509 *status |= FE_HAS_VITERBI;
510 if (lock & 0x08)
511 *status |= FE_HAS_SYNC | FE_HAS_LOCK;
512
513 return 0;
514}
515
516/* TODO: Not clear how we do this */
517static int cx24116_read_ber(struct dvb_frontend* fe, u32* ber)
518{
519 //struct cx24116_state *state = fe->demodulator_priv;
520 dprintk("%s()\n", __func__);
521 *ber = 0;
522
523 return 0;
524}
525
526/* Signal strength (0..100)% = (sig & 0xf0) * 10 + (sig & 0x0f) * 10 / 16 */
527static int cx24116_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
528{
529 struct cx24116_state *state = fe->demodulator_priv;
530 u8 strength_reg;
531 static const u32 strength_tab[] = { /* 10 x Table (rounded up) */
532 0x00000,0x0199A,0x03333,0x04ccD,0x06667,0x08000,0x0999A,0x0b333,0x0cccD,0x0e667,
533 0x10000,0x1199A,0x13333,0x14ccD,0x16667,0x18000 };
534
535 dprintk("%s()\n", __func__);
536
537 strength_reg = cx24116_readreg(state, CX24116_REG_SIGNAL);
538
539 if(strength_reg < 0xa0)
540 *signal_strength = strength_tab [ ( strength_reg & 0xf0 ) >> 4 ] +
541 ( strength_tab [ ( strength_reg & 0x0f ) ] >> 4 );
542 else
543 *signal_strength = 0xffff;
544
545 dprintk("%s: Signal strength (raw / cooked) = (0x%02x / 0x%04x)\n",
546 __func__,strength_reg,*signal_strength);
547
548 return 0;
549}
550
551/* TODO: Not clear how we do this */
552static int cx24116_read_snr(struct dvb_frontend* fe, u16* snr)
553{
554 //struct cx24116_state *state = fe->demodulator_priv;
555 dprintk("%s()\n", __func__);
556 *snr = 0;
557
558 return 0;
559}
560
561/* TODO: Not clear how we do this */
562static int cx24116_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
563{
564 //struct cx24116_state *state = fe->demodulator_priv;
565 dprintk("%s()\n", __func__);
566 *ucblocks = 0;
567
568 return 0;
569}
570
571/* Overwrite the current tuning params, we are about to tune */
572static void cx24116_clone_params(struct dvb_frontend* fe)
573{
574 struct cx24116_state *state = fe->demodulator_priv;
575 memcpy(&state->dcur, &state->dnxt, sizeof(state->dcur));
576}
577
578static int cx24116_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
579{
580 struct cx24116_cmd cmd;
581 int ret;
582
583 dprintk("%s(%d)\n", __func__, tone);
584 if ( (tone != SEC_TONE_ON) && (tone != SEC_TONE_OFF) ) {
585 printk("%s: Invalid, tone=%d\n", __func__, tone);
586 return -EINVAL;
587 }
588
589 /* This is always done before the tone is set */
590 cmd.args[0x00] = CMD_SET_TONEPRE;
591 cmd.args[0x01] = 0x00;
592 cmd.len= 0x02;
593 ret = cx24116_cmd_execute(fe, &cmd);
594 if (ret != 0)
595 return ret;
596
597 /* Now we set the tone */
598 cmd.args[0x00] = CMD_SET_TONE;
599 cmd.args[0x01] = 0x00;
600 cmd.args[0x02] = 0x00;
601
602 switch (tone) {
603 case SEC_TONE_ON:
604 dprintk("%s: setting tone on\n", __func__);
605 cmd.args[0x03] = 0x01;
606 break;
607 case SEC_TONE_OFF:
608 dprintk("%s: setting tone off\n",__func__);
609 cmd.args[0x03] = 0x00;
610 break;
611 }
612 cmd.len= 0x04;
613
614 return cx24116_cmd_execute(fe, &cmd);
615}
616
617/* Initialise DiSEqC */
618static int cx24116_diseqc_init(struct dvb_frontend* fe)
619{
620 struct cx24116_state *state = fe->demodulator_priv;
621
622 /* Default DiSEqC burst state */
623 state->burst = CX24116_DISEQC_MINI_A;
624
625 return 0;
626}
627
628/* Send DiSEqC message with derived burst (hack) || previous burst */
629static int cx24116_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *d)
630{
631 struct cx24116_state *state = fe->demodulator_priv;
632 struct cx24116_cmd cmd;
633 int i, ret;
634
635 /* Dump DiSEqC message */
636 if (debug) {
637 printk("cx24116: %s(", __func__);
638 for(i = 0 ; i < d->msg_len ;) {
639 printk("0x%02x", d->msg[i]);
640 if(++i < d->msg_len)
641 printk(", ");
642 }
643 printk(")\n");
644 }
645
646 if(d->msg_len > (CX24116_ARGLEN - CX24116_DISEQC_MSGOFS))
647 return -EINVAL;
648
649 cmd.args[0x00] = CMD_SEND_DISEQC;
650 cmd.args[CX24116_DISEQC_ARG2_2] = 0x02;
651 cmd.args[CX24116_DISEQC_ARG3_0] = 0x00;
652 cmd.args[CX24116_DISEQC_ARG4_0] = 0x00;
653
654 /* DiSEqC message */
655 for (i = 0; i < d->msg_len; i++)
656 cmd.args[CX24116_DISEQC_MSGOFS + i] = d->msg[i];
657
658 /* Hack: Derive burst from command else use previous burst */
659 if(d->msg_len >= 4 && d->msg[2] == 0x38)
660 cmd.args[CX24116_DISEQC_BURST] = (d->msg[3] >> 2) & 1;
661 else
662 cmd.args[CX24116_DISEQC_BURST] = state->burst;
663
664 cmd.args[CX24116_DISEQC_MSGLEN] = d->msg_len;
665 cmd.len = CX24116_DISEQC_MSGOFS + d->msg_len;
666
667 ret = cx24116_cmd_execute(fe, &cmd);
668
669 /* Firmware command duration is unknown, so guess...
670 *
671 * Eutelsat spec:
672 * >15ms delay +
673 * 13.5ms per byte +
674 * >15ms delay +
675 * 12.5ms burst +
676 * >15ms delay
677 */
678 if(ret == 0)
679 msleep( (cmd.args[CX24116_DISEQC_MSGLEN] << 4) + 60 );
680
681 return ret;
682}
683
684/* Send DiSEqC burst */
685static int cx24116_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
686{
687 struct cx24116_state *state = fe->demodulator_priv;
688 struct cx24116_cmd cmd;
689 int ret;
690
691 dprintk("%s(%d)\n",__func__,(int)burst);
692
693 cmd.args[0x00] = CMD_SEND_DISEQC;
694 cmd.args[CX24116_DISEQC_ARG2_2] = 0x02;
695 cmd.args[CX24116_DISEQC_ARG3_0] = 0x00;
696 cmd.args[CX24116_DISEQC_ARG4_0] = 0x00;
697
698 if (burst == SEC_MINI_A)
699 cmd.args[CX24116_DISEQC_BURST] = CX24116_DISEQC_MINI_A;
700 else if(burst == SEC_MINI_B)
701 cmd.args[CX24116_DISEQC_BURST] = CX24116_DISEQC_MINI_B;
702 else
703 return -EINVAL;
704
705 /* Cache as previous burst state */
706 state->burst= cmd.args[CX24116_DISEQC_BURST];
707
708 cmd.args[CX24116_DISEQC_MSGLEN] = 0x00;
709 cmd.len= CX24116_DISEQC_MSGOFS;
710
711 ret= cx24116_cmd_execute(fe, &cmd);
712
713 /* Firmware command duration is unknown, so guess... */
714 if(ret == 0)
715 msleep(60);
716
717 return ret;
718}
719
720static void cx24116_release(struct dvb_frontend* fe)
721{
722 struct cx24116_state* state = fe->demodulator_priv;
723 dprintk("%s\n",__func__);
724 kfree(state);
725}
726
727static struct dvb_frontend_ops cx24116_ops;
728
729struct dvb_frontend* cx24116_attach(const struct cx24116_config* config,
730 struct i2c_adapter* i2c)
731{
732 struct cx24116_state* state = NULL;
733 int ret;
734
735 dprintk("%s\n",__func__);
736
737 /* allocate memory for the internal state */
738 state = kmalloc(sizeof(struct cx24116_state), GFP_KERNEL);
739 if (state == NULL) {
740 printk("Unable to kmalloc\n");
741 goto error;
742 }
743
744 /* setup the state */
745 memset(state, 0, sizeof(struct cx24116_state));
746
747 state->config = config;
748 state->i2c = i2c;
749
750 /* check if the demod is present */
751 ret = (cx24116_readreg(state, 0xFF) << 8) | cx24116_readreg(state, 0xFE);
752 if (ret != 0x0501) {
753 printk("Invalid probe, probably not a CX24116 device\n");
754 goto error;
755 }
756
757 /* create dvb_frontend */
758 memcpy(&state->frontend.ops, &cx24116_ops, sizeof(struct dvb_frontend_ops));
759 state->frontend.demodulator_priv = state;
760 return &state->frontend;
761
762error:
763 kfree(state);
764
765 return NULL;
766}
767
768static int cx24116_get_params(struct dvb_frontend* fe)
769{
770 struct cx24116_state *state = fe->demodulator_priv;
771 struct tv_frontend_properties *cache = &fe->tv_property_cache;
772
773 dprintk("%s()\n",__func__);
774
775 cache->frequency = state->dcur.frequency;
776 cache->inversion = state->dcur.inversion;
777 cache->modulation = state->dcur.modulation;
778 cache->fec_inner = state->dcur.fec;
779 cache->symbol_rate = state->dcur.symbol_rate;
780
781 return 0;
782}
783
784static int cx24116_initfe(struct dvb_frontend* fe)
785{
786 dprintk("%s()\n",__func__);
787
788 return cx24116_diseqc_init(fe);
789}
790
791static int cx24116_set_property(struct dvb_frontend *fe, tv_property_t* tvp)
792{
793 dprintk("%s(..)\n", __func__);
794 return 0;
795}
796
797static int cx24116_set_params(struct dvb_frontend *fe)
798{
799 dprintk("%s(..) We were notified that a tune request may occur\n", __func__);
800 return 0;
801}
802
803/* dvb-core told us to tune, the tv property cache will be complete,
804 * it's safe for is to pull values and use them for tuning purposes.
805 */
806static int cx24116_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
807{
808 struct cx24116_state *state = fe->demodulator_priv;
809 struct tv_frontend_properties *c = &fe->tv_property_cache;
810 struct cx24116_cmd cmd;
811 fe_status_t tunerstat;
812 int ret;
813 u8 retune=4;
814
815 dprintk("%s()\n",__func__);
816
817 state->dnxt.modulation = c->modulation;
818 state->dnxt.frequency = c->frequency;
819
820 if ((ret = cx24116_set_inversion(state, c->inversion)) != 0)
821 return ret;
822
823 if ((ret = cx24116_set_fec(state, c->modulation, c->fec_inner)) != 0)
824 return ret;
825
826 if ((ret = cx24116_set_symbolrate(state, c->symbol_rate)) != 0)
827 return ret;
828
829 /* discard the 'current' tuning parameters and prepare to tune */
830 cx24116_clone_params(fe);
831
832 dprintk("%s: frequency = %d\n", __func__, state->dcur.frequency);
833 dprintk("%s: symbol_rate = %d\n", __func__, state->dcur.symbol_rate);
834 dprintk("%s: FEC = %d (mask/val = 0x%02x/0x%02x)\n", __func__,
835 state->dcur.fec, state->dcur.fec_mask, state->dcur.fec_val);
836 dprintk("%s: Inversion = %d (val = 0x%02x)\n", __func__,
837 state->dcur.inversion, state->dcur.inversion_val);
838
839 if (state->config->set_ts_params)
840 state->config->set_ts_params(fe, 0);
841
842 /* Prepare a tune request */
843 cmd.args[0x00] = CMD_TUNEREQUEST;
844
845 /* Frequency */
846 cmd.args[0x01] = (state->dcur.frequency & 0xff0000) >> 16;
847 cmd.args[0x02] = (state->dcur.frequency & 0x00ff00) >> 8;
848 cmd.args[0x03] = (state->dcur.frequency & 0x0000ff);
849
850 /* Symbol Rate */
851 cmd.args[0x04] = ((state->dcur.symbol_rate / 1000) & 0xff00) >> 8;
852 cmd.args[0x05] = ((state->dcur.symbol_rate / 1000) & 0x00ff);
853
854 /* Automatic Inversion */
855 cmd.args[0x06] = state->dcur.inversion_val;
856
857 /* Modulation / FEC & Pilot Off */
858 cmd.args[0x07] = state->dcur.fec_val;
859
860 if (c->pilot == PILOT_ON)
861 cmd.args[0x07] |= 0x40;
862
863 cmd.args[0x08] = CX24116_SEARCH_RANGE_KHZ >> 8;
864 cmd.args[0x09] = CX24116_SEARCH_RANGE_KHZ & 0xff;
865 cmd.args[0x0a] = 0x00;
866 cmd.args[0x0b] = 0x00;
867 cmd.args[0x0c] = 0x02;
868 cmd.args[0x0d] = state->dcur.fec_mask;
869 cmd.args[0x0e] = 0x06;
870 cmd.args[0x0f] = 0x00;
871 cmd.args[0x10] = 0x00;
872 cmd.args[0x11] = 0xFA;
873 cmd.args[0x12] = 0x24;
874 cmd.len= 0x13;
875
876 /* We need to support pilot and non-pilot tuning in the
877 * driver automatically. This is a workaround for because
878 * the demod does not support autodetect.
879 */
880 do {
881 /* Reset status register? */
882 cx24116_writereg(state, 0x9d, 0xc1);
883
884 /* Tune */
885 ret = cx24116_cmd_execute(fe, &cmd);
886 if( ret != 0 )
887 break;
888
889 /* The hardware can take time to lock, wait a while */
890 msleep(500);
891
892 cx24116_read_status(fe, &tunerstat);
893 if(tunerstat & FE_HAS_SIGNAL) {
894 if(tunerstat & FE_HAS_SYNC)
895 /* Tuned */
896 break;
897 else if(c->pilot == PILOT_AUTO)
898 /* Toggle pilot bit */
899 cmd.args[0x07] ^= 0x40;
900 }
901 }
902 while(--retune);
903
904 return ret;
905}
906
907static struct dvb_frontend_ops cx24116_ops = {
908
909 .info = {
910 .name = "Conexant CX24116/CX24118",
911 .type = FE_QPSK,
912 .frequency_min = 950000,
913 .frequency_max = 2150000,
914 .frequency_stepsize = 1011, /* kHz for QPSK frontends */
915 .frequency_tolerance = 5000,
916 .symbol_rate_min = 1000000,
917 .symbol_rate_max = 45000000,
918 .caps = FE_CAN_INVERSION_AUTO |
919 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
920 FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
921 FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
922 FE_CAN_QPSK | FE_CAN_RECOVER
923 },
924
925 .release = cx24116_release,
926
927 .init = cx24116_initfe,
928 .read_status = cx24116_read_status,
929 .read_ber = cx24116_read_ber,
930 .read_signal_strength = cx24116_read_signal_strength,
931 .read_snr = cx24116_read_snr,
932 .read_ucblocks = cx24116_read_ucblocks,
933 .set_tone = cx24116_set_tone,
934 .set_voltage = cx24116_set_voltage,
935 .diseqc_send_master_cmd = cx24116_send_diseqc_msg,
936 .diseqc_send_burst = cx24116_diseqc_send_burst,
937
938 .set_property = cx24116_set_property,
939 .set_params = cx24116_set_params,
940 .set_frontend = cx24116_set_frontend,
941};
942
943module_param(debug, int, 0644);
944MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
945
946MODULE_DESCRIPTION("DVB Frontend module for Conexant cx24116/cx24118 hardware");
947MODULE_AUTHOR("Steven Toth");
948MODULE_LICENSE("GPL");
949
950EXPORT_SYMBOL(cx24116_attach);