2 Driver for ST STV0299 demodulator
4 Copyright (C) 2001-2002 Convergence Integrated Media GmbH
5 <ralph@convergence.de>,
6 <holger@convergence.de>,
12 Copyright (C) 2002 by Peter Schildmann <peter.schildmann@web.de>
17 Copyright (C) 2002 Felix Domke <tmbinc@elitedvb.net>
18 & Andreas Oberritter <obi@linuxtv.org>
21 Support for Samsung TBMU24112IMB used on Technisat SkyStar2 rev. 2.6B
23 Copyright (C) 2003 Vadim Catana <skystar@moldova.cc>:
25 Support for Philips SU1278 on Technotrend hardware
27 Copyright (C) 2004 Andrew de Quincey <adq_dvb@lidskialf.net>
29 This program is free software; you can redistribute it and/or modify
30 it under the terms of the GNU General Public License as published by
31 the Free Software Foundation; either version 2 of the License, or
32 (at your option) any later version.
34 This program is distributed in the hope that it will be useful,
35 but WITHOUT ANY WARRANTY; without even the implied warranty of
36 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37 GNU General Public License for more details.
39 You should have received a copy of the GNU General Public License
40 along with this program; if not, write to the Free Software
41 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
45 #include <linux/init.h>
46 #include <linux/kernel.h>
47 #include <linux/module.h>
48 #include <linux/moduleparam.h>
49 #include <linux/string.h>
50 #include <linux/slab.h>
51 #include <linux/jiffies.h>
52 #include <asm/div64.h>
54 #include "dvb_frontend.h"
57 struct stv0299_state
{
58 struct i2c_adapter
* i2c
;
59 struct dvb_frontend_ops ops
;
60 const struct stv0299_config
* config
;
61 struct dvb_frontend frontend
;
66 fe_code_rate_t fec_inner
;
71 #define STATUS_UCBLOCKS 1
74 static int debug_legacy_dish_switch
;
75 #define dprintk(args...) \
77 if (debug) printk(KERN_DEBUG "stv0299: " args); \
81 static int stv0299_writeregI (struct stv0299_state
* state
, u8 reg
, u8 data
)
84 u8 buf
[] = { reg
, data
};
85 struct i2c_msg msg
= { .addr
= state
->config
->demod_address
, .flags
= 0, .buf
= buf
, .len
= 2 };
87 ret
= i2c_transfer (state
->i2c
, &msg
, 1);
90 dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
91 "ret == %i)\n", __FUNCTION__
, reg
, data
, ret
);
93 return (ret
!= 1) ? -EREMOTEIO
: 0;
96 int stv0299_writereg (struct dvb_frontend
* fe
, u8 reg
, u8 data
)
98 struct stv0299_state
* state
= fe
->demodulator_priv
;
100 return stv0299_writeregI(state
, reg
, data
);
103 static u8
stv0299_readreg (struct stv0299_state
* state
, u8 reg
)
108 struct i2c_msg msg
[] = { { .addr
= state
->config
->demod_address
, .flags
= 0, .buf
= b0
, .len
= 1 },
109 { .addr
= state
->config
->demod_address
, .flags
= I2C_M_RD
, .buf
= b1
, .len
= 1 } };
111 ret
= i2c_transfer (state
->i2c
, msg
, 2);
114 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n",
115 __FUNCTION__
, reg
, ret
);
120 static int stv0299_readregs (struct stv0299_state
* state
, u8 reg1
, u8
*b
, u8 len
)
123 struct i2c_msg msg
[] = { { .addr
= state
->config
->demod_address
, .flags
= 0, .buf
= ®1
, .len
= 1 },
124 { .addr
= state
->config
->demod_address
, .flags
= I2C_M_RD
, .buf
= b
, .len
= len
} };
126 ret
= i2c_transfer (state
->i2c
, msg
, 2);
129 dprintk("%s: readreg error (ret == %i)\n", __FUNCTION__
, ret
);
131 return ret
== 2 ? 0 : ret
;
134 static int stv0299_set_FEC (struct stv0299_state
* state
, fe_code_rate_t fec
)
136 dprintk ("%s\n", __FUNCTION__
);
141 return stv0299_writeregI (state
, 0x31, 0x1f);
145 return stv0299_writeregI (state
, 0x31, 0x01);
149 return stv0299_writeregI (state
, 0x31, 0x02);
153 return stv0299_writeregI (state
, 0x31, 0x04);
157 return stv0299_writeregI (state
, 0x31, 0x08);
161 return stv0299_writeregI (state
, 0x31, 0x10);
170 static fe_code_rate_t
stv0299_get_fec (struct stv0299_state
* state
)
172 static fe_code_rate_t fec_tab
[] = { FEC_2_3
, FEC_3_4
, FEC_5_6
,
176 dprintk ("%s\n", __FUNCTION__
);
178 index
= stv0299_readreg (state
, 0x1b);
184 return fec_tab
[index
];
187 static int stv0299_wait_diseqc_fifo (struct stv0299_state
* state
, int timeout
)
189 unsigned long start
= jiffies
;
191 dprintk ("%s\n", __FUNCTION__
);
193 while (stv0299_readreg(state
, 0x0a) & 1) {
194 if (jiffies
- start
> timeout
) {
195 dprintk ("%s: timeout!!\n", __FUNCTION__
);
204 static int stv0299_wait_diseqc_idle (struct stv0299_state
* state
, int timeout
)
206 unsigned long start
= jiffies
;
208 dprintk ("%s\n", __FUNCTION__
);
210 while ((stv0299_readreg(state
, 0x0a) & 3) != 2 ) {
211 if (jiffies
- start
> timeout
) {
212 dprintk ("%s: timeout!!\n", __FUNCTION__
);
221 static int stv0299_set_symbolrate (struct dvb_frontend
* fe
, u32 srate
)
223 struct stv0299_state
* state
= fe
->demodulator_priv
;
227 // check rate is within limits
228 if ((srate
< 1000000) || (srate
> 45000000)) return -EINVAL
;
230 // calculate value to program
232 big
+= (state
->config
->mclk
-1); // round correctly
233 do_div(big
, state
->config
->mclk
);
236 return state
->config
->set_symbol_rate(fe
, srate
, ratio
);
239 static int stv0299_get_symbolrate (struct stv0299_state
* state
)
241 u32 Mclk
= state
->config
->mclk
/ 4096L;
247 dprintk ("%s\n", __FUNCTION__
);
249 stv0299_readregs (state
, 0x1f, sfr
, 3);
250 stv0299_readregs (state
, 0x1a, &rtf
, 1);
252 srate
= (sfr
[0] << 8) | sfr
[1];
255 srate
+= (sfr
[2] >> 4) * Mclk
/ 256;
256 offset
= (s32
) rtf
* (srate
/ 4096L);
259 dprintk ("%s : srate = %i\n", __FUNCTION__
, srate
);
260 dprintk ("%s : ofset = %i\n", __FUNCTION__
, offset
);
271 static int stv0299_send_diseqc_msg (struct dvb_frontend
* fe
,
272 struct dvb_diseqc_master_cmd
*m
)
274 struct stv0299_state
* state
= fe
->demodulator_priv
;
278 dprintk ("%s\n", __FUNCTION__
);
280 if (stv0299_wait_diseqc_idle (state
, 100) < 0)
283 val
= stv0299_readreg (state
, 0x08);
285 if (stv0299_writeregI (state
, 0x08, (val
& ~0x7) | 0x6)) /* DiSEqC mode */
288 for (i
=0; i
<m
->msg_len
; i
++) {
289 if (stv0299_wait_diseqc_fifo (state
, 100) < 0)
292 if (stv0299_writeregI (state
, 0x09, m
->msg
[i
]))
296 if (stv0299_wait_diseqc_idle (state
, 100) < 0)
302 static int stv0299_send_diseqc_burst (struct dvb_frontend
* fe
, fe_sec_mini_cmd_t burst
)
304 struct stv0299_state
* state
= fe
->demodulator_priv
;
307 dprintk ("%s\n", __FUNCTION__
);
309 if (stv0299_wait_diseqc_idle (state
, 100) < 0)
312 val
= stv0299_readreg (state
, 0x08);
314 if (stv0299_writeregI (state
, 0x08, (val
& ~0x7) | 0x2)) /* burst mode */
317 if (stv0299_writeregI (state
, 0x09, burst
== SEC_MINI_A
? 0x00 : 0xff))
320 if (stv0299_wait_diseqc_idle (state
, 100) < 0)
323 if (stv0299_writeregI (state
, 0x08, val
))
329 static int stv0299_set_tone (struct dvb_frontend
* fe
, fe_sec_tone_mode_t tone
)
331 struct stv0299_state
* state
= fe
->demodulator_priv
;
334 if (stv0299_wait_diseqc_idle (state
, 100) < 0)
337 val
= stv0299_readreg (state
, 0x08);
341 return stv0299_writeregI (state
, 0x08, val
| 0x3);
344 return stv0299_writeregI (state
, 0x08, (val
& ~0x3) | 0x02);
351 static int stv0299_set_voltage (struct dvb_frontend
* fe
, fe_sec_voltage_t voltage
)
353 struct stv0299_state
* state
= fe
->demodulator_priv
;
357 dprintk("%s: %s\n", __FUNCTION__
,
358 voltage
== SEC_VOLTAGE_13
? "SEC_VOLTAGE_13" :
359 voltage
== SEC_VOLTAGE_18
? "SEC_VOLTAGE_18" : "??");
361 reg0x08
= stv0299_readreg (state
, 0x08);
362 reg0x0c
= stv0299_readreg (state
, 0x0c);
365 * H/V switching over OP0, OP1 and OP2 are LNB power enable bits
369 if (voltage
== SEC_VOLTAGE_OFF
) {
370 stv0299_writeregI (state
, 0x0c, 0x00); /* LNB power off! */
371 return stv0299_writeregI (state
, 0x08, 0x00); /* LNB power off! */
374 stv0299_writeregI (state
, 0x08, (reg0x08
& 0x3f) | (state
->config
->lock_output
<< 6));
378 if (state
->config
->volt13_op0_op1
== STV0299_VOLT13_OP0
) reg0x0c
|= 0x10;
379 else reg0x0c
|= 0x40;
381 return stv0299_writeregI(state
, 0x0c, reg0x0c
);
384 return stv0299_writeregI(state
, 0x0c, reg0x0c
| 0x50);
390 static int stv0299_send_legacy_dish_cmd (struct dvb_frontend
* fe
, u32 cmd
)
392 struct stv0299_state
* state
= fe
->demodulator_priv
;
398 struct timeval nexttime
;
399 struct timeval tv
[10];
401 reg0x08
= stv0299_readreg (state
, 0x08);
402 reg0x0c
= stv0299_readreg (state
, 0x0c);
404 stv0299_writeregI (state
, 0x08, (reg0x08
& 0x3f) | (state
->config
->lock_output
<< 6));
405 if (state
->config
->volt13_op0_op1
== STV0299_VOLT13_OP0
)
409 if (debug_legacy_dish_switch
)
410 printk ("%s switch command: 0x%04x\n",__FUNCTION__
, cmd
);
412 do_gettimeofday (&nexttime
);
413 if (debug_legacy_dish_switch
)
414 memcpy (&tv
[0], &nexttime
, sizeof (struct timeval
));
415 stv0299_writeregI (state
, 0x0c, reg0x0c
| 0x50); /* set LNB to 18V */
417 dvb_frontend_sleep_until(&nexttime
, 32000);
419 for (i
=0; i
<9; i
++) {
420 if (debug_legacy_dish_switch
)
421 do_gettimeofday (&tv
[i
+1]);
422 if((cmd
& 0x01) != last
) {
423 /* set voltage to (last ? 13V : 18V) */
424 stv0299_writeregI (state
, 0x0c, reg0x0c
| (last
? lv_mask
: 0x50));
425 last
= (last
) ? 0 : 1;
431 dvb_frontend_sleep_until(&nexttime
, 8000);
433 if (debug_legacy_dish_switch
) {
434 printk ("%s(%d): switch delay (should be 32k followed by all 8k\n",
435 __FUNCTION__
, fe
->dvb
->num
);
436 for (i
= 1; i
< 10; i
++)
437 printk ("%d: %d\n", i
, timeval_usec_diff(tv
[i
-1] , tv
[i
]));
443 static int stv0299_init (struct dvb_frontend
* fe
)
445 struct stv0299_state
* state
= fe
->demodulator_priv
;
448 dprintk("stv0299: init chip\n");
450 for (i
=0; !(state
->config
->inittab
[i
] == 0xff && state
->config
->inittab
[i
+1] == 0xff); i
+=2)
451 stv0299_writeregI(state
, state
->config
->inittab
[i
], state
->config
->inittab
[i
+1]);
453 if (state
->config
->pll_init
) {
454 stv0299_writeregI(state
, 0x05, 0xb5); /* enable i2c repeater on stv0299 */
455 state
->config
->pll_init(fe
, state
->i2c
);
456 stv0299_writeregI(state
, 0x05, 0x35); /* disable i2c repeater on stv0299 */
462 static int stv0299_read_status(struct dvb_frontend
* fe
, fe_status_t
* status
)
464 struct stv0299_state
* state
= fe
->demodulator_priv
;
466 u8 signal
= 0xff - stv0299_readreg (state
, 0x18);
467 u8 sync
= stv0299_readreg (state
, 0x1b);
469 dprintk ("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __FUNCTION__
, sync
);
473 *status
|= FE_HAS_SIGNAL
;
476 *status
|= FE_HAS_CARRIER
;
479 *status
|= FE_HAS_VITERBI
;
482 *status
|= FE_HAS_SYNC
;
484 if ((sync
& 0x98) == 0x98)
485 *status
|= FE_HAS_LOCK
;
490 static int stv0299_read_ber(struct dvb_frontend
* fe
, u32
* ber
)
492 struct stv0299_state
* state
= fe
->demodulator_priv
;
494 if (state
->errmode
!= STATUS_BER
) return 0;
495 *ber
= (stv0299_readreg (state
, 0x1d) << 8) | stv0299_readreg (state
, 0x1e);
500 static int stv0299_read_signal_strength(struct dvb_frontend
* fe
, u16
* strength
)
502 struct stv0299_state
* state
= fe
->demodulator_priv
;
504 s32 signal
= 0xffff - ((stv0299_readreg (state
, 0x18) << 8)
505 | stv0299_readreg (state
, 0x19));
507 dprintk ("%s : FE_READ_SIGNAL_STRENGTH : AGC2I: 0x%02x%02x, signal=0x%04x\n", __FUNCTION__
,
508 stv0299_readreg (state
, 0x18),
509 stv0299_readreg (state
, 0x19), (int) signal
);
511 signal
= signal
* 5 / 4;
512 *strength
= (signal
> 0xffff) ? 0xffff : (signal
< 0) ? 0 : signal
;
517 static int stv0299_read_snr(struct dvb_frontend
* fe
, u16
* snr
)
519 struct stv0299_state
* state
= fe
->demodulator_priv
;
521 s32 xsnr
= 0xffff - ((stv0299_readreg (state
, 0x24) << 8)
522 | stv0299_readreg (state
, 0x25));
523 xsnr
= 3 * (xsnr
- 0xa100);
524 *snr
= (xsnr
> 0xffff) ? 0xffff : (xsnr
< 0) ? 0 : xsnr
;
529 static int stv0299_read_ucblocks(struct dvb_frontend
* fe
, u32
* ucblocks
)
531 struct stv0299_state
* state
= fe
->demodulator_priv
;
533 if (state
->errmode
!= STATUS_UCBLOCKS
) *ucblocks
= 0;
534 else *ucblocks
= (stv0299_readreg (state
, 0x1d) << 8) | stv0299_readreg (state
, 0x1e);
539 static int stv0299_set_frontend(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* p
)
541 struct stv0299_state
* state
= fe
->demodulator_priv
;
544 dprintk ("%s : FE_SET_FRONTEND\n", __FUNCTION__
);
547 if (p
->inversion
== INVERSION_OFF
) invval
= 0;
548 else if (p
->inversion
== INVERSION_ON
) invval
= 1;
550 printk("stv0299 does not support auto-inversion\n");
553 if (state
->config
->invert
) invval
= (~invval
) & 1;
554 stv0299_writeregI(state
, 0x0c, (stv0299_readreg(state
, 0x0c) & 0xfe) | invval
);
556 stv0299_writeregI(state
, 0x05, 0xb5); /* enable i2c repeater on stv0299 */
557 state
->config
->pll_set(fe
, state
->i2c
, p
);
558 stv0299_writeregI(state
, 0x05, 0x35); /* disable i2c repeater on stv0299 */
560 stv0299_set_FEC (state
, p
->u
.qpsk
.fec_inner
);
561 stv0299_set_symbolrate (fe
, p
->u
.qpsk
.symbol_rate
);
562 stv0299_writeregI(state
, 0x22, 0x00);
563 stv0299_writeregI(state
, 0x23, 0x00);
565 state
->tuner_frequency
= p
->frequency
;
566 state
->fec_inner
= p
->u
.qpsk
.fec_inner
;
567 state
->symbol_rate
= p
->u
.qpsk
.symbol_rate
;
572 static int stv0299_get_frontend(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* p
)
574 struct stv0299_state
* state
= fe
->demodulator_priv
;
578 derot_freq
= (s32
)(s16
) ((stv0299_readreg (state
, 0x22) << 8)
579 | stv0299_readreg (state
, 0x23));
581 derot_freq
*= (state
->config
->mclk
>> 16);
585 p
->frequency
+= derot_freq
;
587 invval
= stv0299_readreg (state
, 0x0c) & 1;
588 if (state
->config
->invert
) invval
= (~invval
) & 1;
589 p
->inversion
= invval
? INVERSION_ON
: INVERSION_OFF
;
591 p
->u
.qpsk
.fec_inner
= stv0299_get_fec (state
);
592 p
->u
.qpsk
.symbol_rate
= stv0299_get_symbolrate (state
);
597 static int stv0299_sleep(struct dvb_frontend
* fe
)
599 struct stv0299_state
* state
= fe
->demodulator_priv
;
601 stv0299_writeregI(state
, 0x02, 0x80);
602 state
->initialised
= 0;
607 static int stv0299_get_tune_settings(struct dvb_frontend
* fe
, struct dvb_frontend_tune_settings
* fesettings
)
609 struct stv0299_state
* state
= fe
->demodulator_priv
;
611 fesettings
->min_delay_ms
= state
->config
->min_delay_ms
;
612 if (fesettings
->parameters
.u
.qpsk
.symbol_rate
< 10000000) {
613 fesettings
->step_size
= fesettings
->parameters
.u
.qpsk
.symbol_rate
/ 32000;
614 fesettings
->max_drift
= 5000;
616 fesettings
->step_size
= fesettings
->parameters
.u
.qpsk
.symbol_rate
/ 16000;
617 fesettings
->max_drift
= fesettings
->parameters
.u
.qpsk
.symbol_rate
/ 2000;
622 static void stv0299_release(struct dvb_frontend
* fe
)
624 struct stv0299_state
* state
= fe
->demodulator_priv
;
628 static struct dvb_frontend_ops stv0299_ops
;
630 struct dvb_frontend
* stv0299_attach(const struct stv0299_config
* config
,
631 struct i2c_adapter
* i2c
)
633 struct stv0299_state
* state
= NULL
;
636 /* allocate memory for the internal state */
637 state
= kmalloc(sizeof(struct stv0299_state
), GFP_KERNEL
);
638 if (state
== NULL
) goto error
;
640 /* setup the state */
641 state
->config
= config
;
643 memcpy(&state
->ops
, &stv0299_ops
, sizeof(struct dvb_frontend_ops
));
644 state
->initialised
= 0;
645 state
->tuner_frequency
= 0;
646 state
->symbol_rate
= 0;
647 state
->fec_inner
= 0;
648 state
->errmode
= STATUS_BER
;
650 /* check if the demod is there */
651 stv0299_writeregI(state
, 0x02, 0x34); /* standby off */
653 id
= stv0299_readreg(state
, 0x00);
655 /* register 0x00 contains 0xa1 for STV0299 and STV0299B */
656 /* register 0x00 might contain 0x80 when returning from standby */
657 if (id
!= 0xa1 && id
!= 0x80) goto error
;
659 /* create dvb_frontend */
660 state
->frontend
.ops
= &state
->ops
;
661 state
->frontend
.demodulator_priv
= state
;
662 return &state
->frontend
;
669 static struct dvb_frontend_ops stv0299_ops
= {
672 .name
= "ST STV0299 DVB-S",
674 .frequency_min
= 950000,
675 .frequency_max
= 2150000,
676 .frequency_stepsize
= 125, /* kHz for QPSK frontends */
677 .frequency_tolerance
= 0,
678 .symbol_rate_min
= 1000000,
679 .symbol_rate_max
= 45000000,
680 .symbol_rate_tolerance
= 500, /* ppm */
681 .caps
= FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
| FE_CAN_FEC_3_4
|
682 FE_CAN_FEC_5_6
| FE_CAN_FEC_7_8
|
687 .release
= stv0299_release
,
689 .init
= stv0299_init
,
690 .sleep
= stv0299_sleep
,
692 .set_frontend
= stv0299_set_frontend
,
693 .get_frontend
= stv0299_get_frontend
,
694 .get_tune_settings
= stv0299_get_tune_settings
,
696 .read_status
= stv0299_read_status
,
697 .read_ber
= stv0299_read_ber
,
698 .read_signal_strength
= stv0299_read_signal_strength
,
699 .read_snr
= stv0299_read_snr
,
700 .read_ucblocks
= stv0299_read_ucblocks
,
702 .diseqc_send_master_cmd
= stv0299_send_diseqc_msg
,
703 .diseqc_send_burst
= stv0299_send_diseqc_burst
,
704 .set_tone
= stv0299_set_tone
,
705 .set_voltage
= stv0299_set_voltage
,
706 .dishnetwork_send_legacy_command
= stv0299_send_legacy_dish_cmd
,
709 module_param(debug_legacy_dish_switch
, int, 0444);
710 MODULE_PARM_DESC(debug_legacy_dish_switch
, "Enable timing analysis for Dish Network legacy switches");
712 module_param(debug
, int, 0644);
713 MODULE_PARM_DESC(debug
, "Turn on/off frontend debugging (default:off).");
715 MODULE_DESCRIPTION("ST STV0299 DVB Demodulator driver");
716 MODULE_AUTHOR("Ralph Metzler, Holger Waechtler, Peter Schildmann, Felix Domke, "
717 "Andreas Oberritter, Andrew de Quincey, Kenneth Aafløy");
718 MODULE_LICENSE("GPL");
720 EXPORT_SYMBOL(stv0299_writereg
);
721 EXPORT_SYMBOL(stv0299_attach
);