diff options
author | Antti Palosaari <crope@iki.fi> | 2016-08-09 13:58:21 -0400 |
---|---|---|
committer | Mauro Carvalho Chehab <mchehab@s-opensource.com> | 2016-09-22 09:40:29 -0400 |
commit | 4aa4fd86bca5769c9884838501454ef4c486936d (patch) | |
tree | 281b25dcc481787fa096656d5a95c530f06a5fd0 | |
parent | 90d5d2e3f047164748e67ae7cf4d5a7bb6a8d0b3 (diff) |
[media] cxd2820r: wrap legacy DVBv3 statistics via DVBv5 statistics
Return DVBv5 statistics via legacy DVBv3 API.
Signed-off-by: Antti Palosaari <crope@iki.fi>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
-rw-r--r-- | drivers/media/dvb-frontends/cxd2820r_c.c | 108 | ||||
-rw-r--r-- | drivers/media/dvb-frontends/cxd2820r_core.c | 85 | ||||
-rw-r--r-- | drivers/media/dvb-frontends/cxd2820r_priv.h | 25 | ||||
-rw-r--r-- | drivers/media/dvb-frontends/cxd2820r_t.c | 94 | ||||
-rw-r--r-- | drivers/media/dvb-frontends/cxd2820r_t2.c | 87 |
5 files changed, 22 insertions, 377 deletions
diff --git a/drivers/media/dvb-frontends/cxd2820r_c.c b/drivers/media/dvb-frontends/cxd2820r_c.c index 7cdcd5535d06..82df94413aeb 100644 --- a/drivers/media/dvb-frontends/cxd2820r_c.c +++ b/drivers/media/dvb-frontends/cxd2820r_c.c | |||
@@ -149,114 +149,6 @@ error: | |||
149 | return ret; | 149 | return ret; |
150 | } | 150 | } |
151 | 151 | ||
152 | int cxd2820r_read_ber_c(struct dvb_frontend *fe, u32 *ber) | ||
153 | { | ||
154 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
155 | int ret; | ||
156 | u8 buf[3], start_ber = 0; | ||
157 | *ber = 0; | ||
158 | |||
159 | if (priv->ber_running) { | ||
160 | ret = cxd2820r_rd_regs(priv, 0x10076, buf, sizeof(buf)); | ||
161 | if (ret) | ||
162 | goto error; | ||
163 | |||
164 | if ((buf[2] >> 7) & 0x01 || (buf[2] >> 4) & 0x01) { | ||
165 | *ber = (buf[2] & 0x0f) << 16 | buf[1] << 8 | buf[0]; | ||
166 | start_ber = 1; | ||
167 | } | ||
168 | } else { | ||
169 | priv->ber_running = true; | ||
170 | start_ber = 1; | ||
171 | } | ||
172 | |||
173 | if (start_ber) { | ||
174 | /* (re)start BER */ | ||
175 | ret = cxd2820r_wr_reg(priv, 0x10079, 0x01); | ||
176 | if (ret) | ||
177 | goto error; | ||
178 | } | ||
179 | |||
180 | return ret; | ||
181 | error: | ||
182 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
183 | return ret; | ||
184 | } | ||
185 | |||
186 | int cxd2820r_read_signal_strength_c(struct dvb_frontend *fe, | ||
187 | u16 *strength) | ||
188 | { | ||
189 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
190 | int ret; | ||
191 | u8 buf[2]; | ||
192 | u16 tmp; | ||
193 | |||
194 | ret = cxd2820r_rd_regs(priv, 0x10049, buf, sizeof(buf)); | ||
195 | if (ret) | ||
196 | goto error; | ||
197 | |||
198 | tmp = (buf[0] & 0x03) << 8 | buf[1]; | ||
199 | tmp = (~tmp & 0x03ff); | ||
200 | |||
201 | if (tmp == 512) | ||
202 | /* ~no signal */ | ||
203 | tmp = 0; | ||
204 | else if (tmp > 350) | ||
205 | tmp = 350; | ||
206 | |||
207 | /* scale value to 0x0000-0xffff */ | ||
208 | *strength = tmp * 0xffff / (350-0); | ||
209 | |||
210 | return ret; | ||
211 | error: | ||
212 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
213 | return ret; | ||
214 | } | ||
215 | |||
216 | int cxd2820r_read_snr_c(struct dvb_frontend *fe, u16 *snr) | ||
217 | { | ||
218 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
219 | int ret; | ||
220 | u8 tmp; | ||
221 | unsigned int A, B; | ||
222 | /* report SNR in dB * 10 */ | ||
223 | |||
224 | ret = cxd2820r_rd_reg(priv, 0x10019, &tmp); | ||
225 | if (ret) | ||
226 | goto error; | ||
227 | |||
228 | if (((tmp >> 0) & 0x03) % 2) { | ||
229 | A = 875; | ||
230 | B = 650; | ||
231 | } else { | ||
232 | A = 950; | ||
233 | B = 760; | ||
234 | } | ||
235 | |||
236 | ret = cxd2820r_rd_reg(priv, 0x1004d, &tmp); | ||
237 | if (ret) | ||
238 | goto error; | ||
239 | |||
240 | #define CXD2820R_LOG2_E_24 24204406 /* log2(e) << 24 */ | ||
241 | if (tmp) | ||
242 | *snr = A * (intlog2(B / tmp) >> 5) / (CXD2820R_LOG2_E_24 >> 5) | ||
243 | / 10; | ||
244 | else | ||
245 | *snr = 0; | ||
246 | |||
247 | return ret; | ||
248 | error: | ||
249 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
250 | return ret; | ||
251 | } | ||
252 | |||
253 | int cxd2820r_read_ucblocks_c(struct dvb_frontend *fe, u32 *ucblocks) | ||
254 | { | ||
255 | *ucblocks = 0; | ||
256 | /* no way to read ? */ | ||
257 | return 0; | ||
258 | } | ||
259 | |||
260 | int cxd2820r_read_status_c(struct dvb_frontend *fe, enum fe_status *status) | 152 | int cxd2820r_read_status_c(struct dvb_frontend *fe, enum fe_status *status) |
261 | { | 153 | { |
262 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 154 | struct cxd2820r_priv *priv = fe->demodulator_priv; |
diff --git a/drivers/media/dvb-frontends/cxd2820r_core.c b/drivers/media/dvb-frontends/cxd2820r_core.c index 314d3b8c1080..66da8212cb60 100644 --- a/drivers/media/dvb-frontends/cxd2820r_core.c +++ b/drivers/media/dvb-frontends/cxd2820r_core.c | |||
@@ -345,101 +345,58 @@ static int cxd2820r_get_frontend(struct dvb_frontend *fe, | |||
345 | static int cxd2820r_read_ber(struct dvb_frontend *fe, u32 *ber) | 345 | static int cxd2820r_read_ber(struct dvb_frontend *fe, u32 *ber) |
346 | { | 346 | { |
347 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 347 | struct cxd2820r_priv *priv = fe->demodulator_priv; |
348 | int ret; | ||
349 | 348 | ||
350 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, | 349 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, |
351 | fe->dtv_property_cache.delivery_system); | 350 | fe->dtv_property_cache.delivery_system); |
352 | 351 | ||
353 | switch (fe->dtv_property_cache.delivery_system) { | 352 | *ber = (priv->post_bit_error - priv->post_bit_error_prev_dvbv3); |
354 | case SYS_DVBT: | 353 | priv->post_bit_error_prev_dvbv3 = priv->post_bit_error; |
355 | ret = cxd2820r_read_ber_t(fe, ber); | 354 | |
356 | break; | 355 | return 0; |
357 | case SYS_DVBT2: | ||
358 | ret = cxd2820r_read_ber_t2(fe, ber); | ||
359 | break; | ||
360 | case SYS_DVBC_ANNEX_A: | ||
361 | ret = cxd2820r_read_ber_c(fe, ber); | ||
362 | break; | ||
363 | default: | ||
364 | ret = -EINVAL; | ||
365 | break; | ||
366 | } | ||
367 | return ret; | ||
368 | } | 356 | } |
369 | 357 | ||
370 | static int cxd2820r_read_signal_strength(struct dvb_frontend *fe, u16 *strength) | 358 | static int cxd2820r_read_signal_strength(struct dvb_frontend *fe, u16 *strength) |
371 | { | 359 | { |
372 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 360 | struct cxd2820r_priv *priv = fe->demodulator_priv; |
373 | int ret; | 361 | struct dtv_frontend_properties *c = &fe->dtv_property_cache; |
374 | 362 | ||
375 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, | 363 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, |
376 | fe->dtv_property_cache.delivery_system); | 364 | fe->dtv_property_cache.delivery_system); |
377 | 365 | ||
378 | switch (fe->dtv_property_cache.delivery_system) { | 366 | if (c->strength.stat[0].scale == FE_SCALE_RELATIVE) |
379 | case SYS_DVBT: | 367 | *strength = c->strength.stat[0].uvalue; |
380 | ret = cxd2820r_read_signal_strength_t(fe, strength); | 368 | else |
381 | break; | 369 | *strength = 0; |
382 | case SYS_DVBT2: | 370 | |
383 | ret = cxd2820r_read_signal_strength_t2(fe, strength); | 371 | return 0; |
384 | break; | ||
385 | case SYS_DVBC_ANNEX_A: | ||
386 | ret = cxd2820r_read_signal_strength_c(fe, strength); | ||
387 | break; | ||
388 | default: | ||
389 | ret = -EINVAL; | ||
390 | break; | ||
391 | } | ||
392 | return ret; | ||
393 | } | 372 | } |
394 | 373 | ||
395 | static int cxd2820r_read_snr(struct dvb_frontend *fe, u16 *snr) | 374 | static int cxd2820r_read_snr(struct dvb_frontend *fe, u16 *snr) |
396 | { | 375 | { |
397 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 376 | struct cxd2820r_priv *priv = fe->demodulator_priv; |
398 | int ret; | 377 | struct dtv_frontend_properties *c = &fe->dtv_property_cache; |
399 | 378 | ||
400 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, | 379 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, |
401 | fe->dtv_property_cache.delivery_system); | 380 | fe->dtv_property_cache.delivery_system); |
402 | 381 | ||
403 | switch (fe->dtv_property_cache.delivery_system) { | 382 | if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL) |
404 | case SYS_DVBT: | 383 | *snr = div_s64(c->cnr.stat[0].svalue, 100); |
405 | ret = cxd2820r_read_snr_t(fe, snr); | 384 | else |
406 | break; | 385 | *snr = 0; |
407 | case SYS_DVBT2: | 386 | |
408 | ret = cxd2820r_read_snr_t2(fe, snr); | 387 | return 0; |
409 | break; | ||
410 | case SYS_DVBC_ANNEX_A: | ||
411 | ret = cxd2820r_read_snr_c(fe, snr); | ||
412 | break; | ||
413 | default: | ||
414 | ret = -EINVAL; | ||
415 | break; | ||
416 | } | ||
417 | return ret; | ||
418 | } | 388 | } |
419 | 389 | ||
420 | static int cxd2820r_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) | 390 | static int cxd2820r_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) |
421 | { | 391 | { |
422 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 392 | struct cxd2820r_priv *priv = fe->demodulator_priv; |
423 | int ret; | ||
424 | 393 | ||
425 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, | 394 | dev_dbg(&priv->i2c->dev, "%s: delsys=%d\n", __func__, |
426 | fe->dtv_property_cache.delivery_system); | 395 | fe->dtv_property_cache.delivery_system); |
427 | 396 | ||
428 | switch (fe->dtv_property_cache.delivery_system) { | 397 | *ucblocks = 0; |
429 | case SYS_DVBT: | 398 | |
430 | ret = cxd2820r_read_ucblocks_t(fe, ucblocks); | 399 | return 0; |
431 | break; | ||
432 | case SYS_DVBT2: | ||
433 | ret = cxd2820r_read_ucblocks_t2(fe, ucblocks); | ||
434 | break; | ||
435 | case SYS_DVBC_ANNEX_A: | ||
436 | ret = cxd2820r_read_ucblocks_c(fe, ucblocks); | ||
437 | break; | ||
438 | default: | ||
439 | ret = -EINVAL; | ||
440 | break; | ||
441 | } | ||
442 | return ret; | ||
443 | } | 400 | } |
444 | 401 | ||
445 | static int cxd2820r_init(struct dvb_frontend *fe) | 402 | static int cxd2820r_init(struct dvb_frontend *fe) |
diff --git a/drivers/media/dvb-frontends/cxd2820r_priv.h b/drivers/media/dvb-frontends/cxd2820r_priv.h index a97570b7fa1d..66b19dd1f186 100644 --- a/drivers/media/dvb-frontends/cxd2820r_priv.h +++ b/drivers/media/dvb-frontends/cxd2820r_priv.h | |||
@@ -41,6 +41,7 @@ struct cxd2820r_priv { | |||
41 | struct i2c_adapter *i2c; | 41 | struct i2c_adapter *i2c; |
42 | struct dvb_frontend fe; | 42 | struct dvb_frontend fe; |
43 | struct cxd2820r_config cfg; | 43 | struct cxd2820r_config cfg; |
44 | u64 post_bit_error_prev_dvbv3; | ||
44 | u64 post_bit_error; | 45 | u64 post_bit_error; |
45 | 46 | ||
46 | bool ber_running; | 47 | bool ber_running; |
@@ -87,14 +88,6 @@ int cxd2820r_set_frontend_c(struct dvb_frontend *fe); | |||
87 | 88 | ||
88 | int cxd2820r_read_status_c(struct dvb_frontend *fe, enum fe_status *status); | 89 | int cxd2820r_read_status_c(struct dvb_frontend *fe, enum fe_status *status); |
89 | 90 | ||
90 | int cxd2820r_read_ber_c(struct dvb_frontend *fe, u32 *ber); | ||
91 | |||
92 | int cxd2820r_read_signal_strength_c(struct dvb_frontend *fe, u16 *strength); | ||
93 | |||
94 | int cxd2820r_read_snr_c(struct dvb_frontend *fe, u16 *snr); | ||
95 | |||
96 | int cxd2820r_read_ucblocks_c(struct dvb_frontend *fe, u32 *ucblocks); | ||
97 | |||
98 | int cxd2820r_init_c(struct dvb_frontend *fe); | 91 | int cxd2820r_init_c(struct dvb_frontend *fe); |
99 | 92 | ||
100 | int cxd2820r_sleep_c(struct dvb_frontend *fe); | 93 | int cxd2820r_sleep_c(struct dvb_frontend *fe); |
@@ -111,14 +104,6 @@ int cxd2820r_set_frontend_t(struct dvb_frontend *fe); | |||
111 | 104 | ||
112 | int cxd2820r_read_status_t(struct dvb_frontend *fe, enum fe_status *status); | 105 | int cxd2820r_read_status_t(struct dvb_frontend *fe, enum fe_status *status); |
113 | 106 | ||
114 | int cxd2820r_read_ber_t(struct dvb_frontend *fe, u32 *ber); | ||
115 | |||
116 | int cxd2820r_read_signal_strength_t(struct dvb_frontend *fe, u16 *strength); | ||
117 | |||
118 | int cxd2820r_read_snr_t(struct dvb_frontend *fe, u16 *snr); | ||
119 | |||
120 | int cxd2820r_read_ucblocks_t(struct dvb_frontend *fe, u32 *ucblocks); | ||
121 | |||
122 | int cxd2820r_init_t(struct dvb_frontend *fe); | 107 | int cxd2820r_init_t(struct dvb_frontend *fe); |
123 | 108 | ||
124 | int cxd2820r_sleep_t(struct dvb_frontend *fe); | 109 | int cxd2820r_sleep_t(struct dvb_frontend *fe); |
@@ -135,14 +120,6 @@ int cxd2820r_set_frontend_t2(struct dvb_frontend *fe); | |||
135 | 120 | ||
136 | int cxd2820r_read_status_t2(struct dvb_frontend *fe, enum fe_status *status); | 121 | int cxd2820r_read_status_t2(struct dvb_frontend *fe, enum fe_status *status); |
137 | 122 | ||
138 | int cxd2820r_read_ber_t2(struct dvb_frontend *fe, u32 *ber); | ||
139 | |||
140 | int cxd2820r_read_signal_strength_t2(struct dvb_frontend *fe, u16 *strength); | ||
141 | |||
142 | int cxd2820r_read_snr_t2(struct dvb_frontend *fe, u16 *snr); | ||
143 | |||
144 | int cxd2820r_read_ucblocks_t2(struct dvb_frontend *fe, u32 *ucblocks); | ||
145 | |||
146 | int cxd2820r_init_t2(struct dvb_frontend *fe); | 123 | int cxd2820r_init_t2(struct dvb_frontend *fe); |
147 | 124 | ||
148 | int cxd2820r_sleep_t2(struct dvb_frontend *fe); | 125 | int cxd2820r_sleep_t2(struct dvb_frontend *fe); |
diff --git a/drivers/media/dvb-frontends/cxd2820r_t.c b/drivers/media/dvb-frontends/cxd2820r_t.c index d402ab68368b..ddd8e46511a9 100644 --- a/drivers/media/dvb-frontends/cxd2820r_t.c +++ b/drivers/media/dvb-frontends/cxd2820r_t.c | |||
@@ -254,100 +254,6 @@ error: | |||
254 | return ret; | 254 | return ret; |
255 | } | 255 | } |
256 | 256 | ||
257 | int cxd2820r_read_ber_t(struct dvb_frontend *fe, u32 *ber) | ||
258 | { | ||
259 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
260 | int ret; | ||
261 | u8 buf[3], start_ber = 0; | ||
262 | *ber = 0; | ||
263 | |||
264 | if (priv->ber_running) { | ||
265 | ret = cxd2820r_rd_regs(priv, 0x00076, buf, sizeof(buf)); | ||
266 | if (ret) | ||
267 | goto error; | ||
268 | |||
269 | if ((buf[2] >> 7) & 0x01 || (buf[2] >> 4) & 0x01) { | ||
270 | *ber = (buf[2] & 0x0f) << 16 | buf[1] << 8 | buf[0]; | ||
271 | start_ber = 1; | ||
272 | } | ||
273 | } else { | ||
274 | priv->ber_running = true; | ||
275 | start_ber = 1; | ||
276 | } | ||
277 | |||
278 | if (start_ber) { | ||
279 | /* (re)start BER */ | ||
280 | ret = cxd2820r_wr_reg(priv, 0x00079, 0x01); | ||
281 | if (ret) | ||
282 | goto error; | ||
283 | } | ||
284 | |||
285 | return ret; | ||
286 | error: | ||
287 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
288 | return ret; | ||
289 | } | ||
290 | |||
291 | int cxd2820r_read_signal_strength_t(struct dvb_frontend *fe, | ||
292 | u16 *strength) | ||
293 | { | ||
294 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
295 | int ret; | ||
296 | u8 buf[2]; | ||
297 | u16 tmp; | ||
298 | |||
299 | ret = cxd2820r_rd_regs(priv, 0x00026, buf, sizeof(buf)); | ||
300 | if (ret) | ||
301 | goto error; | ||
302 | |||
303 | tmp = (buf[0] & 0x0f) << 8 | buf[1]; | ||
304 | tmp = ~tmp & 0x0fff; | ||
305 | |||
306 | /* scale value to 0x0000-0xffff from 0x0000-0x0fff */ | ||
307 | *strength = tmp * 0xffff / 0x0fff; | ||
308 | |||
309 | return ret; | ||
310 | error: | ||
311 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
312 | return ret; | ||
313 | } | ||
314 | |||
315 | int cxd2820r_read_snr_t(struct dvb_frontend *fe, u16 *snr) | ||
316 | { | ||
317 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
318 | int ret; | ||
319 | u8 buf[2]; | ||
320 | u16 tmp; | ||
321 | /* report SNR in dB * 10 */ | ||
322 | |||
323 | ret = cxd2820r_rd_regs(priv, 0x00028, buf, sizeof(buf)); | ||
324 | if (ret) | ||
325 | goto error; | ||
326 | |||
327 | tmp = (buf[0] & 0x1f) << 8 | buf[1]; | ||
328 | #define CXD2820R_LOG10_8_24 15151336 /* log10(8) << 24 */ | ||
329 | if (tmp) | ||
330 | *snr = (intlog10(tmp) - CXD2820R_LOG10_8_24) / ((1 << 24) | ||
331 | / 100); | ||
332 | else | ||
333 | *snr = 0; | ||
334 | |||
335 | dev_dbg(&priv->i2c->dev, "%s: dBx10=%d val=%04x\n", __func__, *snr, | ||
336 | tmp); | ||
337 | |||
338 | return ret; | ||
339 | error: | ||
340 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
341 | return ret; | ||
342 | } | ||
343 | |||
344 | int cxd2820r_read_ucblocks_t(struct dvb_frontend *fe, u32 *ucblocks) | ||
345 | { | ||
346 | *ucblocks = 0; | ||
347 | /* no way to read ? */ | ||
348 | return 0; | ||
349 | } | ||
350 | |||
351 | int cxd2820r_read_status_t(struct dvb_frontend *fe, enum fe_status *status) | 257 | int cxd2820r_read_status_t(struct dvb_frontend *fe, enum fe_status *status) |
352 | { | 258 | { |
353 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 259 | struct cxd2820r_priv *priv = fe->demodulator_priv; |
diff --git a/drivers/media/dvb-frontends/cxd2820r_t2.c b/drivers/media/dvb-frontends/cxd2820r_t2.c index e2875f2655bd..e09f1527ef0c 100644 --- a/drivers/media/dvb-frontends/cxd2820r_t2.c +++ b/drivers/media/dvb-frontends/cxd2820r_t2.c | |||
@@ -387,93 +387,6 @@ error: | |||
387 | return ret; | 387 | return ret; |
388 | } | 388 | } |
389 | 389 | ||
390 | int cxd2820r_read_ber_t2(struct dvb_frontend *fe, u32 *ber) | ||
391 | { | ||
392 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
393 | int ret; | ||
394 | u8 buf[4]; | ||
395 | unsigned int errbits; | ||
396 | *ber = 0; | ||
397 | /* FIXME: correct calculation */ | ||
398 | |||
399 | ret = cxd2820r_rd_regs(priv, 0x02039, buf, sizeof(buf)); | ||
400 | if (ret) | ||
401 | goto error; | ||
402 | |||
403 | if ((buf[0] >> 4) & 0x01) { | ||
404 | errbits = (buf[0] & 0x0f) << 24 | buf[1] << 16 | | ||
405 | buf[2] << 8 | buf[3]; | ||
406 | |||
407 | if (errbits) | ||
408 | *ber = errbits * 64 / 16588800; | ||
409 | } | ||
410 | |||
411 | return ret; | ||
412 | error: | ||
413 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
414 | return ret; | ||
415 | } | ||
416 | |||
417 | int cxd2820r_read_signal_strength_t2(struct dvb_frontend *fe, | ||
418 | u16 *strength) | ||
419 | { | ||
420 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
421 | int ret; | ||
422 | u8 buf[2]; | ||
423 | u16 tmp; | ||
424 | |||
425 | ret = cxd2820r_rd_regs(priv, 0x02026, buf, sizeof(buf)); | ||
426 | if (ret) | ||
427 | goto error; | ||
428 | |||
429 | tmp = (buf[0] & 0x0f) << 8 | buf[1]; | ||
430 | tmp = ~tmp & 0x0fff; | ||
431 | |||
432 | /* scale value to 0x0000-0xffff from 0x0000-0x0fff */ | ||
433 | *strength = tmp * 0xffff / 0x0fff; | ||
434 | |||
435 | return ret; | ||
436 | error: | ||
437 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
438 | return ret; | ||
439 | } | ||
440 | |||
441 | int cxd2820r_read_snr_t2(struct dvb_frontend *fe, u16 *snr) | ||
442 | { | ||
443 | struct cxd2820r_priv *priv = fe->demodulator_priv; | ||
444 | int ret; | ||
445 | u8 buf[2]; | ||
446 | u16 tmp; | ||
447 | /* report SNR in dB * 10 */ | ||
448 | |||
449 | ret = cxd2820r_rd_regs(priv, 0x02028, buf, sizeof(buf)); | ||
450 | if (ret) | ||
451 | goto error; | ||
452 | |||
453 | tmp = (buf[0] & 0x0f) << 8 | buf[1]; | ||
454 | #define CXD2820R_LOG10_8_24 15151336 /* log10(8) << 24 */ | ||
455 | if (tmp) | ||
456 | *snr = (intlog10(tmp) - CXD2820R_LOG10_8_24) / ((1 << 24) | ||
457 | / 100); | ||
458 | else | ||
459 | *snr = 0; | ||
460 | |||
461 | dev_dbg(&priv->i2c->dev, "%s: dBx10=%d val=%04x\n", __func__, *snr, | ||
462 | tmp); | ||
463 | |||
464 | return ret; | ||
465 | error: | ||
466 | dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret); | ||
467 | return ret; | ||
468 | } | ||
469 | |||
470 | int cxd2820r_read_ucblocks_t2(struct dvb_frontend *fe, u32 *ucblocks) | ||
471 | { | ||
472 | *ucblocks = 0; | ||
473 | /* no way to read ? */ | ||
474 | return 0; | ||
475 | } | ||
476 | |||
477 | int cxd2820r_sleep_t2(struct dvb_frontend *fe) | 390 | int cxd2820r_sleep_t2(struct dvb_frontend *fe) |
478 | { | 391 | { |
479 | struct cxd2820r_priv *priv = fe->demodulator_priv; | 392 | struct cxd2820r_priv *priv = fe->demodulator_priv; |