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 printk(KERN_DEBUG
"%s: reg=0x%02X, data=0x%02X\n",
66 ret
= i2c_transfer(priv
->i2c
, &msg
, 1);
69 dprintk(KERN_DEBUG
"%s: error reg=0x%x, data=0x%x, ret=%i\n",
70 __func__
, reg
, data
, ret
);
72 return (ret
!= 1) ? -1 : 0;
75 static int lgs8gxx_read_reg(struct lgs8gxx_state
*priv
, u8 reg
, u8
*p_data
)
82 struct i2c_msg msg
[] = {
83 { .flags
= 0, .buf
= b0
, .len
= 1 },
84 { .flags
= I2C_M_RD
, .buf
= b1
, .len
= 1 },
87 dev_addr
= priv
->config
->demod_address
;
88 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
&& reg
>= 0xC0)
90 msg
[1].addr
= msg
[0].addr
= dev_addr
;
92 ret
= i2c_transfer(priv
->i2c
, msg
, 2);
94 dprintk(KERN_DEBUG
"%s: error reg=0x%x, ret=%i\n",
101 printk(KERN_DEBUG
"%s: reg=0x%02X, data=0x%02X\n",
102 __func__
, reg
, b1
[0]);
106 static int lgs8gxx_soft_reset(struct lgs8gxx_state
*priv
)
108 lgs8gxx_write_reg(priv
, 0x02, 0x00);
110 lgs8gxx_write_reg(priv
, 0x02, 0x01);
116 static int wait_reg_mask(struct lgs8gxx_state
*priv
, u8 reg
, u8 mask
,
117 u8 val
, u8 delay
, u8 tries
)
122 for (i
= 0; i
< tries
; i
++) {
123 lgs8gxx_read_reg(priv
, reg
, &t
);
125 if ((t
& mask
) == val
)
133 static int lgs8gxx_set_ad_mode(struct lgs8gxx_state
*priv
)
135 const struct lgs8gxx_config
*config
= priv
->config
;
138 if_conf
= 0x10; /* AGC output on, RF_AGC output off; */
141 ((config
->ext_adc
) ? 0x80 : 0x00) |
142 ((config
->if_neg_center
) ? 0x04 : 0x00) |
143 ((config
->if_freq
== 0) ? 0x08 : 0x00) | /* Baseband */
144 ((config
->adc_signed
) ? 0x02 : 0x00) |
145 ((config
->if_neg_edge
) ? 0x01 : 0x00);
147 if (config
->ext_adc
&&
148 (config
->prod
== LGS8GXX_PROD_LGS8G52
)) {
149 lgs8gxx_write_reg(priv
, 0xBA, 0x40);
152 lgs8gxx_write_reg(priv
, 0x07, if_conf
);
157 static int lgs8gxx_set_if_freq(struct lgs8gxx_state
*priv
, u32 freq
/*in kHz*/)
163 if_clk
= priv
->config
->if_clk_freq
;
170 v32
= val
& 0xFFFFFFFF;
171 dprintk("Set IF Freq to %dkHz\n", freq
);
174 dprintk("Set IF Freq to baseband\n");
176 dprintk("AFC_INIT_FREQ = 0x%08X\n", v32
);
178 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
179 lgs8gxx_write_reg(priv
, 0x08, 0xFF & (v32
));
180 lgs8gxx_write_reg(priv
, 0x09, 0xFF & (v32
>> 8));
181 lgs8gxx_write_reg(priv
, 0x0A, 0xFF & (v32
>> 16));
182 lgs8gxx_write_reg(priv
, 0x0B, 0xFF & (v32
>> 24));
184 lgs8gxx_write_reg(priv
, 0x09, 0xFF & (v32
));
185 lgs8gxx_write_reg(priv
, 0x0A, 0xFF & (v32
>> 8));
186 lgs8gxx_write_reg(priv
, 0x0B, 0xFF & (v32
>> 16));
187 lgs8gxx_write_reg(priv
, 0x0C, 0xFF & (v32
>> 24));
193 static int lgs8gxx_get_afc_phase(struct lgs8gxx_state
*priv
)
200 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
205 for (i
= 0; i
< 4; i
++) {
206 lgs8gxx_read_reg(priv
, reg_addr
, &t
);
213 val
*= priv
->config
->if_clk_freq
;
215 dprintk("AFC = %u kHz\n", (u32
)val
);
219 static int lgs8gxx_set_mode_auto(struct lgs8gxx_state
*priv
)
222 u8 prod
= priv
->config
->prod
;
224 if (prod
== LGS8GXX_PROD_LGS8913
)
225 lgs8gxx_write_reg(priv
, 0xC6, 0x01);
227 if (prod
== LGS8GXX_PROD_LGS8G75
) {
228 lgs8gxx_read_reg(priv
, 0x0C, &t
);
230 lgs8gxx_write_reg(priv
, 0x0C, t
| 0x80);
231 lgs8gxx_write_reg(priv
, 0x39, 0x00);
232 lgs8gxx_write_reg(priv
, 0x3D, 0x04);
233 } else if (prod
== LGS8GXX_PROD_LGS8913
||
234 prod
== LGS8GXX_PROD_LGS8GL5
||
235 prod
== LGS8GXX_PROD_LGS8G42
||
236 prod
== LGS8GXX_PROD_LGS8G52
||
237 prod
== LGS8GXX_PROD_LGS8G54
) {
238 lgs8gxx_read_reg(priv
, 0x7E, &t
);
239 lgs8gxx_write_reg(priv
, 0x7E, t
| 0x01);
241 /* clear FEC self reset */
242 lgs8gxx_read_reg(priv
, 0xC5, &t
);
243 lgs8gxx_write_reg(priv
, 0xC5, t
& 0xE0);
246 if (prod
== LGS8GXX_PROD_LGS8913
) {
247 /* FEC auto detect */
248 lgs8gxx_write_reg(priv
, 0xC1, 0x03);
250 lgs8gxx_read_reg(priv
, 0x7C, &t
);
251 t
= (t
& 0x8C) | 0x03;
252 lgs8gxx_write_reg(priv
, 0x7C, t
);
255 lgs8gxx_read_reg(priv
, 0xC3, &t
);
256 t
= (t
& 0xEF) | 0x10;
257 lgs8gxx_write_reg(priv
, 0xC3, t
);
260 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G52
)
261 lgs8gxx_write_reg(priv
, 0xD9, 0x40);
266 static int lgs8gxx_set_mode_manual(struct lgs8gxx_state
*priv
)
271 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
273 lgs8gxx_read_reg(priv
, 0x0C, &t
);
275 lgs8gxx_write_reg(priv
, 0x0C, t
);
277 lgs8gxx_read_reg(priv
, 0x0C, &t
);
278 lgs8gxx_read_reg(priv
, 0x19, &t2
);
280 if (((t
&0x03) == 0x01) && (t2
&0x01)) {
281 lgs8gxx_write_reg(priv
, 0x6E, 0x05);
282 lgs8gxx_write_reg(priv
, 0x39, 0x02);
283 lgs8gxx_write_reg(priv
, 0x39, 0x03);
284 lgs8gxx_write_reg(priv
, 0x3D, 0x05);
285 lgs8gxx_write_reg(priv
, 0x3E, 0x28);
286 lgs8gxx_write_reg(priv
, 0x53, 0x80);
288 lgs8gxx_write_reg(priv
, 0x6E, 0x3F);
289 lgs8gxx_write_reg(priv
, 0x39, 0x00);
290 lgs8gxx_write_reg(priv
, 0x3D, 0x04);
293 lgs8gxx_soft_reset(priv
);
297 /* turn off auto-detect; manual settings */
298 lgs8gxx_write_reg(priv
, 0x7E, 0);
299 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
)
300 lgs8gxx_write_reg(priv
, 0xC1, 0);
302 ret
= lgs8gxx_read_reg(priv
, 0xC5, &t
);
303 t
= (t
& 0xE0) | 0x06;
304 lgs8gxx_write_reg(priv
, 0xC5, t
);
306 lgs8gxx_soft_reset(priv
);
311 static int lgs8gxx_is_locked(struct lgs8gxx_state
*priv
, u8
*locked
)
316 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
317 ret
= lgs8gxx_read_reg(priv
, 0x13, &t
);
319 ret
= lgs8gxx_read_reg(priv
, 0x4B, &t
);
323 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
324 *locked
= ((t
& 0x80) == 0x80) ? 1 : 0;
326 *locked
= ((t
& 0xC0) == 0xC0) ? 1 : 0;
330 /* Wait for Code Acquisition Lock */
331 static int lgs8gxx_wait_ca_lock(struct lgs8gxx_state
*priv
, u8
*locked
)
336 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
346 ret
= wait_reg_mask(priv
, reg
, mask
, val
, 50, 40);
347 *locked
= (ret
== 0) ? 1 : 0;
352 static int lgs8gxx_is_autodetect_finished(struct lgs8gxx_state
*priv
,
358 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
368 ret
= wait_reg_mask(priv
, reg
, mask
, val
, 10, 20);
369 *finished
= (ret
== 0) ? 1 : 0;
374 static int lgs8gxx_autolock_gi(struct lgs8gxx_state
*priv
, u8 gi
, u8 cpn
,
382 dprintk("try GI 945\n");
383 else if (gi
== GI_595
)
384 dprintk("try GI 595\n");
385 else if (gi
== GI_420
)
386 dprintk("try GI 420\n");
387 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
388 lgs8gxx_read_reg(priv
, 0x0C, &t1
);
389 lgs8gxx_read_reg(priv
, 0x18, &t2
);
393 t2
|= cpn
? 0x01 : 0x00;
394 lgs8gxx_write_reg(priv
, 0x0C, t1
);
395 lgs8gxx_write_reg(priv
, 0x18, t2
);
397 lgs8gxx_write_reg(priv
, 0x04, gi
);
399 lgs8gxx_soft_reset(priv
);
400 err
= lgs8gxx_wait_ca_lock(priv
, locked
);
401 if (err
|| !(*locked
))
403 err
= lgs8gxx_is_autodetect_finished(priv
, &ad_fini
);
407 dprintk("auto detect finished\n");
414 static int lgs8gxx_auto_detect(struct lgs8gxx_state
*priv
,
415 u8
*detected_param
, u8
*gi
)
419 u8 locked
= 0, tmp_gi
;
421 dprintk("%s\n", __func__
);
423 lgs8gxx_set_mode_auto(priv
);
424 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
425 lgs8gxx_write_reg(priv
, 0x67, 0xAA);
426 lgs8gxx_write_reg(priv
, 0x6E, 0x3F);
429 lgs8gxx_write_reg(priv
, 0x03, 00);
432 for (i
= 0; i
< 2; i
++) {
433 for (j
= 0; j
< 2; j
++) {
435 err
= lgs8gxx_autolock_gi(priv
, GI_945
, j
, &locked
);
441 for (j
= 0; j
< 2; j
++) {
443 err
= lgs8gxx_autolock_gi(priv
, GI_420
, j
, &locked
);
450 err
= lgs8gxx_autolock_gi(priv
, GI_595
, 1, &locked
);
458 if ((err
== 0) && (locked
== 1)) {
461 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
) {
462 lgs8gxx_read_reg(priv
, 0xA2, &t
);
465 lgs8gxx_read_reg(priv
, 0x1F, &t
);
466 *detected_param
= t
& 0x3F;
469 if (tmp_gi
== GI_945
)
470 dprintk("GI 945 locked\n");
471 else if (tmp_gi
== GI_595
)
472 dprintk("GI 595 locked\n");
473 else if (tmp_gi
== GI_420
)
474 dprintk("GI 420 locked\n");
484 static void lgs8gxx_auto_lock(struct lgs8gxx_state
*priv
)
488 u8 detected_param
= 0;
490 err
= lgs8gxx_auto_detect(priv
, &detected_param
, &gi
);
493 dprintk("lgs8gxx_auto_detect failed\n");
495 dprintk("detected param = 0x%02X\n", detected_param
);
497 /* Apply detected parameters */
498 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
) {
499 u8 inter_leave_len
= detected_param
& TIM_MASK
;
500 /* Fix 8913 time interleaver detection bug */
501 inter_leave_len
= (inter_leave_len
== TIM_MIDDLE
) ? 0x60 : 0x40;
502 detected_param
&= CF_MASK
| SC_MASK
| LGS_FEC_MASK
;
503 detected_param
|= inter_leave_len
;
505 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
507 lgs8gxx_read_reg(priv
, 0x19, &t
);
509 t
|= detected_param
<< 1;
510 lgs8gxx_write_reg(priv
, 0x19, t
);
512 lgs8gxx_write_reg(priv
, 0x7D, detected_param
);
513 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
)
514 lgs8gxx_write_reg(priv
, 0xC0, detected_param
);
516 /* lgs8gxx_soft_reset(priv); */
518 /* Enter manual mode */
519 lgs8gxx_set_mode_manual(priv
);
523 priv
->curr_gi
= 945; break;
525 priv
->curr_gi
= 595; break;
527 priv
->curr_gi
= 420; break;
529 priv
->curr_gi
= 945; break;
533 static int lgs8gxx_set_mpeg_mode(struct lgs8gxx_state
*priv
,
534 u8 serial
, u8 clk_pol
, u8 clk_gated
)
539 reg_addr
= (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) ? 0x30 : 0xC2;
540 ret
= lgs8gxx_read_reg(priv
, reg_addr
, &t
);
545 t
|= serial
? TS_SERIAL
: TS_PARALLEL
;
546 t
|= clk_pol
? TS_CLK_INVERTED
: TS_CLK_NORMAL
;
547 t
|= clk_gated
? TS_CLK_GATED
: TS_CLK_FREERUN
;
549 ret
= lgs8gxx_write_reg(priv
, reg_addr
, t
);
556 /* A/D input peak-to-peak voltage range */
557 static int lgs8g75_set_adc_vpp(struct lgs8gxx_state
*priv
,
560 u8 r26
= 0x73, r27
= 0x90;
562 if (priv
->config
->prod
!= LGS8GXX_PROD_LGS8G75
)
565 r26
|= (sel
& 0x01) << 7;
566 r27
|= (sel
& 0x02) >> 1;
567 lgs8gxx_write_reg(priv
, 0x26, r26
);
568 lgs8gxx_write_reg(priv
, 0x27, r27
);
573 /* LGS8913 demod frontend functions */
575 static int lgs8913_init(struct lgs8gxx_state
*priv
)
579 /* LGS8913 specific */
580 lgs8gxx_write_reg(priv
, 0xc1, 0x3);
582 lgs8gxx_read_reg(priv
, 0x7c, &t
);
583 lgs8gxx_write_reg(priv
, 0x7c, (t
&0x8c) | 0x3);
585 /* LGS8913 specific */
586 lgs8gxx_read_reg(priv
, 0xc3, &t
);
587 lgs8gxx_write_reg(priv
, 0xc3, t
&0x10);
593 static int lgs8g75_init_data(struct lgs8gxx_state
*priv
)
595 const struct firmware
*fw
;
599 rc
= request_firmware(&fw
, "lgs8g75.fw", &priv
->i2c
->dev
);
603 lgs8gxx_write_reg(priv
, 0xC6, 0x40);
605 lgs8gxx_write_reg(priv
, 0x3D, 0x04);
606 lgs8gxx_write_reg(priv
, 0x39, 0x00);
608 lgs8gxx_write_reg(priv
, 0x3A, 0x00);
609 lgs8gxx_write_reg(priv
, 0x38, 0x00);
610 lgs8gxx_write_reg(priv
, 0x3B, 0x00);
611 lgs8gxx_write_reg(priv
, 0x38, 0x00);
613 for (i
= 0; i
< fw
->size
; i
++) {
614 lgs8gxx_write_reg(priv
, 0x38, 0x00);
615 lgs8gxx_write_reg(priv
, 0x3A, (u8
)(i
&0xff));
616 lgs8gxx_write_reg(priv
, 0x3B, (u8
)(i
>>8));
617 lgs8gxx_write_reg(priv
, 0x3C, fw
->data
[i
]);
620 lgs8gxx_write_reg(priv
, 0x38, 0x00);
622 release_firmware(fw
);
626 static int lgs8gxx_init(struct dvb_frontend
*fe
)
628 struct lgs8gxx_state
*priv
=
629 (struct lgs8gxx_state
*)fe
->demodulator_priv
;
630 const struct lgs8gxx_config
*config
= priv
->config
;
633 dprintk("%s\n", __func__
);
635 lgs8gxx_read_reg(priv
, 0, &data
);
636 dprintk("reg 0 = 0x%02X\n", data
);
638 if (config
->prod
== LGS8GXX_PROD_LGS8G75
)
639 lgs8g75_set_adc_vpp(priv
, config
->adc_vpp
);
641 /* Setup MPEG output format */
642 err
= lgs8gxx_set_mpeg_mode(priv
, config
->serial_ts
,
644 config
->ts_clk_gated
);
648 if (config
->prod
== LGS8GXX_PROD_LGS8913
)
650 lgs8gxx_set_if_freq(priv
, priv
->config
->if_freq
);
651 lgs8gxx_set_ad_mode(priv
);
656 static void lgs8gxx_release(struct dvb_frontend
*fe
)
658 struct lgs8gxx_state
*state
= fe
->demodulator_priv
;
659 dprintk("%s\n", __func__
);
665 static int lgs8gxx_write(struct dvb_frontend
*fe
, const u8 buf
[], int len
)
667 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
672 return lgs8gxx_write_reg(priv
, buf
[0], buf
[1]);
675 static int lgs8gxx_set_fe(struct dvb_frontend
*fe
,
676 struct dvb_frontend_parameters
*fe_params
)
678 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
680 dprintk("%s\n", __func__
);
683 if (fe
->ops
.tuner_ops
.set_params
) {
684 fe
->ops
.tuner_ops
.set_params(fe
, fe_params
);
685 if (fe
->ops
.i2c_gate_ctrl
)
686 fe
->ops
.i2c_gate_ctrl(fe
, 0);
689 /* start auto lock */
690 lgs8gxx_auto_lock(priv
);
697 static int lgs8gxx_get_fe(struct dvb_frontend
*fe
,
698 struct dvb_frontend_parameters
*fe_params
)
700 dprintk("%s\n", __func__
);
702 /* TODO: get real readings from device */
703 /* inversion status */
704 fe_params
->inversion
= INVERSION_OFF
;
707 fe_params
->u
.ofdm
.bandwidth
= BANDWIDTH_8_MHZ
;
709 fe_params
->u
.ofdm
.code_rate_HP
= FEC_AUTO
;
710 fe_params
->u
.ofdm
.code_rate_LP
= FEC_AUTO
;
712 fe_params
->u
.ofdm
.constellation
= QAM_AUTO
;
714 /* transmission mode */
715 fe_params
->u
.ofdm
.transmission_mode
= TRANSMISSION_MODE_AUTO
;
718 fe_params
->u
.ofdm
.guard_interval
= GUARD_INTERVAL_AUTO
;
721 fe_params
->u
.ofdm
.hierarchy_information
= HIERARCHY_NONE
;
727 int lgs8gxx_get_tune_settings(struct dvb_frontend
*fe
,
728 struct dvb_frontend_tune_settings
*fesettings
)
730 /* FIXME: copy from tda1004x.c */
731 fesettings
->min_delay_ms
= 800;
732 fesettings
->step_size
= 0;
733 fesettings
->max_drift
= 0;
737 static int lgs8gxx_read_status(struct dvb_frontend
*fe
, fe_status_t
*fe_status
)
739 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
743 dprintk("%s\n", __func__
);
746 lgs8gxx_get_afc_phase(priv
);
747 lgs8gxx_is_locked(priv
, &locked
);
748 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
750 *fe_status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
751 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
755 ret
= lgs8gxx_read_reg(priv
, 0x4B, &t
);
759 dprintk("Reg 0x4B: 0x%02X\n", t
);
762 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
) {
763 if ((t
& 0x40) == 0x40)
764 *fe_status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
;
765 if ((t
& 0x80) == 0x80)
766 *fe_status
|= FE_HAS_VITERBI
| FE_HAS_SYNC
|
769 if ((t
& 0x80) == 0x80)
770 *fe_status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
771 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
775 dprintk("%s: fe_status=0x%x\n", __func__
, *fe_status
);
779 static int lgs8gxx_read_signal_agc(struct lgs8gxx_state
*priv
, u16
*signal
)
784 dprintk("%s()\n", __func__
);
785 lgs8gxx_read_reg(priv
, 0x3F, &agc_lvl
[0]);
786 lgs8gxx_read_reg(priv
, 0x3E, &agc_lvl
[1]);
792 dprintk("agc_lvl: 0x%04X\n", v
);
809 *signal
= cat
* 65535 / 5;
814 static int lgs8913_read_signal_strength(struct lgs8gxx_state
*priv
, u16
*signal
)
817 s16 max_strength
= 0;
819 u16 i
, gi
= priv
->curr_gi
;
821 dprintk("%s\n", __func__
);
823 ret
= lgs8gxx_read_reg(priv
, 0x4B, &t
);
827 if (fake_signal_str
) {
828 if ((t
& 0xC0) == 0xC0) {
829 dprintk("Fake signal strength\n");
836 dprintk("gi = %d\n", gi
);
837 for (i
= 0; i
< gi
; i
++) {
840 lgs8gxx_write_reg(priv
, 0x84, 0x03 & (i
>> 8));
841 lgs8gxx_write_reg(priv
, 0x83, i
& 0xFF);
843 lgs8gxx_read_reg(priv
, 0x94, &str
);
844 if (max_strength
< str
)
848 *signal
= max_strength
;
849 dprintk("%s: signal=0x%02X\n", __func__
, *signal
);
851 lgs8gxx_read_reg(priv
, 0x95, &t
);
852 dprintk("%s: AVG Noise=0x%02X\n", __func__
, t
);
857 static int lgs8g75_read_signal_strength(struct lgs8gxx_state
*priv
, u16
*signal
)
862 dprintk("%s\n", __func__
);
864 lgs8gxx_read_reg(priv
, 0xB1, &t
);
867 lgs8gxx_read_reg(priv
, 0xB0, &t
);
871 dprintk("%s: signal=0x%02X\n", __func__
, *signal
);
876 static int lgs8gxx_read_signal_strength(struct dvb_frontend
*fe
, u16
*signal
)
878 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
880 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8913
)
881 return lgs8913_read_signal_strength(priv
, signal
);
882 else if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
883 return lgs8g75_read_signal_strength(priv
, signal
);
885 return lgs8gxx_read_signal_agc(priv
, signal
);
888 static int lgs8gxx_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
890 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
894 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
)
895 lgs8gxx_read_reg(priv
, 0x34, &t
);
897 lgs8gxx_read_reg(priv
, 0x95, &t
);
898 dprintk("AVG Noise=0x%02X\n", t
);
901 dprintk("snr=0x%x\n", *snr
);
906 static int lgs8gxx_read_ucblocks(struct dvb_frontend
*fe
, u32
*ucblocks
)
909 dprintk("%s: ucblocks=0x%x\n", __func__
, *ucblocks
);
913 static void packet_counter_start(struct lgs8gxx_state
*priv
)
917 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
918 lgs8gxx_read_reg(priv
, 0x30, &orig
);
921 lgs8gxx_write_reg(priv
, 0x30, t
);
923 lgs8gxx_write_reg(priv
, 0x30, t
);
925 lgs8gxx_write_reg(priv
, 0x30, t
);
927 lgs8gxx_write_reg(priv
, 0xC6, 0x01);
928 lgs8gxx_write_reg(priv
, 0xC6, 0x41);
929 lgs8gxx_write_reg(priv
, 0xC6, 0x01);
933 static void packet_counter_stop(struct lgs8gxx_state
*priv
)
937 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
938 lgs8gxx_read_reg(priv
, 0x30, &t
);
940 lgs8gxx_write_reg(priv
, 0x30, t
);
942 lgs8gxx_write_reg(priv
, 0xC6, 0x81);
946 static int lgs8gxx_read_ber(struct dvb_frontend
*fe
, u32
*ber
)
948 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
949 u8 reg_err
, reg_total
, t
;
950 u32 total_cnt
= 0, err_cnt
= 0;
953 dprintk("%s\n", __func__
);
955 packet_counter_start(priv
);
957 packet_counter_stop(priv
);
959 if (priv
->config
->prod
== LGS8GXX_PROD_LGS8G75
) {
960 reg_total
= 0x28; reg_err
= 0x2C;
962 reg_total
= 0xD0; reg_err
= 0xD4;
965 for (i
= 0; i
< 4; i
++) {
967 lgs8gxx_read_reg(priv
, reg_total
+3-i
, &t
);
970 for (i
= 0; i
< 4; i
++) {
972 lgs8gxx_read_reg(priv
, reg_err
+3-i
, &t
);
975 dprintk("error=%d total=%d\n", err_cnt
, total_cnt
);
980 *ber
= err_cnt
* 100 / total_cnt
;
982 dprintk("%s: ber=0x%x\n", __func__
, *ber
);
986 static int lgs8gxx_i2c_gate_ctrl(struct dvb_frontend
*fe
, int enable
)
988 struct lgs8gxx_state
*priv
= fe
->demodulator_priv
;
990 if (priv
->config
->tuner_address
== 0)
993 u8 v
= 0x80 | priv
->config
->tuner_address
;
994 return lgs8gxx_write_reg(priv
, 0x01, v
);
996 return lgs8gxx_write_reg(priv
, 0x01, 0);
999 static struct dvb_frontend_ops lgs8gxx_ops
= {
1001 .name
= "Legend Silicon LGS8913/LGS8GXX DMB-TH",
1003 .frequency_min
= 474000000,
1004 .frequency_max
= 858000000,
1005 .frequency_stepsize
= 10000,
1009 FE_CAN_TRANSMISSION_MODE_AUTO
|
1010 FE_CAN_GUARD_INTERVAL_AUTO
1013 .release
= lgs8gxx_release
,
1015 .init
= lgs8gxx_init
,
1016 .write
= lgs8gxx_write
,
1017 .i2c_gate_ctrl
= lgs8gxx_i2c_gate_ctrl
,
1019 .set_frontend
= lgs8gxx_set_fe
,
1020 .get_frontend
= lgs8gxx_get_fe
,
1021 .get_tune_settings
= lgs8gxx_get_tune_settings
,
1023 .read_status
= lgs8gxx_read_status
,
1024 .read_ber
= lgs8gxx_read_ber
,
1025 .read_signal_strength
= lgs8gxx_read_signal_strength
,
1026 .read_snr
= lgs8gxx_read_snr
,
1027 .read_ucblocks
= lgs8gxx_read_ucblocks
,
1030 struct dvb_frontend
*lgs8gxx_attach(const struct lgs8gxx_config
*config
,
1031 struct i2c_adapter
*i2c
)
1033 struct lgs8gxx_state
*priv
= NULL
;
1036 dprintk("%s()\n", __func__
);
1038 if (config
== NULL
|| i2c
== NULL
)
1041 priv
= kzalloc(sizeof(struct lgs8gxx_state
), GFP_KERNEL
);
1045 priv
->config
= config
;
1048 /* check if the demod is there */
1049 if (lgs8gxx_read_reg(priv
, 0, &data
) != 0) {
1050 dprintk("%s lgs8gxx not found at i2c addr 0x%02X\n",
1051 __func__
, priv
->config
->demod_address
);
1055 lgs8gxx_read_reg(priv
, 1, &data
);
1057 memcpy(&priv
->frontend
.ops
, &lgs8gxx_ops
,
1058 sizeof(struct dvb_frontend_ops
));
1059 priv
->frontend
.demodulator_priv
= priv
;
1061 if (config
->prod
== LGS8GXX_PROD_LGS8G75
)
1062 lgs8g75_init_data(priv
);
1064 return &priv
->frontend
;
1067 dprintk("%s() error_out\n", __func__
);
1072 EXPORT_SYMBOL(lgs8gxx_attach
);
1074 MODULE_DESCRIPTION("Legend Silicon LGS8913/LGS8GXX DMB-TH demodulator driver");
1075 MODULE_AUTHOR("David T. L. Wong <davidtlwong@gmail.com>");
1076 MODULE_LICENSE("GPL");