2 * HDIC HD29L2 DMB-TH demodulator driver
4 * Copyright (C) 2011 Metropolia University of Applied Sciences, Electria R&D
6 * Author: Antti Palosaari <crope@iki.fi>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include "hd29l2_priv.h"
26 module_param_named(debug
, hd29l2_debug
, int, 0644);
27 MODULE_PARM_DESC(debug
, "Turn on/off frontend debugging (default:off).");
29 /* write multiple registers */
30 static int hd29l2_wr_regs(struct hd29l2_priv
*priv
, u8 reg
, u8
*val
, int len
)
34 struct i2c_msg msg
[1] = {
36 .addr
= priv
->cfg
.i2c_addr
,
45 memcpy(&buf
[2], val
, len
);
47 ret
= i2c_transfer(priv
->i2c
, msg
, 1);
51 warn("i2c wr failed=%d reg=%02x len=%d", ret
, reg
, len
);
58 /* read multiple registers */
59 static int hd29l2_rd_regs(struct hd29l2_priv
*priv
, u8 reg
, u8
*val
, int len
)
62 u8 buf
[2] = { 0x00, reg
};
63 struct i2c_msg msg
[2] = {
65 .addr
= priv
->cfg
.i2c_addr
,
70 .addr
= priv
->cfg
.i2c_addr
,
77 ret
= i2c_transfer(priv
->i2c
, msg
, 2);
81 warn("i2c rd failed=%d reg=%02x len=%d", ret
, reg
, len
);
88 /* write single register */
89 static int hd29l2_wr_reg(struct hd29l2_priv
*priv
, u8 reg
, u8 val
)
91 return hd29l2_wr_regs(priv
, reg
, &val
, 1);
94 /* read single register */
95 static int hd29l2_rd_reg(struct hd29l2_priv
*priv
, u8 reg
, u8
*val
)
97 return hd29l2_rd_regs(priv
, reg
, val
, 1);
100 /* write single register with mask */
101 static int hd29l2_wr_reg_mask(struct hd29l2_priv
*priv
, u8 reg
, u8 val
, u8 mask
)
106 /* no need for read if whole reg is written */
108 ret
= hd29l2_rd_regs(priv
, reg
, &tmp
, 1);
117 return hd29l2_wr_regs(priv
, reg
, &val
, 1);
120 /* read single register with mask */
121 int hd29l2_rd_reg_mask(struct hd29l2_priv
*priv
, u8 reg
, u8
*val
, u8 mask
)
126 ret
= hd29l2_rd_regs(priv
, reg
, &tmp
, 1);
132 /* find position of the first bit */
133 for (i
= 0; i
< 8; i
++) {
134 if ((mask
>> i
) & 0x01)
142 static int hd29l2_soft_reset(struct hd29l2_priv
*priv
)
147 ret
= hd29l2_rd_reg(priv
, 0x26, &tmp
);
151 ret
= hd29l2_wr_reg(priv
, 0x26, 0x0d);
155 usleep_range(10000, 20000);
157 ret
= hd29l2_wr_reg(priv
, 0x26, tmp
);
163 dbg("%s: failed=%d", __func__
, ret
);
167 static int hd29l2_i2c_gate_ctrl(struct dvb_frontend
*fe
, int enable
)
170 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
173 dbg("%s: enable=%d", __func__
, enable
);
175 /* set tuner address for demod */
176 if (!priv
->tuner_i2c_addr_programmed
&& enable
) {
177 /* no need to set tuner address every time, once is enough */
178 ret
= hd29l2_wr_reg(priv
, 0x9d, priv
->cfg
.tuner_i2c_addr
<< 1);
182 priv
->tuner_i2c_addr_programmed
= true;
185 /* open / close gate */
186 ret
= hd29l2_wr_reg(priv
, 0x9f, enable
);
190 /* wait demod ready */
191 for (i
= 10; i
; i
--) {
192 ret
= hd29l2_rd_reg(priv
, 0x9e, &tmp
);
199 usleep_range(5000, 10000);
202 dbg("%s: loop=%d", __func__
, i
);
206 dbg("%s: failed=%d", __func__
, ret
);
210 static int hd29l2_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
213 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
218 ret
= hd29l2_rd_reg(priv
, 0x05, &buf
[0]);
224 *status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
| FE_HAS_VITERBI
|
225 FE_HAS_SYNC
| FE_HAS_LOCK
;
227 ret
= hd29l2_rd_reg(priv
, 0x0d, &buf
[1]);
231 if ((buf
[1] & 0xfe) == 0x78)
233 *status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
234 FE_HAS_VITERBI
| FE_HAS_SYNC
;
237 priv
->fe_status
= *status
;
241 dbg("%s: failed=%d", __func__
, ret
);
245 static int hd29l2_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
248 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
252 if (!(priv
->fe_status
& FE_HAS_LOCK
)) {
258 ret
= hd29l2_rd_regs(priv
, 0x0b, buf
, 2);
262 tmp
= (buf
[0] << 8) | buf
[1];
264 /* report SNR in dB * 10 */
265 #define LOG10_20736_24 72422627 /* log10(20736) << 24 */
267 *snr
= (LOG10_20736_24
- intlog10(tmp
)) / ((1 << 24) / 100);
273 dbg("%s: failed=%d", __func__
, ret
);
277 static int hd29l2_read_signal_strength(struct dvb_frontend
*fe
, u16
*strength
)
280 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
286 ret
= hd29l2_rd_regs(priv
, 0xd5, buf
, 2);
290 tmp
= buf
[0] << 8 | buf
[1];
293 /* scale value to 0x0000-0xffff from 0x0000-0x0fff */
294 *strength
= tmp
* 0xffff / 0x0fff;
298 dbg("%s: failed=%d", __func__
, ret
);
302 static int hd29l2_read_ber(struct dvb_frontend
*fe
, u32
*ber
)
305 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
308 if (!(priv
->fe_status
& FE_HAS_SYNC
)) {
314 ret
= hd29l2_rd_regs(priv
, 0xd9, buf
, 2);
321 *ber
= ((buf
[0] & 0x0f) << 8) | buf
[1];
325 dbg("%s: failed=%d", __func__
, ret
);
329 static int hd29l2_read_ucblocks(struct dvb_frontend
*fe
, u32
*ucblocks
)
331 /* no way to read? */
336 static enum dvbfe_search
hd29l2_search(struct dvb_frontend
*fe
,
337 struct dvb_frontend_parameters
*p
)
340 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
341 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
343 u8 modulation
, carrier
, guard_interval
, interleave
, code_rate
;
348 dbg("%s: delivery_system=%d frequency=%d bandwidth_hz=%d " \
349 "modulation=%d inversion=%d fec_inner=%d guard_interval=%d",
351 c
->delivery_system
, c
->frequency
, c
->bandwidth_hz
,
352 c
->modulation
, c
->inversion
, c
->fec_inner
, c
->guard_interval
);
354 /* as for now we detect always params automatically */
358 if (fe
->ops
.tuner_ops
.set_params
)
359 fe
->ops
.tuner_ops
.set_params(fe
, p
);
361 /* get and program IF */
362 if (fe
->ops
.tuner_ops
.get_if_frequency
)
363 fe
->ops
.tuner_ops
.get_if_frequency(fe
, &if_freq
);
370 /* calc IF control value */
373 num64
= div_u64(num64
, HD29L2_XTAL
);
377 tmp
= 0xfc; /* tuner type normal */
381 tmp
= 0xfe; /* tuner type Zero-IF */
384 buf
[0] = ((if_ctl
>> 0) & 0xff);
385 buf
[1] = ((if_ctl
>> 8) & 0xff);
386 buf
[2] = ((if_ctl
>> 16) & 0xff);
388 /* program IF control */
389 ret
= hd29l2_wr_regs(priv
, 0x14, buf
, 3);
393 /* program tuner type */
394 ret
= hd29l2_wr_reg(priv
, 0xab, tmp
);
398 dbg("%s: if_ctl=%x", __func__
, if_ctl
);
405 /* disable quick mode */
406 ret
= hd29l2_wr_reg_mask(priv
, 0xac, 0 << 7, 0x80);
410 ret
= hd29l2_wr_reg_mask(priv
, 0x82, 1 << 1, 0x02);
414 /* enable auto mode */
415 ret
= hd29l2_wr_reg_mask(priv
, 0x7d, 1 << 6, 0x40);
419 ret
= hd29l2_wr_reg_mask(priv
, 0x81, 1 << 3, 0x08);
424 ret
= hd29l2_soft_reset(priv
);
428 /* detect modulation */
429 for (i
= 30; i
; i
--) {
432 ret
= hd29l2_rd_reg(priv
, 0x0d, &tmp
);
436 if ((((tmp
& 0xf0) >= 0x10) &&
437 ((tmp
& 0x0f) == 0x08)) || (tmp
>= 0x2c))
441 dbg("%s: loop=%d", __func__
, i
);
444 /* detection failed */
445 return DVBFE_ALGO_SEARCH_FAILED
;
447 /* read modulation */
448 ret
= hd29l2_rd_reg_mask(priv
, 0x7d, &modulation
, 0x07);
456 modulation
= HD29L2_QAM64
;
457 carrier
= HD29L2_CARRIER_MULTI
;
458 guard_interval
= HD29L2_PN945
;
459 interleave
= HD29L2_INTERLEAVER_420
;
460 code_rate
= HD29L2_CODE_RATE_08
;
462 tmp
= (code_rate
<< 3) | modulation
;
463 ret
= hd29l2_wr_reg_mask(priv
, 0x7d, tmp
, 0x5f);
467 tmp
= (carrier
<< 2) | guard_interval
;
468 ret
= hd29l2_wr_reg_mask(priv
, 0x81, tmp
, 0x0f);
473 ret
= hd29l2_wr_reg_mask(priv
, 0x82, tmp
, 0x03);
478 /* ensure modulation validy */
479 /* 0=QAM4_NR, 1=QAM4, 2=QAM16, 3=QAM32, 4=QAM64 */
480 if (modulation
> 4) {
481 dbg("%s: modulation=%d not valid", __func__
, modulation
);
485 /* program registers according to modulation */
486 for (i
= 0; i
< ARRAY_SIZE(reg_mod_vals_tab
); i
++) {
487 ret
= hd29l2_wr_reg(priv
, reg_mod_vals_tab
[i
].reg
,
488 reg_mod_vals_tab
[i
].val
[modulation
]);
493 /* read guard interval */
494 ret
= hd29l2_rd_reg_mask(priv
, 0x81, &guard_interval
, 0x03);
498 /* read carrier mode */
499 ret
= hd29l2_rd_reg_mask(priv
, 0x81, &carrier
, 0x04);
503 dbg("%s: modulation=%d guard_interval=%d carrier=%d",
504 __func__
, modulation
, guard_interval
, carrier
);
506 if ((carrier
== HD29L2_CARRIER_MULTI
) && (modulation
== HD29L2_QAM64
) &&
507 (guard_interval
== HD29L2_PN945
)) {
508 dbg("%s: C=3780 && QAM64 && PN945", __func__
);
510 ret
= hd29l2_wr_reg(priv
, 0x42, 0x33);
514 ret
= hd29l2_wr_reg(priv
, 0xdd, 0x01);
519 usleep_range(10000, 20000);
522 ret
= hd29l2_soft_reset(priv
);
526 /* wait demod lock */
527 for (i
= 30; i
; i
--) {
531 ret
= hd29l2_rd_reg_mask(priv
, 0x05, &tmp
, 0x01);
539 dbg("%s: loop=%d", __func__
, i
);
542 return DVBFE_ALGO_SEARCH_AGAIN
;
544 return DVBFE_ALGO_SEARCH_SUCCESS
;
546 dbg("%s: failed=%d", __func__
, ret
);
547 return DVBFE_ALGO_SEARCH_ERROR
;
550 static int hd29l2_get_frontend_algo(struct dvb_frontend
*fe
)
552 return DVBFE_ALGO_CUSTOM
;
555 static int hd29l2_get_frontend(struct dvb_frontend
*fe
,
556 struct dvb_frontend_parameters
*p
)
559 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
560 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
563 char *str_constellation
, *str_code_rate
, *str_constellation_code_rate
,
564 *str_guard_interval
, *str_carrier
, *str_guard_interval_carrier
,
565 *str_interleave
, *str_interleave_
;
567 ret
= hd29l2_rd_reg(priv
, 0x7d, &buf
[0]);
571 ret
= hd29l2_rd_regs(priv
, 0x81, &buf
[1], 2);
575 /* constellation, 0x7d[2:0] */
576 switch ((buf
[0] >> 0) & 0x07) {
578 str_constellation
= "QAM4NR";
579 c
->modulation
= QAM_AUTO
; /* FIXME */
582 str_constellation
= "QAM4";
583 c
->modulation
= QPSK
; /* FIXME */
586 str_constellation
= "QAM16";
587 c
->modulation
= QAM_16
;
590 str_constellation
= "QAM32";
591 c
->modulation
= QAM_32
;
594 str_constellation
= "QAM64";
595 c
->modulation
= QAM_64
;
598 str_constellation
= "?";
601 /* LDPC code rate, 0x7d[4:3] */
602 switch ((buf
[0] >> 3) & 0x03) {
604 str_code_rate
= "0.4";
605 c
->fec_inner
= FEC_AUTO
; /* FIXME */
608 str_code_rate
= "0.6";
609 c
->fec_inner
= FEC_3_5
;
612 str_code_rate
= "0.8";
613 c
->fec_inner
= FEC_4_5
;
619 /* constellation & code rate set, 0x7d[6] */
620 switch ((buf
[0] >> 6) & 0x01) {
622 str_constellation_code_rate
= "manual";
625 str_constellation_code_rate
= "auto";
628 str_constellation_code_rate
= "?";
631 /* frame header, 0x81[1:0] */
632 switch ((buf
[1] >> 0) & 0x03) {
634 str_guard_interval
= "PN945";
635 c
->guard_interval
= GUARD_INTERVAL_AUTO
; /* FIXME */
638 str_guard_interval
= "PN595";
639 c
->guard_interval
= GUARD_INTERVAL_AUTO
; /* FIXME */
642 str_guard_interval
= "PN420";
643 c
->guard_interval
= GUARD_INTERVAL_AUTO
; /* FIXME */
646 str_guard_interval
= "?";
649 /* carrier, 0x81[2] */
650 switch ((buf
[1] >> 2) & 0x01) {
655 str_carrier
= "C=3780";
661 /* frame header & carrier set, 0x81[3] */
662 switch ((buf
[1] >> 3) & 0x01) {
664 str_guard_interval_carrier
= "manual";
667 str_guard_interval_carrier
= "auto";
670 str_guard_interval_carrier
= "?";
673 /* interleave, 0x82[0] */
674 switch ((buf
[2] >> 0) & 0x01) {
676 str_interleave
= "M=720";
679 str_interleave
= "M=240";
682 str_interleave
= "?";
685 /* interleave set, 0x82[1] */
686 switch ((buf
[2] >> 1) & 0x01) {
688 str_interleave_
= "manual";
691 str_interleave_
= "auto";
694 str_interleave_
= "?";
698 * We can read out current detected NCO and use that value next
699 * time instead of calculating new value from targed IF.
700 * I think it will not effect receiver sensitivity but gaining lock
701 * after tune could be easier...
703 ret
= hd29l2_rd_regs(priv
, 0xb1, &buf
[0], 3);
707 if_ctl
= (buf
[0] << 16) | ((buf
[1] - 7) << 8) | buf
[2];
709 dbg("%s: %s %s %s | %s %s %s | %s %s | NCO=%06x", __func__
,
710 str_constellation
, str_code_rate
, str_constellation_code_rate
,
711 str_guard_interval
, str_carrier
, str_guard_interval_carrier
,
712 str_interleave
, str_interleave_
, if_ctl
);
716 dbg("%s: failed=%d", __func__
, ret
);
720 static int hd29l2_init(struct dvb_frontend
*fe
)
723 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
725 static const struct reg_val tab
[] = {
735 dbg("%s:", __func__
);
738 /* it is recommended to HW reset chip using RST_N pin */
740 ret
= fe
->callback(fe
, 0, 0, 0);
744 /* reprogramming needed because HW reset clears registers */
745 priv
->tuner_i2c_addr_programmed
= false;
749 for (i
= 0; i
< ARRAY_SIZE(tab
); i
++) {
750 ret
= hd29l2_wr_reg(priv
, tab
[i
].reg
, tab
[i
].val
);
756 ret
= hd29l2_rd_reg(priv
, 0x36, &tmp
);
761 tmp
|= priv
->cfg
.ts_mode
;
762 ret
= hd29l2_wr_reg(priv
, 0x36, tmp
);
766 ret
= hd29l2_rd_reg(priv
, 0x31, &tmp
);
769 if (!(priv
->cfg
.ts_mode
>> 7))
770 /* set b4 for serial TS */
773 ret
= hd29l2_wr_reg(priv
, 0x31, tmp
);
779 dbg("%s: failed=%d", __func__
, ret
);
783 static void hd29l2_release(struct dvb_frontend
*fe
)
785 struct hd29l2_priv
*priv
= fe
->demodulator_priv
;
789 static struct dvb_frontend_ops hd29l2_ops
;
791 struct dvb_frontend
*hd29l2_attach(const struct hd29l2_config
*config
,
792 struct i2c_adapter
*i2c
)
795 struct hd29l2_priv
*priv
= NULL
;
798 /* allocate memory for the internal state */
799 priv
= kzalloc(sizeof(struct hd29l2_priv
), GFP_KERNEL
);
803 /* setup the state */
805 memcpy(&priv
->cfg
, config
, sizeof(struct hd29l2_config
));
808 /* check if the demod is there */
809 ret
= hd29l2_rd_reg(priv
, 0x00, &tmp
);
813 /* create dvb_frontend */
814 memcpy(&priv
->fe
.ops
, &hd29l2_ops
, sizeof(struct dvb_frontend_ops
));
815 priv
->fe
.demodulator_priv
= priv
;
822 EXPORT_SYMBOL(hd29l2_attach
);
824 static struct dvb_frontend_ops hd29l2_ops
= {
826 .name
= "HDIC HD29L2 DMB-TH",
828 .frequency_min
= 474000000,
829 .frequency_max
= 858000000,
830 .frequency_stepsize
= 10000,
831 .caps
= FE_CAN_FEC_AUTO
|
837 FE_CAN_TRANSMISSION_MODE_AUTO
|
838 FE_CAN_BANDWIDTH_AUTO
|
839 FE_CAN_GUARD_INTERVAL_AUTO
|
840 FE_CAN_HIERARCHY_AUTO
|
844 .release
= hd29l2_release
,
848 .get_frontend_algo
= hd29l2_get_frontend_algo
,
849 .search
= hd29l2_search
,
850 .get_frontend
= hd29l2_get_frontend
,
852 .read_status
= hd29l2_read_status
,
853 .read_snr
= hd29l2_read_snr
,
854 .read_signal_strength
= hd29l2_read_signal_strength
,
855 .read_ber
= hd29l2_read_ber
,
856 .read_ucblocks
= hd29l2_read_ucblocks
,
858 .i2c_gate_ctrl
= hd29l2_i2c_gate_ctrl
,
861 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
862 MODULE_DESCRIPTION("HDIC HD29L2 DMB-TH demodulator driver");
863 MODULE_LICENSE("GPL");