2 Driver for Philips tda10086 DVBS Demodulator
4 (c) 2006 Andrew de Quincey
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.
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
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/device.h>
26 #include <linux/jiffies.h>
27 #include <linux/string.h>
28 #include <linux/slab.h>
30 #include "dvb_frontend.h"
33 #define SACLK 96000000
35 struct tda10086_state
{
36 struct i2c_adapter
* i2c
;
37 const struct tda10086_config
* config
;
38 struct dvb_frontend frontend
;
40 /* private demod data */
47 #define dprintk(args...) \
49 if (debug) printk(KERN_DEBUG "tda10086: " args); \
52 static int tda10086_write_byte(struct tda10086_state
*state
, int reg
, int data
)
55 u8 b0
[] = { reg
, data
};
56 struct i2c_msg msg
= { .flags
= 0, .buf
= b0
, .len
= 2 };
58 msg
.addr
= state
->config
->demod_address
;
59 ret
= i2c_transfer(state
->i2c
, &msg
, 1);
62 dprintk("%s: error reg=0x%x, data=0x%x, ret=%i\n",
63 __FUNCTION__
, reg
, data
, ret
);
65 return (ret
!= 1) ? ret
: 0;
68 static int tda10086_read_byte(struct tda10086_state
*state
, int reg
)
73 struct i2c_msg msg
[] = {{ .flags
= 0, .buf
= b0
, .len
= 1 },
74 { .flags
= I2C_M_RD
, .buf
= b1
, .len
= 1 }};
76 msg
[0].addr
= state
->config
->demod_address
;
77 msg
[1].addr
= state
->config
->demod_address
;
78 ret
= i2c_transfer(state
->i2c
, msg
, 2);
81 dprintk("%s: error reg=0x%x, ret=%i\n", __FUNCTION__
, reg
,
89 static int tda10086_write_mask(struct tda10086_state
*state
, int reg
, int mask
, int data
)
93 // read a byte and check
94 val
= tda10086_read_byte(state
, reg
);
102 // write it out again
103 return tda10086_write_byte(state
, reg
, val
);
106 static int tda10086_init(struct dvb_frontend
* fe
)
108 struct tda10086_state
* state
= fe
->demodulator_priv
;
111 dprintk ("%s\n", __FUNCTION__
);
113 if (state
->config
->diseqc_tone
)
116 tda10086_write_byte(state
, 0x00, 0x00);
120 tda10086_write_byte(state
, 0x01, 0x94);
121 tda10086_write_byte(state
, 0x02, 0x35); // NOTE: TT drivers appear to disable CSWP
122 tda10086_write_byte(state
, 0x03, 0xe4);
123 tda10086_write_byte(state
, 0x04, 0x43);
124 tda10086_write_byte(state
, 0x0c, 0x0c);
125 tda10086_write_byte(state
, 0x1b, 0xb0); // noise threshold
126 tda10086_write_byte(state
, 0x20, 0x89); // misc
127 tda10086_write_byte(state
, 0x30, 0x04); // acquisition period length
128 tda10086_write_byte(state
, 0x32, 0x00); // irq off
129 tda10086_write_byte(state
, 0x31, 0x56); // setup AFC
131 // setup PLL (assumes 16Mhz XIN)
132 tda10086_write_byte(state
, 0x55, 0x2c); // misc PLL setup
133 tda10086_write_byte(state
, 0x3a, 0x0b); // M=12
134 tda10086_write_byte(state
, 0x3b, 0x01); // P=2
135 tda10086_write_mask(state
, 0x55, 0x20, 0x00); // powerup PLL
137 // setup TS interface
138 tda10086_write_byte(state
, 0x11, 0x81);
139 tda10086_write_byte(state
, 0x12, 0x81);
140 tda10086_write_byte(state
, 0x19, 0x40); // parallel mode A + MSBFIRST
141 tda10086_write_byte(state
, 0x56, 0x80); // powerdown WPLL - unused in the mode we use
142 tda10086_write_byte(state
, 0x57, 0x08); // bypass WPLL - unused in the mode we use
143 tda10086_write_byte(state
, 0x10, 0x2a);
146 tda10086_write_byte(state
, 0x58, 0x61); // ADC setup
147 tda10086_write_mask(state
, 0x58, 0x01, 0x00); // powerup ADC
150 tda10086_write_byte(state
, 0x05, 0x0B);
151 tda10086_write_byte(state
, 0x37, 0x63);
152 tda10086_write_byte(state
, 0x3f, 0x0a); // NOTE: flydvb varies it
153 tda10086_write_byte(state
, 0x40, 0x64);
154 tda10086_write_byte(state
, 0x41, 0x4f);
155 tda10086_write_byte(state
, 0x42, 0x43);
158 tda10086_write_byte(state
, 0x1a, 0x11); // VBER 10^6, DVB, QPSK
160 // setup carrier recovery
161 tda10086_write_byte(state
, 0x3d, 0x80);
164 tda10086_write_byte(state
, 0x36, t22k_off
); // all SEC off, 22k tone
165 tda10086_write_byte(state
, 0x34, (((1<<19) * (22000/1000)) / (SACLK
/1000))); // } tone frequency
166 tda10086_write_byte(state
, 0x35, (((1<<19) * (22000/1000)) / (SACLK
/1000)) >> 8); // }
171 static void tda10086_diseqc_wait(struct tda10086_state
*state
)
173 unsigned long timeout
= jiffies
+ msecs_to_jiffies(200);
174 while (!(tda10086_read_byte(state
, 0x50) & 0x01)) {
175 if(time_after(jiffies
, timeout
)) {
176 printk("%s: diseqc queue not ready, command may be lost.\n", __FUNCTION__
);
183 static int tda10086_set_tone (struct dvb_frontend
* fe
, fe_sec_tone_mode_t tone
)
185 struct tda10086_state
* state
= fe
->demodulator_priv
;
188 dprintk ("%s\n", __FUNCTION__
);
190 if (state
->config
->diseqc_tone
)
195 tda10086_write_byte(state
, 0x36, t22k_off
);
199 tda10086_write_byte(state
, 0x36, 0x01 + t22k_off
);
206 static int tda10086_send_master_cmd (struct dvb_frontend
* fe
,
207 struct dvb_diseqc_master_cmd
* cmd
)
209 struct tda10086_state
* state
= fe
->demodulator_priv
;
214 dprintk ("%s\n", __FUNCTION__
);
216 if (state
->config
->diseqc_tone
)
219 if (cmd
->msg_len
> 6)
221 oldval
= tda10086_read_byte(state
, 0x36);
223 for(i
=0; i
< cmd
->msg_len
; i
++) {
224 tda10086_write_byte(state
, 0x48+i
, cmd
->msg
[i
]);
226 tda10086_write_byte(state
, 0x36, (0x08 + t22k_off
)
227 | ((cmd
->msg_len
- 1) << 4));
229 tda10086_diseqc_wait(state
);
231 tda10086_write_byte(state
, 0x36, oldval
);
236 static int tda10086_send_burst (struct dvb_frontend
* fe
, fe_sec_mini_cmd_t minicmd
)
238 struct tda10086_state
* state
= fe
->demodulator_priv
;
239 u8 oldval
= tda10086_read_byte(state
, 0x36);
242 dprintk ("%s\n", __FUNCTION__
);
244 if (state
->config
->diseqc_tone
)
249 tda10086_write_byte(state
, 0x36, 0x04 + t22k_off
);
253 tda10086_write_byte(state
, 0x36, 0x06 + t22k_off
);
257 tda10086_diseqc_wait(state
);
259 tda10086_write_byte(state
, 0x36, oldval
);
264 static int tda10086_set_inversion(struct tda10086_state
*state
,
265 struct dvb_frontend_parameters
*fe_params
)
269 dprintk ("%s %i %i\n", __FUNCTION__
, fe_params
->inversion
, state
->config
->invert
);
271 switch(fe_params
->inversion
) {
273 if (state
->config
->invert
)
277 if (!state
->config
->invert
)
284 tda10086_write_mask(state
, 0x0c, 0xc0, invval
);
289 static int tda10086_set_symbol_rate(struct tda10086_state
*state
,
290 struct dvb_frontend_parameters
*fe_params
)
301 u32 symbol_rate
= fe_params
->u
.qpsk
.symbol_rate
;
303 dprintk ("%s %i\n", __FUNCTION__
, symbol_rate
);
305 // setup the decimation and anti-aliasing filters..
306 if (symbol_rate
< (u32
) (SACLK
* 0.0137)) {
309 } else if (symbol_rate
< (u32
) (SACLK
* 0.0208)) {
312 } else if (symbol_rate
< (u32
) (SACLK
* 0.0270)) {
315 } else if (symbol_rate
< (u32
) (SACLK
* 0.0416)) {
318 } else if (symbol_rate
< (u32
) (SACLK
* 0.0550)) {
321 } else if (symbol_rate
< (u32
) (SACLK
* 0.0833)) {
324 } else if (symbol_rate
< (u32
) (SACLK
* 0.1100)) {
327 } else if (symbol_rate
< (u32
) (SACLK
* 0.1666)) {
330 } else if (symbol_rate
< (u32
) (SACLK
* 0.2200)) {
333 } else if (symbol_rate
< (u32
) (SACLK
* 0.3333)) {
343 big
= (1ULL<<21) * ((u64
) symbol_rate
/1000ULL) * (1ULL<<dfn
);
344 big
+= ((SACLK
/1000ULL)-1ULL);
345 do_div(big
, (SACLK
/1000ULL));
349 tmp
= (1<<dfn
)*(symbol_rate
/1000);
350 bdri
= ((32 * (SACLK
/1000)) + (tmp
-1)) / tmp
;
352 tda10086_write_byte(state
, 0x21, (afs
<< 7) | dfn
);
353 tda10086_write_mask(state
, 0x20, 0x08, byp
<< 3);
354 tda10086_write_byte(state
, 0x06, bdr
);
355 tda10086_write_byte(state
, 0x07, bdr
>> 8);
356 tda10086_write_byte(state
, 0x08, bdr
>> 16);
357 tda10086_write_byte(state
, 0x09, bdri
);
358 tda10086_write_byte(state
, 0x37, reg37
);
359 tda10086_write_byte(state
, 0x42, reg42
);
364 static int tda10086_set_fec(struct tda10086_state
*state
,
365 struct dvb_frontend_parameters
*fe_params
)
369 dprintk ("%s %i\n", __FUNCTION__
, fe_params
->u
.qpsk
.fec_inner
);
371 switch(fe_params
->u
.qpsk
.fec_inner
) {
402 tda10086_write_byte(state
, 0x0d, fecval
);
407 static int tda10086_set_frontend(struct dvb_frontend
* fe
,
408 struct dvb_frontend_parameters
*fe_params
)
410 struct tda10086_state
*state
= fe
->demodulator_priv
;
415 dprintk ("%s\n", __FUNCTION__
);
417 // modify parameters for tuning
418 tda10086_write_byte(state
, 0x02, 0x35);
419 state
->has_lock
= false;
422 if (fe
->ops
.tuner_ops
.set_params
) {
423 fe
->ops
.tuner_ops
.set_params(fe
, fe_params
);
424 if (fe
->ops
.i2c_gate_ctrl
)
425 fe
->ops
.i2c_gate_ctrl(fe
, 0);
427 if (fe
->ops
.tuner_ops
.get_frequency
)
428 fe
->ops
.tuner_ops
.get_frequency(fe
, &freq
);
429 if (fe
->ops
.i2c_gate_ctrl
)
430 fe
->ops
.i2c_gate_ctrl(fe
, 0);
433 // calcluate the frequency offset (in *Hz* not kHz)
434 freqoff
= fe_params
->frequency
- freq
;
435 freqoff
= ((1<<16) * freqoff
) / (SACLK
/1000);
436 tda10086_write_byte(state
, 0x3d, 0x80 | ((freqoff
>> 8) & 0x7f));
437 tda10086_write_byte(state
, 0x3e, freqoff
);
439 if ((ret
= tda10086_set_inversion(state
, fe_params
)) < 0)
441 if ((ret
= tda10086_set_symbol_rate(state
, fe_params
)) < 0)
443 if ((ret
= tda10086_set_fec(state
, fe_params
)) < 0)
446 // soft reset + disable TS output until lock
447 tda10086_write_mask(state
, 0x10, 0x40, 0x40);
448 tda10086_write_mask(state
, 0x00, 0x01, 0x00);
450 state
->symbol_rate
= fe_params
->u
.qpsk
.symbol_rate
;
451 state
->frequency
= fe_params
->frequency
;
455 static int tda10086_get_frontend(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
*fe_params
)
457 struct tda10086_state
* state
= fe
->demodulator_priv
;
462 dprintk ("%s\n", __FUNCTION__
);
464 // check for invalid symbol rate
465 if (fe_params
->u
.qpsk
.symbol_rate
< 500000)
468 // calculate the updated frequency (note: we convert from Hz->kHz)
469 tmp64
= tda10086_read_byte(state
, 0x52);
470 tmp64
|= (tda10086_read_byte(state
, 0x51) << 8);
472 tmp64
|= 0xffffffffffff0000ULL
;
473 tmp64
= (tmp64
* (SACLK
/1000ULL));
474 do_div(tmp64
, (1ULL<<15) * (1ULL<<1));
475 fe_params
->frequency
= (int) state
->frequency
+ (int) tmp64
;
478 val
= tda10086_read_byte(state
, 0x0c);
482 fe_params
->inversion
= INVERSION_OFF
;
483 if (state
->config
->invert
)
484 fe_params
->inversion
= INVERSION_ON
;
487 fe_params
->inversion
= INVERSION_ON
;
488 if (state
->config
->invert
)
489 fe_params
->inversion
= INVERSION_OFF
;
493 tda10086_read_byte(state
, 0x0f);
496 fe_params
->inversion
= INVERSION_OFF
;
497 if (state
->config
->invert
)
498 fe_params
->inversion
= INVERSION_ON
;
501 fe_params
->inversion
= INVERSION_ON
;
502 if (state
->config
->invert
)
503 fe_params
->inversion
= INVERSION_OFF
;
508 // calculate the updated symbol rate
509 tmp
= tda10086_read_byte(state
, 0x1d);
512 tmp
= (tmp
* 480 * (1<<1)) / 128;
513 tmp
= ((state
->symbol_rate
/1000) * tmp
) / (1000000/1000);
514 fe_params
->u
.qpsk
.symbol_rate
= state
->symbol_rate
+ tmp
;
517 val
= (tda10086_read_byte(state
, 0x0d) & 0x70) >> 4;
520 fe_params
->u
.qpsk
.fec_inner
= FEC_1_2
;
523 fe_params
->u
.qpsk
.fec_inner
= FEC_2_3
;
526 fe_params
->u
.qpsk
.fec_inner
= FEC_3_4
;
529 fe_params
->u
.qpsk
.fec_inner
= FEC_4_5
;
532 fe_params
->u
.qpsk
.fec_inner
= FEC_5_6
;
535 fe_params
->u
.qpsk
.fec_inner
= FEC_6_7
;
538 fe_params
->u
.qpsk
.fec_inner
= FEC_7_8
;
541 fe_params
->u
.qpsk
.fec_inner
= FEC_8_9
;
548 static int tda10086_read_status(struct dvb_frontend
* fe
, fe_status_t
*fe_status
)
550 struct tda10086_state
* state
= fe
->demodulator_priv
;
553 dprintk ("%s\n", __FUNCTION__
);
555 val
= tda10086_read_byte(state
, 0x0e);
558 *fe_status
|= FE_HAS_SIGNAL
;
560 *fe_status
|= FE_HAS_CARRIER
;
562 *fe_status
|= FE_HAS_VITERBI
;
564 *fe_status
|= FE_HAS_SYNC
;
566 *fe_status
|= FE_HAS_LOCK
;
567 if (!state
->has_lock
) {
568 state
->has_lock
= true;
569 // modify parameters for stable reception
570 tda10086_write_byte(state
, 0x02, 0x00);
577 static int tda10086_read_signal_strength(struct dvb_frontend
* fe
, u16
* signal
)
579 struct tda10086_state
* state
= fe
->demodulator_priv
;
582 dprintk ("%s\n", __FUNCTION__
);
584 _str
= 0xff - tda10086_read_byte(state
, 0x43);
585 *signal
= (_str
<< 8) | _str
;
590 static int tda10086_read_snr(struct dvb_frontend
* fe
, u16
* snr
)
592 struct tda10086_state
* state
= fe
->demodulator_priv
;
595 dprintk ("%s\n", __FUNCTION__
);
597 _snr
= 0xff - tda10086_read_byte(state
, 0x1c);
598 *snr
= (_snr
<< 8) | _snr
;
603 static int tda10086_read_ucblocks(struct dvb_frontend
* fe
, u32
* ucblocks
)
605 struct tda10086_state
* state
= fe
->demodulator_priv
;
607 dprintk ("%s\n", __FUNCTION__
);
610 *ucblocks
= tda10086_read_byte(state
, 0x18) & 0x7f;
613 tda10086_write_byte(state
, 0x18, 0x00);
614 tda10086_write_byte(state
, 0x18, 0x80);
619 static int tda10086_read_ber(struct dvb_frontend
* fe
, u32
* ber
)
621 struct tda10086_state
* state
= fe
->demodulator_priv
;
623 dprintk ("%s\n", __FUNCTION__
);
627 *ber
|= tda10086_read_byte(state
, 0x15);
628 *ber
|= tda10086_read_byte(state
, 0x16) << 8;
629 *ber
|= (tda10086_read_byte(state
, 0x17) & 0xf) << 16;
634 static int tda10086_sleep(struct dvb_frontend
* fe
)
636 struct tda10086_state
* state
= fe
->demodulator_priv
;
638 dprintk ("%s\n", __FUNCTION__
);
640 tda10086_write_mask(state
, 0x00, 0x08, 0x08);
645 static int tda10086_i2c_gate_ctrl(struct dvb_frontend
* fe
, int enable
)
647 struct tda10086_state
* state
= fe
->demodulator_priv
;
649 dprintk ("%s\n", __FUNCTION__
);
652 tda10086_write_mask(state
, 0x00, 0x10, 0x10);
654 tda10086_write_mask(state
, 0x00, 0x10, 0x00);
660 static int tda10086_get_tune_settings(struct dvb_frontend
* fe
, struct dvb_frontend_tune_settings
* fesettings
)
662 if (fesettings
->parameters
.u
.qpsk
.symbol_rate
> 20000000) {
663 fesettings
->min_delay_ms
= 50;
664 fesettings
->step_size
= 2000;
665 fesettings
->max_drift
= 8000;
666 } else if (fesettings
->parameters
.u
.qpsk
.symbol_rate
> 12000000) {
667 fesettings
->min_delay_ms
= 100;
668 fesettings
->step_size
= 1500;
669 fesettings
->max_drift
= 9000;
670 } else if (fesettings
->parameters
.u
.qpsk
.symbol_rate
> 8000000) {
671 fesettings
->min_delay_ms
= 100;
672 fesettings
->step_size
= 1000;
673 fesettings
->max_drift
= 8000;
674 } else if (fesettings
->parameters
.u
.qpsk
.symbol_rate
> 4000000) {
675 fesettings
->min_delay_ms
= 100;
676 fesettings
->step_size
= 500;
677 fesettings
->max_drift
= 7000;
678 } else if (fesettings
->parameters
.u
.qpsk
.symbol_rate
> 2000000) {
679 fesettings
->min_delay_ms
= 200;
680 fesettings
->step_size
= (fesettings
->parameters
.u
.qpsk
.symbol_rate
/ 8000);
681 fesettings
->max_drift
= 14 * fesettings
->step_size
;
683 fesettings
->min_delay_ms
= 200;
684 fesettings
->step_size
= (fesettings
->parameters
.u
.qpsk
.symbol_rate
/ 8000);
685 fesettings
->max_drift
= 18 * fesettings
->step_size
;
691 static void tda10086_release(struct dvb_frontend
* fe
)
693 struct tda10086_state
*state
= fe
->demodulator_priv
;
698 static struct dvb_frontend_ops tda10086_ops
= {
701 .name
= "Philips TDA10086 DVB-S",
703 .frequency_min
= 950000,
704 .frequency_max
= 2150000,
705 .frequency_stepsize
= 125, /* kHz for QPSK frontends */
706 .symbol_rate_min
= 1000000,
707 .symbol_rate_max
= 45000000,
708 .caps
= FE_CAN_INVERSION_AUTO
|
709 FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
| FE_CAN_FEC_3_4
|
710 FE_CAN_FEC_5_6
| FE_CAN_FEC_6_7
| FE_CAN_FEC_7_8
| FE_CAN_FEC_AUTO
|
714 .release
= tda10086_release
,
716 .init
= tda10086_init
,
717 .sleep
= tda10086_sleep
,
718 .i2c_gate_ctrl
= tda10086_i2c_gate_ctrl
,
720 .set_frontend
= tda10086_set_frontend
,
721 .get_frontend
= tda10086_get_frontend
,
722 .get_tune_settings
= tda10086_get_tune_settings
,
724 .read_status
= tda10086_read_status
,
725 .read_ber
= tda10086_read_ber
,
726 .read_signal_strength
= tda10086_read_signal_strength
,
727 .read_snr
= tda10086_read_snr
,
728 .read_ucblocks
= tda10086_read_ucblocks
,
730 .diseqc_send_master_cmd
= tda10086_send_master_cmd
,
731 .diseqc_send_burst
= tda10086_send_burst
,
732 .set_tone
= tda10086_set_tone
,
735 struct dvb_frontend
* tda10086_attach(const struct tda10086_config
* config
,
736 struct i2c_adapter
* i2c
)
738 struct tda10086_state
*state
;
740 dprintk ("%s\n", __FUNCTION__
);
742 /* allocate memory for the internal state */
743 state
= kmalloc(sizeof(struct tda10086_state
), GFP_KERNEL
);
747 /* setup the state */
748 state
->config
= config
;
751 /* check if the demod is there */
752 if (tda10086_read_byte(state
, 0x1e) != 0xe1) {
757 /* create dvb_frontend */
758 memcpy(&state
->frontend
.ops
, &tda10086_ops
, sizeof(struct dvb_frontend_ops
));
759 state
->frontend
.demodulator_priv
= state
;
760 return &state
->frontend
;
763 module_param(debug
, int, 0644);
764 MODULE_PARM_DESC(debug
, "Turn on/off frontend debugging (default:off).");
766 MODULE_DESCRIPTION("Philips TDA10086 DVB-S Demodulator");
767 MODULE_AUTHOR("Andrew de Quincey");
768 MODULE_LICENSE("GPL");
770 EXPORT_SYMBOL(tda10086_attach
);