2 * Support for Legend Silicon GB20600 (a.k.a DMB-TH) demodulator
3 * LGS8913, LGS8GL5, LGS8G75
4 * experimental support LGS8G42, LGS8G52
6 * Copyright (C) 2007-2009 David T.L. Wong <davidtlwong@gmail.com>
7 * Copyright (C) 2008 Sirius International (Hong Kong) Limited
8 * Timothy Lee <timothy.lee@siriushk.com> (for initial work on LGS8GL5)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <asm/div64.h>
27 #include <linux/firmware.h>
29 #include "dvb_frontend.h"
32 #include "lgs8gxx_priv.h"
34 #define dprintk(args...) \
37 printk(KERN_DEBUG "lgs8gxx: " args); \
41 static int fake_signal_str
= 1;
43 module_param(debug
, int, 0644);
44 MODULE_PARM_DESC(debug
, "Turn on/off frontend debugging (default:off).");
46 module_param(fake_signal_str
, int, 0644);
47 MODULE_PARM_DESC(fake_signal_str
, "fake signal strength for LGS8913."
48 "Signal strength calculation is slow.(default:on).");
50 /* LGS8GXX internal helper functions */
52 static int lgs8gxx_write_reg(struct lgs8gxx_state
*priv
, u8 reg
, u8 data
)
55 u8 buf
[] = { reg
, data
};
56 struct i2c_msg msg
= { .flags
= 0, .buf
= buf
, .len
= 2 };
58 msg
.addr
= priv
->config
->demod_address
;
59 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
&& reg
>= 0xC0)
63 dprintk("%s: reg=0x%02X, data=0x%02X\n", __func__
, reg
, data
);
65 ret
= i2c_transfer(priv
->i2c
, &msg
, 1);
68 dprintk("%s: error reg=0x%x, data=0x%x, ret=%i\n",
69 __func__
, reg
, data
, ret
);
71 return (ret
!= 1) ? -1 : 0;
74 static int lgs8gxx_read_reg(struct lgs8gxx_state
*priv
, u8 reg
, u8
*p_data
)
81 struct i2c_msg msg
[] = {
82 { .flags
= 0, .buf
= b0
, .len
= 1 },
83 { .flags
= I2C_M_RD
, .buf
= b1
, .len
= 1 },
86 dev_addr
= priv
->config
->demod_address
;
87 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
&& reg
>= 0xC0)
89 msg
[1].addr
= msg
[0].addr
= dev_addr
;
91 ret
= i2c_transfer(priv
->i2c
, msg
, 2);
93 dprintk("%s: error reg=0x%x, ret=%i\n", __func__
, reg
, ret
);
99 dprintk("%s: reg=0x%02X, data=0x%02X\n", __func__
, reg
, b1
[0]);
103 static int lgs8gxx_soft_reset(struct lgs8gxx_state
*priv
)
105 lgs8gxx_write_reg(priv
, 0x02, 0x00);
107 lgs8gxx_write_reg(priv
, 0x02, 0x01);
113 static int wait_reg_mask(struct lgs8gxx_state
*priv
, u8 reg
, u8 mask
,
114 u8 val
, u8 delay
, u8 tries
)
119 for (i
= 0; i
< tries
; i
++) {
120 lgs8gxx_read_reg(priv
, reg
, &t
);
122 if ((t
& mask
) == val
)
130 static int lgs8gxx_set_ad_mode(struct lgs8gxx_state
*priv
)
132 const struct lgs8gxx_config
*config
= priv
->config
;
135 if_conf
= 0x10; /* AGC output on, RF_AGC output off; */
138 ((config
->ext_adc
) ? 0x80 : 0x00) |
139 ((config
->if_neg_center
) ? 0x04 : 0x00) |
140 ((config
->if_freq
== 0) ? 0x08 : 0x00) | /* Baseband */
141 ((config
->adc_signed
) ? 0x02 : 0x00) |
142 ((config
->if_neg_edge
) ? 0x01 : 0x00);
144 if (config
->ext_adc
&&
145 (config
->prod
== LGS8GXX_PROD_LGS8G52
)) {
146 lgs8gxx_write_reg(priv
, 0xBA, 0x40);
149 lgs8gxx_write_reg(priv
, 0x07, if_conf
);
154 static int lgs8gxx_set_if_freq(struct lgs8gxx_state
*priv
, u32 freq
/*in kHz*/)
160 if_clk
= priv
->config
->if_clk_freq
;
167 v32
= val
& 0xFFFFFFFF;
168 dprintk("Set IF Freq to %dkHz\n", freq
);
171 dprintk("Set IF Freq to baseband\n");
173 dprintk("AFC_INIT_FREQ = 0x%08X\n", v32
);
175 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
176 lgs8gxx_write_reg(priv
, 0x08, 0xFF & (v32
));
177 lgs8gxx_write_reg(priv
, 0x09, 0xFF & (v32
>> 8));
178 lgs8gxx_write_reg(priv
, 0x0A, 0xFF & (v32
>> 16));
179 lgs8gxx_write_reg(priv
, 0x0B, 0xFF & (v32
>> 24));
181 lgs8gxx_write_reg(priv
, 0x09, 0xFF & (v32
));
182 lgs8gxx_write_reg(priv
, 0x0A, 0xFF & (v32
>> 8));
183 lgs8gxx_write_reg(priv
, 0x0B, 0xFF & (v32
>> 16));
184 lgs8gxx_write_reg(priv
, 0x0C, 0xFF & (v32
>> 24));
190 static int lgs8gxx_get_afc_phase(struct lgs8gxx_state
*priv
)
197 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
202 for (i
= 0; i
< 4; i
++) {
203 lgs8gxx_read_reg(priv
, reg_addr
, &t
);
210 val
*= priv
->config
->if_clk_freq
;
212 dprintk("AFC = %u kHz\n", (u32
)val
);
216 static int lgs8gxx_set_mode_auto(struct lgs8gxx_state
*priv
)
219 u8 prod
= priv
->config
->prod
;
221 if (prod
== LGS8GXX_PROD_LGS8913
)
222 lgs8gxx_write_reg(priv
, 0xC6, 0x01);
224 if (prod
== LGS8GXX_PROD_LGS8G75
) {
225 lgs8gxx_read_reg(priv
, 0x0C, &t
);
227 lgs8gxx_write_reg(priv
, 0x0C, t
| 0x80);
228 lgs8gxx_write_reg(priv
, 0x39, 0x00);
229 lgs8gxx_write_reg(priv
, 0x3D, 0x04);
230 } else if (prod
== LGS8GXX_PROD_LGS8913
||
231 prod
== LGS8GXX_PROD_LGS8GL5
||
232 prod
== LGS8GXX_PROD_LGS8G42
||
233 prod
== LGS8GXX_PROD_LGS8G52
||
234 prod
== LGS8GXX_PROD_LGS8G54
) {
235 lgs8gxx_read_reg(priv
, 0x7E, &t
);
236 lgs8gxx_write_reg(priv
, 0x7E, t
| 0x01);
238 /* clear FEC self reset */
239 lgs8gxx_read_reg(priv
, 0xC5, &t
);
240 lgs8gxx_write_reg(priv
, 0xC5, t
& 0xE0);
243 if (prod
== LGS8GXX_PROD_LGS8913
) {
244 /* FEC auto detect */
245 lgs8gxx_write_reg(priv
, 0xC1, 0x03);
247 lgs8gxx_read_reg(priv
, 0x7C, &t
);
248 t
= (t
& 0x8C) | 0x03;
249 lgs8gxx_write_reg(priv
, 0x7C, t
);
252 lgs8gxx_read_reg(priv
, 0xC3, &t
);
253 t
= (t
& 0xEF) | 0x10;
254 lgs8gxx_write_reg(priv
, 0xC3, t
);
257 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G52
)
258 lgs8gxx_write_reg(priv
, 0xD9, 0x40);
263 static int lgs8gxx_set_mode_manual(struct lgs8gxx_state
*priv
)
267 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
269 lgs8gxx_read_reg(priv
, 0x0C, &t
);
271 lgs8gxx_write_reg(priv
, 0x0C, t
);
273 lgs8gxx_read_reg(priv
, 0x0C, &t
);
274 lgs8gxx_read_reg(priv
, 0x19, &t2
);
276 if (((t
&0x03) == 0x01) && (t2
&0x01)) {
277 lgs8gxx_write_reg(priv
, 0x6E, 0x05);
278 lgs8gxx_write_reg(priv
, 0x39, 0x02);
279 lgs8gxx_write_reg(priv
, 0x39, 0x03);
280 lgs8gxx_write_reg(priv
, 0x3D, 0x05);
281 lgs8gxx_write_reg(priv
, 0x3E, 0x28);
282 lgs8gxx_write_reg(priv
, 0x53, 0x80);
284 lgs8gxx_write_reg(priv
, 0x6E, 0x3F);
285 lgs8gxx_write_reg(priv
, 0x39, 0x00);
286 lgs8gxx_write_reg(priv
, 0x3D, 0x04);
289 lgs8gxx_soft_reset(priv
);
293 /* turn off auto-detect; manual settings */
294 lgs8gxx_write_reg(priv
, 0x7E, 0);
295 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
)
296 lgs8gxx_write_reg(priv
, 0xC1, 0);
298 lgs8gxx_read_reg(priv
, 0xC5, &t
);
299 t
= (t
& 0xE0) | 0x06;
300 lgs8gxx_write_reg(priv
, 0xC5, t
);
302 lgs8gxx_soft_reset(priv
);
307 static int lgs8gxx_is_locked(struct lgs8gxx_state
*priv
, u8
*locked
)
312 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
313 ret
= lgs8gxx_read_reg(priv
, 0x13, &t
);
315 ret
= lgs8gxx_read_reg(priv
, 0x4B, &t
);
319 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
320 *locked
= ((t
& 0x80) == 0x80) ? 1 : 0;
322 *locked
= ((t
& 0xC0) == 0xC0) ? 1 : 0;
326 /* Wait for Code Acquisition Lock */
327 static int lgs8gxx_wait_ca_lock(struct lgs8gxx_state
*priv
, u8
*locked
)
332 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
342 ret
= wait_reg_mask(priv
, reg
, mask
, val
, 50, 40);
343 *locked
= (ret
== 0) ? 1 : 0;
348 static int lgs8gxx_is_autodetect_finished(struct lgs8gxx_state
*priv
,
354 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
364 ret
= wait_reg_mask(priv
, reg
, mask
, val
, 10, 20);
365 *finished
= (ret
== 0) ? 1 : 0;
370 static int lgs8gxx_autolock_gi(struct lgs8gxx_state
*priv
, u8 gi
, u8 cpn
,
378 dprintk("try GI 945\n");
379 else if (gi
== GI_595
)
380 dprintk("try GI 595\n");
381 else if (gi
== GI_420
)
382 dprintk("try GI 420\n");
383 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
384 lgs8gxx_read_reg(priv
, 0x0C, &t1
);
385 lgs8gxx_read_reg(priv
, 0x18, &t2
);
389 t2
|= cpn
? 0x01 : 0x00;
390 lgs8gxx_write_reg(priv
, 0x0C, t1
);
391 lgs8gxx_write_reg(priv
, 0x18, t2
);
393 lgs8gxx_write_reg(priv
, 0x04, gi
);
395 lgs8gxx_soft_reset(priv
);
396 err
= lgs8gxx_wait_ca_lock(priv
, locked
);
397 if (err
|| !(*locked
))
399 err
= lgs8gxx_is_autodetect_finished(priv
, &ad_fini
);
403 dprintk("auto detect finished\n");
410 static int lgs8gxx_auto_detect(struct lgs8gxx_state
*priv
,
411 u8
*detected_param
, u8
*gi
)
415 u8 locked
= 0, tmp_gi
;
417 dprintk("%s\n", __func__
);
419 lgs8gxx_set_mode_auto(priv
);
420 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
421 lgs8gxx_write_reg(priv
, 0x67, 0xAA);
422 lgs8gxx_write_reg(priv
, 0x6E, 0x3F);
425 lgs8gxx_write_reg(priv
, 0x03, 00);
428 for (i
= 0; i
< 2; i
++) {
429 for (j
= 0; j
< 2; j
++) {
431 err
= lgs8gxx_autolock_gi(priv
, GI_945
, j
, &locked
);
437 for (j
= 0; j
< 2; j
++) {
439 err
= lgs8gxx_autolock_gi(priv
, GI_420
, j
, &locked
);
446 err
= lgs8gxx_autolock_gi(priv
, GI_595
, 1, &locked
);
454 if ((err
== 0) && (locked
== 1)) {
457 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
) {
458 lgs8gxx_read_reg(priv
, 0xA2, &t
);
461 lgs8gxx_read_reg(priv
, 0x1F, &t
);
462 *detected_param
= t
& 0x3F;
465 if (tmp_gi
== GI_945
)
466 dprintk("GI 945 locked\n");
467 else if (tmp_gi
== GI_595
)
468 dprintk("GI 595 locked\n");
469 else if (tmp_gi
== GI_420
)
470 dprintk("GI 420 locked\n");
480 static void lgs8gxx_auto_lock(struct lgs8gxx_state
*priv
)
484 u8 detected_param
= 0;
486 err
= lgs8gxx_auto_detect(priv
, &detected_param
, &gi
);
489 dprintk("lgs8gxx_auto_detect failed\n");
491 dprintk("detected param = 0x%02X\n", detected_param
);
493 /* Apply detected parameters */
494 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
) {
495 u8 inter_leave_len
= detected_param
& TIM_MASK
;
496 /* Fix 8913 time interleaver detection bug */
497 inter_leave_len
= (inter_leave_len
== TIM_MIDDLE
) ? 0x60 : 0x40;
498 detected_param
&= CF_MASK
| SC_MASK
| LGS_FEC_MASK
;
499 detected_param
|= inter_leave_len
;
501 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
503 lgs8gxx_read_reg(priv
, 0x19, &t
);
505 t
|= detected_param
<< 1;
506 lgs8gxx_write_reg(priv
, 0x19, t
);
508 lgs8gxx_write_reg(priv
, 0x7D, detected_param
);
509 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
)
510 lgs8gxx_write_reg(priv
, 0xC0, detected_param
);
512 /* lgs8gxx_soft_reset(priv); */
514 /* Enter manual mode */
515 lgs8gxx_set_mode_manual(priv
);
519 priv
->curr_gi
= 945; break;
521 priv
->curr_gi
= 595; break;
523 priv
->curr_gi
= 420; break;
525 priv
->curr_gi
= 945; break;
529 static int lgs8gxx_set_mpeg_mode(struct lgs8gxx_state
*priv
,
530 u8 serial
, u8 clk_pol
, u8 clk_gated
)
535 reg_addr
= (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) ? 0x30 : 0xC2;
536 ret
= lgs8gxx_read_reg(priv
, reg_addr
, &t
);
541 t
|= serial
? TS_SERIAL
: TS_PARALLEL
;
542 t
|= clk_pol
? TS_CLK_INVERTED
: TS_CLK_NORMAL
;
543 t
|= clk_gated
? TS_CLK_GATED
: TS_CLK_FREERUN
;
545 ret
= lgs8gxx_write_reg(priv
, reg_addr
, t
);
552 /* A/D input peak-to-peak voltage range */
553 static int lgs8g75_set_adc_vpp(struct lgs8gxx_state
*priv
,
556 u8 r26
= 0x73, r27
= 0x90;
558 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
)
561 r26
|= (sel
& 0x01) << 7;
562 r27
|= (sel
& 0x02) >> 1;
563 lgs8gxx_write_reg(priv
, 0x26, r26
);
564 lgs8gxx_write_reg(priv
, 0x27, r27
);
569 /* LGS8913 demod frontend functions */
571 static int lgs8913_init(struct lgs8gxx_state
*priv
)
575 /* LGS8913 specific */
576 lgs8gxx_write_reg(priv
, 0xc1, 0x3);
578 lgs8gxx_read_reg(priv
, 0x7c, &t
);
579 lgs8gxx_write_reg(priv
, 0x7c, (t
&0x8c) | 0x3);
581 /* LGS8913 specific */
582 lgs8gxx_read_reg(priv
, 0xc3, &t
);
583 lgs8gxx_write_reg(priv
, 0xc3, t
&0x10);
589 static int lgs8g75_init_data(struct lgs8gxx_state
*priv
)
591 const struct firmware
*fw
;
595 rc
= request_firmware(&fw
, "lgs8g75.fw", &priv
->i2c
->dev
);
599 lgs8gxx_write_reg(priv
, 0xC6, 0x40);
601 lgs8gxx_write_reg(priv
, 0x3D, 0x04);
602 lgs8gxx_write_reg(priv
, 0x39, 0x00);
604 lgs8gxx_write_reg(priv
, 0x3A, 0x00);
605 lgs8gxx_write_reg(priv
, 0x38, 0x00);
606 lgs8gxx_write_reg(priv
, 0x3B, 0x00);
607 lgs8gxx_write_reg(priv
, 0x38, 0x00);
609 for (i
= 0; i
< fw
->size
; i
++) {
610 lgs8gxx_write_reg(priv
, 0x38, 0x00);
611 lgs8gxx_write_reg(priv
, 0x3A, (u8
)(i
&0xff));
612 lgs8gxx_write_reg(priv
, 0x3B, (u8
)(i
>>8));
613 lgs8gxx_write_reg(priv
, 0x3C, fw
->data
[i
]);
616 lgs8gxx_write_reg(priv
, 0x38, 0x00);
618 release_firmware(fw
);
622 static int lgs8gxx_init(struct dvb_frontend
*fe
)
624 struct lgs8gxx_state
*priv
=
625 (struct lgs8gxx_state
*)fe
->demodulator_priv
;
626 const struct lgs8gxx_config
*config
= priv
->config
;
629 dprintk("%s\n", __func__
);
631 lgs8gxx_read_reg(priv
, 0, &data
);
632 dprintk("reg 0 = 0x%02X\n", data
);
634 if (config
->prod
== LGS8GXX_PROD_LGS8G75
)
635 lgs8g75_set_adc_vpp(priv
, config
->adc_vpp
);
637 /* Setup MPEG output format */
638 err
= lgs8gxx_set_mpeg_mode(priv
, config
->serial_ts
,
640 config
->ts_clk_gated
);
644 if (config
->prod
== LGS8GXX_PROD_LGS8913
)
646 lgs8gxx_set_if_freq(priv
, priv
->config
->if_freq
);
647 lgs8gxx_set_ad_mode(priv
);
652 static void lgs8gxx_release(struct dvb_frontend
*fe
)
654 struct lgs8gxx_state
*state
= fe
->demodulator_priv
;
655 dprintk("%s\n", __func__
);
661 static int lgs8gxx_write(struct dvb_frontend
*fe
, const u8 buf
[], int len
)
663 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
668 return lgs8gxx_write_reg(priv
, buf
[0], buf
[1]);
671 static int lgs8gxx_set_fe(struct dvb_frontend
*fe
)
674 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
676 dprintk("%s\n", __func__
);
679 if (fe
->ops
.tuner_ops
.set_params
) {
680 fe
->ops
.tuner_ops
.set_params(fe
);
681 if (fe
->ops
.i2c_gate_ctrl
)
682 fe
->ops
.i2c_gate_ctrl(fe
, 0);
685 /* start auto lock */
686 lgs8gxx_auto_lock(priv
);
693 static int lgs8gxx_get_fe(struct dvb_frontend
*fe
)
695 struct dtv_frontend_properties
*fe_params
= &fe
->dtv_property_cache
;
696 dprintk("%s\n", __func__
);
698 /* TODO: get real readings from device */
699 /* inversion status */
700 fe_params
->inversion
= INVERSION_OFF
;
703 fe_params
->bandwidth_hz
= 8000000;
705 fe_params
->code_rate_HP
= FEC_AUTO
;
706 fe_params
->code_rate_LP
= FEC_AUTO
;
708 fe_params
->modulation
= QAM_AUTO
;
710 /* transmission mode */
711 fe_params
->transmission_mode
= TRANSMISSION_MODE_AUTO
;
714 fe_params
->guard_interval
= GUARD_INTERVAL_AUTO
;
717 fe_params
->hierarchy
= HIERARCHY_NONE
;
723 int lgs8gxx_get_tune_settings(struct dvb_frontend
*fe
,
724 struct dvb_frontend_tune_settings
*fesettings
)
726 /* FIXME: copy from tda1004x.c */
727 fesettings
->min_delay_ms
= 800;
728 fesettings
->step_size
= 0;
729 fesettings
->max_drift
= 0;
733 static int lgs8gxx_read_status(struct dvb_frontend
*fe
, fe_status_t
*fe_status
)
735 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
739 dprintk("%s\n", __func__
);
742 lgs8gxx_get_afc_phase(priv
);
743 lgs8gxx_is_locked(priv
, &locked
);
744 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
746 *fe_status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
747 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
751 ret
= lgs8gxx_read_reg(priv
, 0x4B, &t
);
755 dprintk("Reg 0x4B: 0x%02X\n", t
);
758 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
) {
759 if ((t
& 0x40) == 0x40)
760 *fe_status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
;
761 if ((t
& 0x80) == 0x80)
762 *fe_status
|= FE_HAS_VITERBI
| FE_HAS_SYNC
|
765 if ((t
& 0x80) == 0x80)
766 *fe_status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
767 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
771 dprintk("%s: fe_status=0x%x\n", __func__
, *fe_status
);
775 static int lgs8gxx_read_signal_agc(struct lgs8gxx_state
*priv
, u16
*signal
)
780 dprintk("%s()\n", __func__
);
781 lgs8gxx_read_reg(priv
, 0x3F, &agc_lvl
[0]);
782 lgs8gxx_read_reg(priv
, 0x3E, &agc_lvl
[1]);
788 dprintk("agc_lvl: 0x%04X\n", v
);
805 *signal
= cat
* 65535 / 5;
810 static int lgs8913_read_signal_strength(struct lgs8gxx_state
*priv
, u16
*signal
)
813 s16 max_strength
= 0;
815 u16 i
, gi
= priv
->curr_gi
;
817 dprintk("%s\n", __func__
);
819 ret
= lgs8gxx_read_reg(priv
, 0x4B, &t
);
823 if (fake_signal_str
) {
824 if ((t
& 0xC0) == 0xC0) {
825 dprintk("Fake signal strength\n");
832 dprintk("gi = %d\n", gi
);
833 for (i
= 0; i
< gi
; i
++) {
836 lgs8gxx_write_reg(priv
, 0x84, 0x03 & (i
>> 8));
837 lgs8gxx_write_reg(priv
, 0x83, i
& 0xFF);
839 lgs8gxx_read_reg(priv
, 0x94, &str
);
840 if (max_strength
< str
)
844 *signal
= max_strength
;
845 dprintk("%s: signal=0x%02X\n", __func__
, *signal
);
847 lgs8gxx_read_reg(priv
, 0x95, &t
);
848 dprintk("%s: AVG Noise=0x%02X\n", __func__
, t
);
853 static int lgs8g75_read_signal_strength(struct lgs8gxx_state
*priv
, u16
*signal
)
858 dprintk("%s\n", __func__
);
860 lgs8gxx_read_reg(priv
, 0xB1, &t
);
863 lgs8gxx_read_reg(priv
, 0xB0, &t
);
867 dprintk("%s: signal=0x%02X\n", __func__
, *signal
);
872 static int lgs8gxx_read_signal_strength(struct dvb_frontend
*fe
, u16
*signal
)
874 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
876 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
)
877 return lgs8913_read_signal_strength(priv
, signal
);
878 else if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
879 return lgs8g75_read_signal_strength(priv
, signal
);
881 return lgs8gxx_read_signal_agc(priv
, signal
);
884 static int lgs8gxx_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
886 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
890 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
891 lgs8gxx_read_reg(priv
, 0x34, &t
);
893 lgs8gxx_read_reg(priv
, 0x95, &t
);
894 dprintk("AVG Noise=0x%02X\n", t
);
897 dprintk("snr=0x%x\n", *snr
);
902 static int lgs8gxx_read_ucblocks(struct dvb_frontend
*fe
, u32
*ucblocks
)
905 dprintk("%s: ucblocks=0x%x\n", __func__
, *ucblocks
);
909 static void packet_counter_start(struct lgs8gxx_state
*priv
)
913 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
914 lgs8gxx_read_reg(priv
, 0x30, &orig
);
917 lgs8gxx_write_reg(priv
, 0x30, t
);
919 lgs8gxx_write_reg(priv
, 0x30, t
);
921 lgs8gxx_write_reg(priv
, 0x30, t
);
923 lgs8gxx_write_reg(priv
, 0xC6, 0x01);
924 lgs8gxx_write_reg(priv
, 0xC6, 0x41);
925 lgs8gxx_write_reg(priv
, 0xC6, 0x01);
929 static void packet_counter_stop(struct lgs8gxx_state
*priv
)
933 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
934 lgs8gxx_read_reg(priv
, 0x30, &t
);
936 lgs8gxx_write_reg(priv
, 0x30, t
);
938 lgs8gxx_write_reg(priv
, 0xC6, 0x81);
942 static int lgs8gxx_read_ber(struct dvb_frontend
*fe
, u32
*ber
)
944 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
945 u8 reg_err
, reg_total
, t
;
946 u32 total_cnt
= 0, err_cnt
= 0;
949 dprintk("%s\n", __func__
);
951 packet_counter_start(priv
);
953 packet_counter_stop(priv
);
955 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
956 reg_total
= 0x28; reg_err
= 0x2C;
958 reg_total
= 0xD0; reg_err
= 0xD4;
961 for (i
= 0; i
< 4; i
++) {
963 lgs8gxx_read_reg(priv
, reg_total
+3-i
, &t
);
966 for (i
= 0; i
< 4; i
++) {
968 lgs8gxx_read_reg(priv
, reg_err
+3-i
, &t
);
971 dprintk("error=%d total=%d\n", err_cnt
, total_cnt
);
976 *ber
= err_cnt
* 100 / total_cnt
;
978 dprintk("%s: ber=0x%x\n", __func__
, *ber
);
982 static int lgs8gxx_i2c_gate_ctrl(struct dvb_frontend
*fe
, int enable
)
984 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
986 if (priv
->config
->tuner_address
== 0)
989 u8 v
= 0x80 | priv
->config
->tuner_address
;
990 return lgs8gxx_write_reg(priv
, 0x01, v
);
992 return lgs8gxx_write_reg(priv
, 0x01, 0);
995 static struct dvb_frontend_ops lgs8gxx_ops
= {
996 .delsys
= { SYS_DMBTH
},
998 .name
= "Legend Silicon LGS8913/LGS8GXX DMB-TH",
999 .frequency_min
= 474000000,
1000 .frequency_max
= 858000000,
1001 .frequency_stepsize
= 10000,
1005 FE_CAN_TRANSMISSION_MODE_AUTO
|
1006 FE_CAN_GUARD_INTERVAL_AUTO
1009 .release
= lgs8gxx_release
,
1011 .init
= lgs8gxx_init
,
1012 .write
= lgs8gxx_write
,
1013 .i2c_gate_ctrl
= lgs8gxx_i2c_gate_ctrl
,
1015 .set_frontend
= lgs8gxx_set_fe
,
1016 .get_frontend
= lgs8gxx_get_fe
,
1017 .get_tune_settings
= lgs8gxx_get_tune_settings
,
1019 .read_status
= lgs8gxx_read_status
,
1020 .read_ber
= lgs8gxx_read_ber
,
1021 .read_signal_strength
= lgs8gxx_read_signal_strength
,
1022 .read_snr
= lgs8gxx_read_snr
,
1023 .read_ucblocks
= lgs8gxx_read_ucblocks
,
1026 struct dvb_frontend
*lgs8gxx_attach(const struct lgs8gxx_config
*config
,
1027 struct i2c_adapter
*i2c
)
1029 struct lgs8gxx_state
*priv
= NULL
;
1032 dprintk("%s()\n", __func__
);
1034 if (config
== NULL
|| i2c
== NULL
)
1037 priv
= kzalloc(sizeof(struct lgs8gxx_state
), GFP_KERNEL
);
1041 priv
->config
= config
;
1044 /* check if the demod is there */
1045 if (lgs8gxx_read_reg(priv
, 0, &data
) != 0) {
1046 dprintk("%s lgs8gxx not found at i2c addr 0x%02X\n",
1047 __func__
, priv
->config
->demod_address
);
1051 lgs8gxx_read_reg(priv
, 1, &data
);
1053 memcpy(&priv
->frontend
.ops
, &lgs8gxx_ops
,
1054 sizeof(struct dvb_frontend_ops
));
1055 priv
->frontend
.demodulator_priv
= priv
;
1057 if (config
->prod
== LGS8GXX_PROD_LGS8G75
)
1058 lgs8g75_init_data(priv
);
1060 return &priv
->frontend
;
1063 dprintk("%s() error_out\n", __func__
);
1068 EXPORT_SYMBOL(lgs8gxx_attach
);
1070 MODULE_DESCRIPTION("Legend Silicon LGS8913/LGS8GXX DMB-TH demodulator driver");
1071 MODULE_AUTHOR("David T. L. Wong <davidtlwong@gmail.com>");
1072 MODULE_LICENSE("GPL");