2 * Sony CXD2820R demodulator driver
4 * Copyright (C) 2010 Antti Palosaari <crope@iki.fi>
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
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include "cxd2820r_priv.h"
24 int cxd2820r_set_frontend_c(struct dvb_frontend
*fe
,
25 struct dvb_frontend_parameters
*params
)
27 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
28 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
34 struct reg_val_mask tab
[] = {
35 { 0x00080, 0x01, 0xff },
36 { 0x00081, 0x05, 0xff },
37 { 0x00085, 0x07, 0xff },
38 { 0x00088, 0x01, 0xff },
40 { 0x00082, 0x20, 0x60 },
41 { 0x1016a, 0x48, 0xff },
42 { 0x100a5, 0x00, 0x01 },
43 { 0x10020, 0x06, 0x07 },
44 { 0x10059, 0x50, 0xff },
45 { 0x10087, 0x0c, 0x3c },
46 { 0x1008b, 0x07, 0xff },
47 { 0x1001f, priv
->cfg
.if_agc_polarity
<< 7, 0x80 },
48 { 0x10070, priv
->cfg
.ts_mode
, 0xff },
51 dbg("%s: RF=%d SR=%d", __func__
, c
->frequency
, c
->symbol_rate
);
54 ret
= cxd2820r_gpio(fe
);
59 if (fe
->ops
.tuner_ops
.set_params
)
60 fe
->ops
.tuner_ops
.set_params(fe
, params
);
62 if (priv
->delivery_system
!= SYS_DVBC_ANNEX_AC
) {
63 for (i
= 0; i
< ARRAY_SIZE(tab
); i
++) {
64 ret
= cxd2820r_wr_reg_mask(priv
, tab
[i
].reg
,
65 tab
[i
].val
, tab
[i
].mask
);
71 priv
->delivery_system
= SYS_DVBC_ANNEX_AC
;
72 priv
->ber_running
= 0; /* tune stops BER counter */
74 /* program IF frequency */
75 if (fe
->ops
.tuner_ops
.get_if_frequency
) {
76 ret
= fe
->ops
.tuner_ops
.get_if_frequency(fe
, &if_freq
);
82 dbg("%s: if_freq=%d", __func__
, if_freq
);
84 num
= if_freq
/ 1000; /* Hz => kHz */
86 if_ctl
= cxd2820r_div_u64_round_closest(num
, 41000);
87 buf
[0] = (if_ctl
>> 8) & 0x3f;
88 buf
[1] = (if_ctl
>> 0) & 0xff;
90 ret
= cxd2820r_wr_regs(priv
, 0x10042, buf
, 2);
94 ret
= cxd2820r_wr_reg(priv
, 0x000ff, 0x08);
98 ret
= cxd2820r_wr_reg(priv
, 0x000fe, 0x01);
104 dbg("%s: failed:%d", __func__
, ret
);
108 int cxd2820r_get_frontend_c(struct dvb_frontend
*fe
,
109 struct dvb_frontend_parameters
*p
)
111 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
112 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
116 ret
= cxd2820r_rd_regs(priv
, 0x1001a, buf
, 2);
120 c
->symbol_rate
= 2500 * ((buf
[0] & 0x0f) << 8 | buf
[1]);
122 ret
= cxd2820r_rd_reg(priv
, 0x10019, &buf
[0]);
126 switch ((buf
[0] >> 0) & 0x03) {
128 c
->modulation
= QAM_16
;
131 c
->modulation
= QAM_32
;
134 c
->modulation
= QAM_64
;
137 c
->modulation
= QAM_128
;
140 c
->modulation
= QAM_256
;
144 switch ((buf
[0] >> 7) & 0x01) {
146 c
->inversion
= INVERSION_OFF
;
149 c
->inversion
= INVERSION_ON
;
155 dbg("%s: failed:%d", __func__
, ret
);
159 int cxd2820r_read_ber_c(struct dvb_frontend
*fe
, u32
*ber
)
161 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
163 u8 buf
[3], start_ber
= 0;
166 if (priv
->ber_running
) {
167 ret
= cxd2820r_rd_regs(priv
, 0x10076, buf
, sizeof(buf
));
171 if ((buf
[2] >> 7) & 0x01 || (buf
[2] >> 4) & 0x01) {
172 *ber
= (buf
[2] & 0x0f) << 16 | buf
[1] << 8 | buf
[0];
176 priv
->ber_running
= 1;
182 ret
= cxd2820r_wr_reg(priv
, 0x10079, 0x01);
189 dbg("%s: failed:%d", __func__
, ret
);
193 int cxd2820r_read_signal_strength_c(struct dvb_frontend
*fe
,
196 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
201 ret
= cxd2820r_rd_regs(priv
, 0x10049, buf
, sizeof(buf
));
205 tmp
= (buf
[0] & 0x03) << 8 | buf
[1];
206 tmp
= (~tmp
& 0x03ff);
214 /* scale value to 0x0000-0xffff */
215 *strength
= tmp
* 0xffff / (350-0);
219 dbg("%s: failed:%d", __func__
, ret
);
223 int cxd2820r_read_snr_c(struct dvb_frontend
*fe
, u16
*snr
)
225 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
229 /* report SNR in dB * 10 */
231 ret
= cxd2820r_rd_reg(priv
, 0x10019, &tmp
);
235 if (((tmp
>> 0) & 0x03) % 2) {
243 ret
= cxd2820r_rd_reg(priv
, 0x1004d, &tmp
);
247 #define CXD2820R_LOG2_E_24 24204406 /* log2(e) << 24 */
249 *snr
= A
* (intlog2(B
/ tmp
) >> 5) / (CXD2820R_LOG2_E_24
>> 5)
256 dbg("%s: failed:%d", __func__
, ret
);
260 int cxd2820r_read_ucblocks_c(struct dvb_frontend
*fe
, u32
*ucblocks
)
263 /* no way to read ? */
267 int cxd2820r_read_status_c(struct dvb_frontend
*fe
, fe_status_t
*status
)
269 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
274 ret
= cxd2820r_rd_regs(priv
, 0x10088, buf
, sizeof(buf
));
278 if (((buf
[0] >> 0) & 0x01) == 1) {
279 *status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
280 FE_HAS_VITERBI
| FE_HAS_SYNC
;
282 if (((buf
[1] >> 3) & 0x01) == 1) {
283 *status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
|
284 FE_HAS_VITERBI
| FE_HAS_SYNC
| FE_HAS_LOCK
;
288 dbg("%s: lock=%02x %02x", __func__
, buf
[0], buf
[1]);
292 dbg("%s: failed:%d", __func__
, ret
);
296 int cxd2820r_init_c(struct dvb_frontend
*fe
)
298 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
301 ret
= cxd2820r_wr_reg(priv
, 0x00085, 0x07);
307 dbg("%s: failed:%d", __func__
, ret
);
311 int cxd2820r_sleep_c(struct dvb_frontend
*fe
)
313 struct cxd2820r_priv
*priv
= fe
->demodulator_priv
;
315 struct reg_val_mask tab
[] = {
316 { 0x000ff, 0x1f, 0xff },
317 { 0x00085, 0x00, 0xff },
318 { 0x00088, 0x01, 0xff },
319 { 0x00081, 0x00, 0xff },
320 { 0x00080, 0x00, 0xff },
325 priv
->delivery_system
= SYS_UNDEFINED
;
327 for (i
= 0; i
< ARRAY_SIZE(tab
); i
++) {
328 ret
= cxd2820r_wr_reg_mask(priv
, tab
[i
].reg
, tab
[i
].val
,
336 dbg("%s: failed:%d", __func__
, ret
);
340 int cxd2820r_get_tune_settings_c(struct dvb_frontend
*fe
,
341 struct dvb_frontend_tune_settings
*s
)
343 s
->min_delay_ms
= 500;
344 s
->step_size
= 0; /* no zigzag */