2019-05-31 08:09:32 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-10-18 11:34:16 +00:00
|
|
|
/*
|
|
|
|
* Linux-DVB Driver for DiBcom's second generation DiB7000P (PC).
|
|
|
|
*
|
2007-07-27 13:08:51 +00:00
|
|
|
* Copyright (C) 2005-7 DiBcom (http://www.dibcom.fr/)
|
2006-10-18 11:34:16 +00:00
|
|
|
*/
|
2016-10-14 12:35:33 +00:00
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
#include <linux/kernel.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2006-10-18 11:34:16 +00:00
|
|
|
#include <linux/i2c.h>
|
2011-08-03 15:08:21 +00:00
|
|
|
#include <linux/mutex.h>
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
#include <asm/div64.h>
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2017-12-28 18:03:51 +00:00
|
|
|
#include <media/dvb_math.h>
|
|
|
|
#include <media/dvb_frontend.h>
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
#include "dib7000p.h"
|
|
|
|
|
|
|
|
static int debug;
|
|
|
|
module_param(debug, int, 0644);
|
|
|
|
MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
|
|
|
|
|
2007-07-31 10:09:30 +00:00
|
|
|
static int buggy_sfn_workaround;
|
|
|
|
module_param(buggy_sfn_workaround, int, 0644);
|
2007-07-31 13:36:06 +00:00
|
|
|
MODULE_PARM_DESC(buggy_sfn_workaround, "Enable work-around for buggy SFNs (default: 0)");
|
2007-07-31 10:09:30 +00:00
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
#define dprintk(fmt, arg...) do { \
|
|
|
|
if (debug) \
|
|
|
|
printk(KERN_DEBUG pr_fmt("%s: " fmt), \
|
|
|
|
__func__, ##arg); \
|
|
|
|
} while (0)
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
struct i2c_device {
|
|
|
|
struct i2c_adapter *i2c_adap;
|
|
|
|
u8 i2c_addr;
|
|
|
|
};
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
struct dib7000p_state {
|
|
|
|
struct dvb_frontend demod;
|
2011-01-04 07:54:31 +00:00
|
|
|
struct dib7000p_config cfg;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
u8 i2c_addr;
|
2011-01-04 07:54:31 +00:00
|
|
|
struct i2c_adapter *i2c_adap;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
struct dibx000_i2c_master i2c_master;
|
|
|
|
|
|
|
|
u16 wbd_ref;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
u8 current_band;
|
2008-01-25 10:31:58 +00:00
|
|
|
u32 current_bandwidth;
|
2006-10-18 11:34:16 +00:00
|
|
|
struct dibx000_agc_config *current_agc;
|
|
|
|
u32 timf;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
u8 div_force_off:1;
|
|
|
|
u8 div_state:1;
|
2007-07-30 15:49:04 +00:00
|
|
|
u16 div_sync_wait;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
u8 agc_state;
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
u16 gpio_dir;
|
|
|
|
u16 gpio_val;
|
2007-07-31 10:09:30 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
u8 sfn_workaround_active:1;
|
|
|
|
|
|
|
|
#define SOC7090 0x7090
|
|
|
|
u16 version;
|
|
|
|
|
|
|
|
u16 tuner_enable;
|
|
|
|
struct i2c_adapter dib7090_tuner_adap;
|
2011-05-03 15:27:33 +00:00
|
|
|
|
|
|
|
/* for the I2C transfer */
|
|
|
|
struct i2c_msg msg[2];
|
|
|
|
u8 i2c_write_buffer[4];
|
|
|
|
u8 i2c_read_buffer[2];
|
2011-08-03 15:08:21 +00:00
|
|
|
struct mutex i2c_buffer_lock;
|
2011-08-05 13:39:15 +00:00
|
|
|
|
|
|
|
u8 input_mode_mpeg;
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
|
|
|
|
/* for DVBv5 stats */
|
|
|
|
s64 old_ucb;
|
|
|
|
unsigned long per_jiffies_stats;
|
|
|
|
unsigned long ber_jiffies_stats;
|
|
|
|
unsigned long get_stats_time;
|
2006-10-18 11:34:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum dib7000p_power_mode {
|
|
|
|
DIB7000P_POWER_ALL = 0,
|
2007-07-27 13:08:51 +00:00
|
|
|
DIB7000P_POWER_ANALOG_ADC,
|
2006-10-18 11:34:16 +00:00
|
|
|
DIB7000P_POWER_INTERFACE_ONLY,
|
|
|
|
};
|
|
|
|
|
2019-02-18 19:28:55 +00:00
|
|
|
/* dib7090 specific functions */
|
2011-01-04 07:54:31 +00:00
|
|
|
static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode);
|
|
|
|
static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff);
|
2011-08-05 13:39:15 +00:00
|
|
|
static void dib7090_setDibTxMux(struct dib7000p_state *state, int mode);
|
|
|
|
static void dib7090_setHostBusMux(struct dib7000p_state *state, int mode);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static u16 dib7000p_read_word(struct dib7000p_state *state, u16 reg)
|
|
|
|
{
|
2011-08-03 15:08:21 +00:00
|
|
|
u16 ret;
|
|
|
|
|
|
|
|
if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("could not acquire lock\n");
|
2011-08-03 15:08:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-03 15:27:33 +00:00
|
|
|
state->i2c_write_buffer[0] = reg >> 8;
|
|
|
|
state->i2c_write_buffer[1] = reg & 0xff;
|
|
|
|
|
|
|
|
memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
|
|
|
|
state->msg[0].addr = state->i2c_addr >> 1;
|
|
|
|
state->msg[0].flags = 0;
|
|
|
|
state->msg[0].buf = state->i2c_write_buffer;
|
|
|
|
state->msg[0].len = 2;
|
|
|
|
state->msg[1].addr = state->i2c_addr >> 1;
|
|
|
|
state->msg[1].flags = I2C_M_RD;
|
|
|
|
state->msg[1].buf = state->i2c_read_buffer;
|
|
|
|
state->msg[1].len = 2;
|
|
|
|
|
|
|
|
if (i2c_transfer(state->i2c_adap, state->msg, 2) != 2)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("i2c read error on %d\n", reg);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-08-03 15:08:21 +00:00
|
|
|
ret = (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
|
|
|
|
mutex_unlock(&state->i2c_buffer_lock);
|
|
|
|
return ret;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_write_word(struct dib7000p_state *state, u16 reg, u16 val)
|
|
|
|
{
|
2011-08-03 15:08:21 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("could not acquire lock\n");
|
2011-08-03 15:08:21 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-05-03 15:27:33 +00:00
|
|
|
state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
|
|
|
|
state->i2c_write_buffer[1] = reg & 0xff;
|
|
|
|
state->i2c_write_buffer[2] = (val >> 8) & 0xff;
|
|
|
|
state->i2c_write_buffer[3] = val & 0xff;
|
|
|
|
|
|
|
|
memset(&state->msg[0], 0, sizeof(struct i2c_msg));
|
|
|
|
state->msg[0].addr = state->i2c_addr >> 1;
|
|
|
|
state->msg[0].flags = 0;
|
|
|
|
state->msg[0].buf = state->i2c_write_buffer;
|
|
|
|
state->msg[0].len = 4;
|
|
|
|
|
2011-08-03 15:08:21 +00:00
|
|
|
ret = (i2c_transfer(state->i2c_adap, state->msg, 1) != 1 ?
|
|
|
|
-EREMOTEIO : 0);
|
|
|
|
mutex_unlock(&state->i2c_buffer_lock);
|
|
|
|
return ret;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
static void dib7000p_write_tab(struct dib7000p_state *state, u16 * buf)
|
2007-07-27 13:08:51 +00:00
|
|
|
{
|
|
|
|
u16 l = 0, r, *n;
|
|
|
|
n = buf;
|
|
|
|
l = *n++;
|
|
|
|
while (l) {
|
|
|
|
r = *n++;
|
|
|
|
|
|
|
|
do {
|
|
|
|
dib7000p_write_word(state, r, *n++);
|
|
|
|
r++;
|
|
|
|
} while (--l);
|
|
|
|
l = *n++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static int dib7000p_set_output_mode(struct dib7000p_state *state, int mode)
|
|
|
|
{
|
2011-01-04 07:54:31 +00:00
|
|
|
int ret = 0;
|
2006-10-18 11:34:16 +00:00
|
|
|
u16 outreg, fifo_threshold, smo_mode;
|
|
|
|
|
|
|
|
outreg = 0;
|
|
|
|
fifo_threshold = 1792;
|
2009-09-23 16:41:27 +00:00
|
|
|
smo_mode = (dib7000p_read_word(state, 235) & 0x0050) | (1 << 1);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode for demod %p to %d\n", &state->demod, mode);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
switch (mode) {
|
2011-01-04 16:08:14 +00:00
|
|
|
case OUTMODE_MPEG2_PAR_GATED_CLK:
|
2011-01-04 07:54:31 +00:00
|
|
|
outreg = (1 << 10); /* 0x0400 */
|
|
|
|
break;
|
2011-01-04 16:08:14 +00:00
|
|
|
case OUTMODE_MPEG2_PAR_CONT_CLK:
|
2011-01-04 07:54:31 +00:00
|
|
|
outreg = (1 << 10) | (1 << 6); /* 0x0440 */
|
|
|
|
break;
|
2011-01-04 16:08:14 +00:00
|
|
|
case OUTMODE_MPEG2_SERIAL:
|
2011-01-04 07:54:31 +00:00
|
|
|
outreg = (1 << 10) | (2 << 6) | (0 << 1); /* 0x0480 */
|
|
|
|
break;
|
|
|
|
case OUTMODE_DIVERSITY:
|
|
|
|
if (state->cfg.hostbus_diversity)
|
|
|
|
outreg = (1 << 10) | (4 << 6); /* 0x0500 */
|
|
|
|
else
|
|
|
|
outreg = (1 << 11);
|
|
|
|
break;
|
2011-01-04 16:08:14 +00:00
|
|
|
case OUTMODE_MPEG2_FIFO:
|
2011-01-04 07:54:31 +00:00
|
|
|
smo_mode |= (3 << 1);
|
|
|
|
fifo_threshold = 512;
|
|
|
|
outreg = (1 << 10) | (5 << 6);
|
|
|
|
break;
|
|
|
|
case OUTMODE_ANALOG_ADC:
|
|
|
|
outreg = (1 << 10) | (3 << 6);
|
|
|
|
break;
|
2011-01-04 16:08:14 +00:00
|
|
|
case OUTMODE_HIGH_Z:
|
2011-01-04 07:54:31 +00:00
|
|
|
outreg = 0;
|
|
|
|
break;
|
|
|
|
default:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Unhandled output_mode passed to be set for demod %p\n", &state->demod);
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (state->cfg.output_mpeg2_in_188_bytes)
|
2011-01-04 07:54:31 +00:00
|
|
|
smo_mode |= (1 << 5);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
ret |= dib7000p_write_word(state, 235, smo_mode);
|
|
|
|
ret |= dib7000p_write_word(state, 236, fifo_threshold); /* synchronous fread */
|
|
|
|
if (state->version != SOC7090)
|
|
|
|
ret |= dib7000p_write_word(state, 1286, outreg); /* P_Div_active */
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static int dib7000p_set_diversity_in(struct dvb_frontend *demod, int onoff)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
|
|
|
|
if (state->div_force_off) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("diversity combination deactivated - forced by COFDM parameters\n");
|
2007-07-27 13:08:51 +00:00
|
|
|
onoff = 0;
|
2009-09-23 16:41:27 +00:00
|
|
|
dib7000p_write_word(state, 207, 0);
|
|
|
|
} else
|
|
|
|
dib7000p_write_word(state, 207, (state->div_sync_wait << 4) | (1 << 2) | (2 << 0));
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
state->div_state = (u8) onoff;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
if (onoff) {
|
|
|
|
dib7000p_write_word(state, 204, 6);
|
|
|
|
dib7000p_write_word(state, 205, 16);
|
|
|
|
/* P_dvsy_sync_mode = 0, P_dvsy_sync_enable=1, P_dvcb_comb_mode=2 */
|
|
|
|
} else {
|
|
|
|
dib7000p_write_word(state, 204, 1);
|
|
|
|
dib7000p_write_word(state, 205, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static int dib7000p_set_power_mode(struct dib7000p_state *state, enum dib7000p_power_mode mode)
|
|
|
|
{
|
|
|
|
/* by default everything is powered off */
|
2011-01-04 07:54:31 +00:00
|
|
|
u16 reg_774 = 0x3fff, reg_775 = 0xffff, reg_776 = 0x0007, reg_899 = 0x0003, reg_1280 = (0xfe00) | (dib7000p_read_word(state, 1280) & 0x01ff);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* now, depending on the requested mode, we power on */
|
|
|
|
switch (mode) {
|
|
|
|
/* power up everything in the demod */
|
2011-01-04 07:54:31 +00:00
|
|
|
case DIB7000P_POWER_ALL:
|
|
|
|
reg_774 = 0x0000;
|
|
|
|
reg_775 = 0x0000;
|
|
|
|
reg_776 = 0x0;
|
|
|
|
reg_899 = 0x0;
|
|
|
|
if (state->version == SOC7090)
|
|
|
|
reg_1280 &= 0x001f;
|
|
|
|
else
|
|
|
|
reg_1280 &= 0x01ff;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DIB7000P_POWER_ANALOG_ADC:
|
|
|
|
/* dem, cfg, iqc, sad, agc */
|
|
|
|
reg_774 &= ~((1 << 15) | (1 << 14) | (1 << 11) | (1 << 10) | (1 << 9));
|
|
|
|
/* nud */
|
|
|
|
reg_776 &= ~((1 << 0));
|
|
|
|
/* Dout */
|
|
|
|
if (state->version != SOC7090)
|
2007-07-27 13:08:51 +00:00
|
|
|
reg_1280 &= ~((1 << 11));
|
2011-01-04 07:54:31 +00:00
|
|
|
reg_1280 &= ~(1 << 6);
|
2020-08-23 22:36:59 +00:00
|
|
|
fallthrough;
|
2017-05-18 11:13:28 +00:00
|
|
|
case DIB7000P_POWER_INTERFACE_ONLY:
|
2006-10-18 11:34:16 +00:00
|
|
|
/* just leave power on the control-interfaces: GPIO and (I2C or SDIO) */
|
2017-05-18 11:13:28 +00:00
|
|
|
/* TODO power up either SDIO or I2C */
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->version == SOC7090)
|
|
|
|
reg_1280 &= ~((1 << 7) | (1 << 5));
|
|
|
|
else
|
2006-10-18 11:34:16 +00:00
|
|
|
reg_1280 &= ~((1 << 14) | (1 << 13) | (1 << 12) | (1 << 10));
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
/* TODO following stuff is just converted from the dib7000-driver - check when is used what */
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 774, reg_774);
|
|
|
|
dib7000p_write_word(state, 775, reg_775);
|
|
|
|
dib7000p_write_word(state, 776, reg_776);
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_write_word(state, 1280, reg_1280);
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version != SOC7090)
|
|
|
|
dib7000p_write_word(state, 899, reg_899);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dib7000p_set_adc_state(struct dib7000p_state *state, enum dibx000_adc_states no)
|
|
|
|
{
|
2011-08-05 13:39:15 +00:00
|
|
|
u16 reg_908 = 0, reg_909 = 0;
|
2011-01-04 07:54:31 +00:00
|
|
|
u16 reg;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version != SOC7090) {
|
|
|
|
reg_908 = dib7000p_read_word(state, 908);
|
|
|
|
reg_909 = dib7000p_read_word(state, 909);
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
switch (no) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case DIBX000_SLOW_ADC_ON:
|
|
|
|
if (state->version == SOC7090) {
|
|
|
|
reg = dib7000p_read_word(state, 1925);
|
|
|
|
|
|
|
|
dib7000p_write_word(state, 1925, reg | (1 << 4) | (1 << 2)); /* en_slowAdc = 1 & reset_sladc = 1 */
|
|
|
|
|
2019-02-18 19:28:55 +00:00
|
|
|
reg = dib7000p_read_word(state, 1925); /* read access to make it works... strange ... */
|
2011-01-04 07:54:31 +00:00
|
|
|
msleep(200);
|
|
|
|
dib7000p_write_word(state, 1925, reg & ~(1 << 4)); /* en_slowAdc = 1 & reset_sladc = 0 */
|
|
|
|
|
|
|
|
reg = dib7000p_read_word(state, 72) & ~((0x3 << 14) | (0x3 << 12));
|
|
|
|
dib7000p_write_word(state, 72, reg | (1 << 14) | (3 << 12) | 524); /* ref = Vin1 => Vbg ; sel = Vin0 or Vin3 ; (Vin2 = Vcm) */
|
|
|
|
} else {
|
2006-10-18 11:34:16 +00:00
|
|
|
reg_909 |= (1 << 1) | (1 << 0);
|
|
|
|
dib7000p_write_word(state, 909, reg_909);
|
|
|
|
reg_909 &= ~(1 << 1);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case DIBX000_SLOW_ADC_OFF:
|
|
|
|
if (state->version == SOC7090) {
|
|
|
|
reg = dib7000p_read_word(state, 1925);
|
|
|
|
dib7000p_write_word(state, 1925, (reg & ~(1 << 2)) | (1 << 4)); /* reset_sladc = 1 en_slowAdc = 0 */
|
|
|
|
} else
|
|
|
|
reg_909 |= (1 << 1) | (1 << 0);
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case DIBX000_ADC_ON:
|
|
|
|
reg_908 &= 0x0fff;
|
|
|
|
reg_909 &= 0x0003;
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
case DIBX000_ADC_OFF:
|
2011-01-04 07:54:31 +00:00
|
|
|
reg_908 |= (1 << 14) | (1 << 13) | (1 << 12);
|
|
|
|
reg_909 |= (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2);
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case DIBX000_VBG_ENABLE:
|
|
|
|
reg_908 &= ~(1 << 15);
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case DIBX000_VBG_DISABLE:
|
|
|
|
reg_908 |= (1 << 15);
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
default:
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
// dprintk( "908: %x, 909: %x\n", reg_908, reg_909);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2010-09-07 15:50:46 +00:00
|
|
|
reg_909 |= (state->cfg.disable_sample_and_hold & 1) << 4;
|
2010-09-07 15:50:45 +00:00
|
|
|
reg_908 |= (state->cfg.enable_current_mirror & 1) << 7;
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version != SOC7090) {
|
|
|
|
dib7000p_write_word(state, 908, reg_908);
|
|
|
|
dib7000p_write_word(state, 909, reg_909);
|
|
|
|
}
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static int dib7000p_set_bandwidth(struct dib7000p_state *state, u32 bw)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
u32 timf;
|
|
|
|
|
|
|
|
// store the current bandwidth for later use
|
2007-07-27 13:08:51 +00:00
|
|
|
state->current_bandwidth = bw;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
if (state->timf == 0) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("using default timf\n");
|
2006-10-18 11:34:16 +00:00
|
|
|
timf = state->cfg.bw->timf;
|
|
|
|
} else {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("using updated timf\n");
|
2006-10-18 11:34:16 +00:00
|
|
|
timf = state->timf;
|
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
timf = timf * (bw / 50) / 160;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_write_word(state, 23, (u16) ((timf >> 16) & 0xffff));
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 24, (u16) ((timf) & 0xffff));
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_sad_calib(struct dib7000p_state *state)
|
|
|
|
{
|
|
|
|
/* internal */
|
|
|
|
dib7000p_write_word(state, 73, (0 << 1) | (0 << 0));
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
if (state->version == SOC7090)
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 74, 2048);
|
2011-01-04 07:54:31 +00:00
|
|
|
else
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 74, 776);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* do the calibration */
|
|
|
|
dib7000p_write_word(state, 73, (1 << 0));
|
|
|
|
dib7000p_write_word(state, 73, (0 << 0));
|
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_set_wbd_ref(struct dvb_frontend *demod, u16 value)
|
2007-07-30 15:49:04 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
if (value > 4095)
|
|
|
|
value = 4095;
|
|
|
|
state->wbd_ref = value;
|
|
|
|
return dib7000p_write_word(state, 105, (dib7000p_read_word(state, 105) & 0xf000) | value);
|
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_get_agc_values(struct dvb_frontend *fe,
|
2011-08-05 16:49:33 +00:00
|
|
|
u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
|
|
|
|
if (agc_global != NULL)
|
|
|
|
*agc_global = dib7000p_read_word(state, 394);
|
|
|
|
if (agc1 != NULL)
|
|
|
|
*agc1 = dib7000p_read_word(state, 392);
|
|
|
|
if (agc2 != NULL)
|
|
|
|
*agc2 = dib7000p_read_word(state, 393);
|
|
|
|
if (wbd != NULL)
|
|
|
|
*wbd = dib7000p_read_word(state, 397);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v)
|
2012-12-31 12:23:26 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
return dib7000p_write_word(state, 108, v);
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static void dib7000p_reset_pll(struct dib7000p_state *state)
|
|
|
|
{
|
|
|
|
struct dibx000_bandwidth_config *bw = &state->cfg.bw[0];
|
2007-07-27 13:08:51 +00:00
|
|
|
u16 clk_cfg0;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->version == SOC7090) {
|
|
|
|
dib7000p_write_word(state, 1856, (!bw->pll_reset << 13) | (bw->pll_range << 12) | (bw->pll_ratio << 6) | (bw->pll_prediv));
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
while (((dib7000p_read_word(state, 1856) >> 15) & 0x1) != 1)
|
|
|
|
;
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
dib7000p_write_word(state, 1857, dib7000p_read_word(state, 1857) | (!bw->pll_bypass << 15));
|
|
|
|
} else {
|
|
|
|
/* force PLL bypass */
|
|
|
|
clk_cfg0 = (1 << 15) | ((bw->pll_ratio & 0x3f) << 9) |
|
|
|
|
(bw->modulo << 7) | (bw->ADClkSrc << 6) | (bw->IO_CLK_en_core << 5) | (bw->bypclk_div << 2) | (bw->enable_refdiv << 1) | (0 << 0);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 900, clk_cfg0);
|
|
|
|
|
|
|
|
/* P_pll_cfg */
|
|
|
|
dib7000p_write_word(state, 903, (bw->pll_prediv << 5) | (((bw->pll_ratio >> 6) & 0x3) << 3) | (bw->pll_range << 1) | bw->pll_reset);
|
|
|
|
clk_cfg0 = (bw->pll_bypass << 15) | (clk_cfg0 & 0x7fff);
|
|
|
|
dib7000p_write_word(state, 900, clk_cfg0);
|
|
|
|
}
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 18, (u16) (((bw->internal * 1000) >> 16) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 19, (u16) ((bw->internal * 1000) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 21, (u16) ((bw->ifreq >> 16) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 22, (u16) ((bw->ifreq) & 0xffff));
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
dib7000p_write_word(state, 72, bw->sad_cfg);
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static u32 dib7000p_get_internal_freq(struct dib7000p_state *state)
|
|
|
|
{
|
|
|
|
u32 internal = (u32) dib7000p_read_word(state, 18) << 16;
|
|
|
|
internal |= (u32) dib7000p_read_word(state, 19);
|
|
|
|
internal /= 1000;
|
|
|
|
|
|
|
|
return internal;
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 reg_1857, reg_1856 = dib7000p_read_word(state, 1856);
|
|
|
|
u8 loopdiv, prediv;
|
|
|
|
u32 internal, xtal;
|
|
|
|
|
|
|
|
/* get back old values */
|
|
|
|
prediv = reg_1856 & 0x3f;
|
|
|
|
loopdiv = (reg_1856 >> 6) & 0x3f;
|
|
|
|
|
|
|
|
if ((bw != NULL) && (bw->pll_prediv != prediv || bw->pll_ratio != loopdiv)) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Updating pll (prediv: old = %d new = %d ; loopdiv : old = %d new = %d)\n", prediv, bw->pll_prediv, loopdiv, bw->pll_ratio);
|
2011-01-04 07:54:31 +00:00
|
|
|
reg_1856 &= 0xf000;
|
|
|
|
reg_1857 = dib7000p_read_word(state, 1857);
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 1857, reg_1857 & ~(1 << 15));
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
dib7000p_write_word(state, 1856, reg_1856 | ((bw->pll_ratio & 0x3f) << 6) | (bw->pll_prediv & 0x3f));
|
|
|
|
|
|
|
|
/* write new system clk into P_sec_len */
|
|
|
|
internal = dib7000p_get_internal_freq(state);
|
|
|
|
xtal = (internal / loopdiv) * prediv;
|
|
|
|
internal = 1000 * (xtal / bw->pll_prediv) * bw->pll_ratio; /* new internal */
|
|
|
|
dib7000p_write_word(state, 18, (u16) ((internal >> 16) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 19, (u16) (internal & 0xffff));
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 1857, reg_1857 | (1 << 15));
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
while (((dib7000p_read_word(state, 1856) >> 15) & 0x1) != 1)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Waiting for PLL to lock\n");
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static int dib7000p_reset_gpio(struct dib7000p_state *st)
|
|
|
|
{
|
|
|
|
/* reset the GPIOs */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("gpio dir: %x: val: %x, pwm_pos: %x\n", st->gpio_dir, st->gpio_val, st->cfg.gpio_pwm_pos);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
dib7000p_write_word(st, 1029, st->gpio_dir);
|
|
|
|
dib7000p_write_word(st, 1030, st->gpio_val);
|
|
|
|
|
|
|
|
/* TODO 1031 is P_gpio_od */
|
|
|
|
|
|
|
|
dib7000p_write_word(st, 1032, st->cfg.gpio_pwm_pos);
|
|
|
|
|
|
|
|
dib7000p_write_word(st, 1037, st->cfg.pwm_freq_div);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-30 15:49:04 +00:00
|
|
|
static int dib7000p_cfg_gpio(struct dib7000p_state *st, u8 num, u8 dir, u8 val)
|
|
|
|
{
|
|
|
|
st->gpio_dir = dib7000p_read_word(st, 1029);
|
2011-01-04 07:54:31 +00:00
|
|
|
st->gpio_dir &= ~(1 << num); /* reset the direction bit */
|
|
|
|
st->gpio_dir |= (dir & 0x1) << num; /* set the new direction */
|
2007-07-30 15:49:04 +00:00
|
|
|
dib7000p_write_word(st, 1029, st->gpio_dir);
|
|
|
|
|
|
|
|
st->gpio_val = dib7000p_read_word(st, 1030);
|
2011-01-04 07:54:31 +00:00
|
|
|
st->gpio_val &= ~(1 << num); /* reset the direction bit */
|
|
|
|
st->gpio_val |= (val & 0x01) << num; /* set the new value */
|
2007-07-30 15:49:04 +00:00
|
|
|
dib7000p_write_word(st, 1030, st->gpio_val);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_set_gpio(struct dvb_frontend *demod, u8 num, u8 dir, u8 val)
|
2007-07-30 15:49:04 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
return dib7000p_cfg_gpio(state, num, dir, val);
|
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static u16 dib7000p_defaults[] = {
|
2007-07-27 13:08:51 +00:00
|
|
|
// auto search configuration
|
|
|
|
3, 2,
|
2011-01-04 07:54:31 +00:00
|
|
|
0x0004,
|
2011-08-05 13:39:15 +00:00
|
|
|
(1<<3)|(1<<11)|(1<<12)|(1<<13),
|
2011-01-04 07:54:31 +00:00
|
|
|
0x0814, /* Equal Lock */
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
12, 6,
|
2011-01-04 07:54:31 +00:00
|
|
|
0x001b,
|
|
|
|
0x7740,
|
|
|
|
0x005b,
|
|
|
|
0x8d80,
|
|
|
|
0x01c9,
|
|
|
|
0xc380,
|
|
|
|
0x0000,
|
|
|
|
0x0080,
|
|
|
|
0x0000,
|
|
|
|
0x0090,
|
|
|
|
0x0001,
|
|
|
|
0xd4c0,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 26,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x6680,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
/* set ADC level to -16 */
|
|
|
|
11, 79,
|
2011-01-04 07:54:31 +00:00
|
|
|
(1 << 13) - 825 - 117,
|
|
|
|
(1 << 13) - 837 - 117,
|
|
|
|
(1 << 13) - 811 - 117,
|
|
|
|
(1 << 13) - 766 - 117,
|
|
|
|
(1 << 13) - 737 - 117,
|
|
|
|
(1 << 13) - 693 - 117,
|
|
|
|
(1 << 13) - 648 - 117,
|
|
|
|
(1 << 13) - 619 - 117,
|
|
|
|
(1 << 13) - 575 - 117,
|
|
|
|
(1 << 13) - 531 - 117,
|
|
|
|
(1 << 13) - 501 - 117,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 142,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x0410,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
/* disable power smoothing */
|
|
|
|
8, 145,
|
2011-01-04 07:54:31 +00:00
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 154,
|
2011-01-04 16:08:14 +00:00
|
|
|
1 << 13,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 168,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x0ccd,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 183,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x200f,
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
1, 212,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x169,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
5, 187,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x023d,
|
|
|
|
0x00a4,
|
|
|
|
0x00a4,
|
|
|
|
0x7ff0,
|
|
|
|
0x3ccc,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 198,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x800,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 222,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x0010,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
1, 235,
|
2011-01-04 16:08:14 +00:00
|
|
|
0x0062,
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
0,
|
|
|
|
};
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
static void dib7000p_reset_stats(struct dvb_frontend *fe);
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static int dib7000p_demod_reset(struct dib7000p_state *state)
|
|
|
|
{
|
|
|
|
dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->version == SOC7090)
|
|
|
|
dibx000_reset_i2c_master(&state->i2c_master);
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_set_adc_state(state, DIBX000_VBG_ENABLE);
|
|
|
|
|
|
|
|
/* restart all parts */
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 770, 0xffff);
|
|
|
|
dib7000p_write_word(state, 771, 0xffff);
|
|
|
|
dib7000p_write_word(state, 772, 0x001f);
|
|
|
|
dib7000p_write_word(state, 1280, 0x001f - ((1 << 4) | (1 << 3)));
|
|
|
|
|
|
|
|
dib7000p_write_word(state, 770, 0);
|
|
|
|
dib7000p_write_word(state, 771, 0);
|
|
|
|
dib7000p_write_word(state, 772, 0);
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_write_word(state, 1280, 0);
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version != SOC7090) {
|
|
|
|
dib7000p_write_word(state, 898, 0x0003);
|
|
|
|
dib7000p_write_word(state, 898, 0);
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
/* default */
|
|
|
|
dib7000p_reset_pll(state);
|
|
|
|
|
|
|
|
if (dib7000p_reset_gpio(state) != 0)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("GPIO reset was not successful.\n");
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->version == SOC7090) {
|
|
|
|
dib7000p_write_word(state, 899, 0);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
/* impulse noise */
|
|
|
|
dib7000p_write_word(state, 42, (1<<5) | 3); /* P_iqc_thsat_ipc = 1 ; P_iqc_win2 = 3 */
|
|
|
|
dib7000p_write_word(state, 43, 0x2d4); /*-300 fag P_iqc_dect_min = -280 */
|
|
|
|
dib7000p_write_word(state, 44, 300); /* 300 fag P_iqc_dect_min = +280 */
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7000p_write_word(state, 273, (0<<6) | 30);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
if (dib7000p_set_output_mode(state, OUTMODE_HIGH_Z) != 0)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("OUTPUT_MODE could not be reset.\n");
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_ON);
|
|
|
|
dib7000p_sad_calib(state);
|
|
|
|
dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_OFF);
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
/* unforce divstr regardless whether i2c enumeration was done or not */
|
|
|
|
dib7000p_write_word(state, 1285, dib7000p_read_word(state, 1285) & ~(1 << 1));
|
|
|
|
|
|
|
|
dib7000p_set_bandwidth(state, 8000);
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
if (state->version == SOC7090) {
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7000p_write_word(state, 36, 0x0755);/* P_iqc_impnc_on =1 & P_iqc_corr_inh = 1 for impulsive noise */
|
2011-01-04 16:08:14 +00:00
|
|
|
} else {
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->cfg.tuner_is_baseband)
|
|
|
|
dib7000p_write_word(state, 36, 0x0755);
|
|
|
|
else
|
|
|
|
dib7000p_write_word(state, 36, 0x1f55);
|
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
dib7000p_write_tab(state, dib7000p_defaults);
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version != SOC7090) {
|
|
|
|
dib7000p_write_word(state, 901, 0x0006);
|
|
|
|
dib7000p_write_word(state, 902, (3 << 10) | (1 << 6));
|
|
|
|
dib7000p_write_word(state, 905, 0x2c8e);
|
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static void dib7000p_pll_clk_cfg(struct dib7000p_state *state)
|
|
|
|
{
|
|
|
|
u16 tmp = 0;
|
|
|
|
tmp = dib7000p_read_word(state, 903);
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 903, (tmp | 0x1));
|
2007-07-27 13:08:51 +00:00
|
|
|
tmp = dib7000p_read_word(state, 900);
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 900, (tmp & 0x7fff) | (1 << 6));
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
static void dib7000p_restart_agc(struct dib7000p_state *state)
|
|
|
|
{
|
|
|
|
// P_restart_iqc & P_restart_agc
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_write_word(state, 770, (1 << 11) | (1 << 9));
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_write_word(state, 770, 0x0000);
|
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static int dib7000p_update_lna(struct dib7000p_state *state)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
u16 dyn_gain;
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
if (state->cfg.update_lna) {
|
2006-10-18 11:34:16 +00:00
|
|
|
dyn_gain = dib7000p_read_word(state, 394);
|
2011-01-04 16:08:14 +00:00
|
|
|
if (state->cfg.update_lna(&state->demod, dyn_gain)) {
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_restart_agc(state);
|
2007-07-27 13:08:51 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_set_agc_config(struct dib7000p_state *state, u8 band)
|
|
|
|
{
|
|
|
|
struct dibx000_agc_config *agc = NULL;
|
|
|
|
int i;
|
|
|
|
if (state->current_band == band && state->current_agc != NULL)
|
|
|
|
return 0;
|
|
|
|
state->current_band = band;
|
|
|
|
|
|
|
|
for (i = 0; i < state->cfg.agc_config_count; i++)
|
|
|
|
if (state->cfg.agc[i].band_caps & band) {
|
|
|
|
agc = &state->cfg.agc[i];
|
2006-10-18 11:34:16 +00:00
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (agc == NULL) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("no valid AGC configuration found for band 0x%02x\n", band);
|
2007-07-27 13:08:51 +00:00
|
|
|
return -EINVAL;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
state->current_agc = agc;
|
|
|
|
|
|
|
|
/* AGC */
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 75, agc->setup);
|
|
|
|
dib7000p_write_word(state, 76, agc->inv_gain);
|
|
|
|
dib7000p_write_word(state, 77, agc->time_stabiliz);
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_write_word(state, 100, (agc->alpha_level << 12) | agc->thlock);
|
|
|
|
|
|
|
|
// Demod AGC loop configuration
|
|
|
|
dib7000p_write_word(state, 101, (agc->alpha_mant << 5) | agc->alpha_exp);
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 102, (agc->beta_mant << 6) | agc->beta_exp);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
/* AGC continued */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("WBD: ref: %d, sel: %d, active: %d, alpha: %d\n",
|
2007-07-27 13:08:51 +00:00
|
|
|
state->wbd_ref != 0 ? state->wbd_ref : agc->wbd_ref, agc->wbd_sel, !agc->perform_agc_softsplit, agc->wbd_sel);
|
|
|
|
|
|
|
|
if (state->wbd_ref != 0)
|
|
|
|
dib7000p_write_word(state, 105, (agc->wbd_inv << 12) | state->wbd_ref);
|
|
|
|
else
|
|
|
|
dib7000p_write_word(state, 105, (agc->wbd_inv << 12) | agc->wbd_ref);
|
|
|
|
|
|
|
|
dib7000p_write_word(state, 106, (agc->wbd_sel << 13) | (agc->wbd_alpha << 9) | (agc->perform_agc_softsplit << 8));
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 107, agc->agc1_max);
|
|
|
|
dib7000p_write_word(state, 108, agc->agc1_min);
|
|
|
|
dib7000p_write_word(state, 109, agc->agc2_max);
|
|
|
|
dib7000p_write_word(state, 110, agc->agc2_min);
|
|
|
|
dib7000p_write_word(state, 111, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
|
|
|
|
dib7000p_write_word(state, 112, agc->agc1_pt3);
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_write_word(state, 113, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 114, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_write_word(state, 115, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
|
|
|
|
return 0;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2016-12-13 20:21:41 +00:00
|
|
|
static int dib7000p_set_dds(struct dib7000p_state *state, s32 offset_khz)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
u32 internal = dib7000p_get_internal_freq(state);
|
2016-12-13 20:21:41 +00:00
|
|
|
s32 unit_khz_dds_val;
|
2017-12-25 21:16:14 +00:00
|
|
|
u32 abs_offset_khz = abs(offset_khz);
|
2011-01-04 07:54:31 +00:00
|
|
|
u32 dds = state->cfg.bw->ifreq & 0x1ffffff;
|
|
|
|
u8 invert = !!(state->cfg.bw->ifreq & (1 << 25));
|
2016-12-13 20:21:41 +00:00
|
|
|
if (internal == 0) {
|
|
|
|
pr_warn("DIB7000P: dib7000p_get_internal_freq returned 0\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* 2**26 / Fsampling is the unit 1KHz offset */
|
|
|
|
unit_khz_dds_val = 67108864 / (internal);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting a frequency offset of %dkHz internal freq = %d invert = %d\n", offset_khz, internal, invert);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
if (offset_khz < 0)
|
|
|
|
unit_khz_dds_val *= -1;
|
|
|
|
|
|
|
|
/* IF tuner */
|
|
|
|
if (invert)
|
|
|
|
dds -= (abs_offset_khz * unit_khz_dds_val); /* /100 because of /100 on the unit_khz_dds_val line calc for better accuracy */
|
|
|
|
else
|
|
|
|
dds += (abs_offset_khz * unit_khz_dds_val);
|
|
|
|
|
|
|
|
if (abs_offset_khz <= (internal / 2)) { /* Max dds offset is the half of the demod freq */
|
|
|
|
dib7000p_write_word(state, 21, (u16) (((dds >> 16) & 0x1ff) | (0 << 10) | (invert << 9)));
|
|
|
|
dib7000p_write_word(state, 22, (u16) (dds & 0xffff));
|
|
|
|
}
|
2016-12-13 20:21:41 +00:00
|
|
|
return 0;
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
static int dib7000p_agc_startup(struct dvb_frontend *demod)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2011-12-22 22:06:20 +00:00
|
|
|
struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
|
2007-07-27 13:08:51 +00:00
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
int ret = -1;
|
|
|
|
u8 *agc_state = &state->agc_state;
|
|
|
|
u8 agc_split;
|
2011-01-04 07:54:31 +00:00
|
|
|
u16 reg;
|
|
|
|
u32 upd_demod_gain_period = 0x1000;
|
2012-12-31 12:23:26 +00:00
|
|
|
s32 frequency_offset = 0;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
switch (state->agc_state) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case 0:
|
|
|
|
dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
|
|
|
|
if (state->version == SOC7090) {
|
|
|
|
reg = dib7000p_read_word(state, 0x79b) & 0xff00;
|
|
|
|
dib7000p_write_word(state, 0x79a, upd_demod_gain_period & 0xFFFF); /* lsb */
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 0x79b, reg | (1 << 14) | ((upd_demod_gain_period >> 16) & 0xFF));
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
/* enable adc i & q */
|
|
|
|
reg = dib7000p_read_word(state, 0x780);
|
|
|
|
dib7000p_write_word(state, 0x780, (reg | (0x3)) & (~(1 << 7)));
|
|
|
|
} else {
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_set_adc_state(state, DIBX000_ADC_ON);
|
|
|
|
dib7000p_pll_clk_cfg(state);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (dib7000p_set_agc_config(state, BAND_OF_FREQUENCY(ch->frequency / 1000)) != 0)
|
|
|
|
return -1;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2012-12-31 12:23:26 +00:00
|
|
|
if (demod->ops.tuner_ops.get_frequency) {
|
|
|
|
u32 frequency_tuner;
|
|
|
|
|
|
|
|
demod->ops.tuner_ops.get_frequency(demod, &frequency_tuner);
|
|
|
|
frequency_offset = (s32)frequency_tuner / 1000 - ch->frequency / 1000;
|
|
|
|
}
|
|
|
|
|
2016-12-13 20:21:41 +00:00
|
|
|
if (dib7000p_set_dds(state, frequency_offset) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
ret = 7;
|
|
|
|
(*agc_state)++;
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case 1:
|
|
|
|
if (state->cfg.agc_control)
|
|
|
|
state->cfg.agc_control(&state->demod, 1);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 78, 32768);
|
|
|
|
if (!state->current_agc->perform_agc_softsplit) {
|
|
|
|
/* we are using the wbd - so slow AGC startup */
|
|
|
|
/* force 0 split on WBD and restart AGC */
|
|
|
|
dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (state->current_agc->wbd_alpha << 9) | (1 << 8));
|
2007-07-27 13:08:51 +00:00
|
|
|
(*agc_state)++;
|
2011-01-04 07:54:31 +00:00
|
|
|
ret = 5;
|
|
|
|
} else {
|
|
|
|
/* default AGC startup */
|
|
|
|
(*agc_state) = 4;
|
|
|
|
/* wait AGC rough lock time */
|
|
|
|
ret = 7;
|
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_restart_agc(state);
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case 2: /* fast split search path after 5sec */
|
|
|
|
dib7000p_write_word(state, 75, state->current_agc->setup | (1 << 4)); /* freeze AGC loop */
|
|
|
|
dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (2 << 9) | (0 << 8)); /* fast split search 0.25kHz */
|
|
|
|
(*agc_state)++;
|
|
|
|
ret = 14;
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case 3: /* split search ended */
|
|
|
|
agc_split = (u8) dib7000p_read_word(state, 396); /* store the split value for the next time */
|
|
|
|
dib7000p_write_word(state, 78, dib7000p_read_word(state, 394)); /* set AGC gain start value */
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 75, state->current_agc->setup); /* std AGC loop */
|
|
|
|
dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (state->current_agc->wbd_alpha << 9) | agc_split); /* standard split search */
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_restart_agc(state);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2020-01-01 08:59:58 +00:00
|
|
|
dprintk("SPLIT %p: %u\n", demod, agc_split);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
(*agc_state)++;
|
|
|
|
ret = 5;
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
case 4: /* LNA startup */
|
|
|
|
ret = 7;
|
|
|
|
|
|
|
|
if (dib7000p_update_lna(state))
|
|
|
|
ret = 5;
|
2011-01-04 16:08:14 +00:00
|
|
|
else
|
2007-07-27 13:08:51 +00:00
|
|
|
(*agc_state)++;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
|
|
|
if (state->cfg.agc_control)
|
|
|
|
state->cfg.agc_control(&state->demod, 0);
|
|
|
|
(*agc_state)++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
return ret;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static void dib7000p_update_timf(struct dib7000p_state *state)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
u32 timf = (dib7000p_read_word(state, 427) << 16) | dib7000p_read_word(state, 428);
|
2007-07-27 13:08:51 +00:00
|
|
|
state->timf = timf * 160 / (state->current_bandwidth / 50);
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_write_word(state, 23, (u16) (timf >> 16));
|
|
|
|
dib7000p_write_word(state, 24, (u16) (timf & 0xffff));
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("updated timf_frequency: %d (default: %d)\n", state->timf, state->cfg.bw->timf);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
switch (op) {
|
|
|
|
case DEMOD_TIMF_SET:
|
|
|
|
state->timf = timf;
|
|
|
|
break;
|
|
|
|
case DEMOD_TIMF_UPDATE:
|
|
|
|
dib7000p_update_timf(state);
|
|
|
|
break;
|
|
|
|
case DEMOD_TIMF_GET:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dib7000p_set_bandwidth(state, state->current_bandwidth);
|
|
|
|
return state->timf;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
static void dib7000p_set_channel(struct dib7000p_state *state,
|
|
|
|
struct dtv_frontend_properties *ch, u8 seq)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2007-07-27 13:08:51 +00:00
|
|
|
u16 value, est[4];
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* nfft, guard, qam, alpha */
|
2007-07-27 13:08:51 +00:00
|
|
|
value = 0;
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->transmission_mode) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case TRANSMISSION_MODE_2K:
|
|
|
|
value |= (0 << 7);
|
|
|
|
break;
|
2011-01-16 15:01:20 +00:00
|
|
|
case TRANSMISSION_MODE_4K:
|
2011-01-04 07:54:31 +00:00
|
|
|
value |= (2 << 7);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case TRANSMISSION_MODE_8K:
|
|
|
|
value |= (1 << 7);
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->guard_interval) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case GUARD_INTERVAL_1_32:
|
|
|
|
value |= (0 << 5);
|
|
|
|
break;
|
|
|
|
case GUARD_INTERVAL_1_16:
|
|
|
|
value |= (1 << 5);
|
|
|
|
break;
|
|
|
|
case GUARD_INTERVAL_1_4:
|
|
|
|
value |= (3 << 5);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case GUARD_INTERVAL_1_8:
|
|
|
|
value |= (2 << 5);
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->modulation) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case QPSK:
|
|
|
|
value |= (0 << 3);
|
|
|
|
break;
|
|
|
|
case QAM_16:
|
|
|
|
value |= (1 << 3);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case QAM_64:
|
|
|
|
value |= (2 << 3);
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
switch (HIERARCHY_1) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case HIERARCHY_2:
|
|
|
|
value |= 2;
|
|
|
|
break;
|
|
|
|
case HIERARCHY_4:
|
|
|
|
value |= 4;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case HIERARCHY_1:
|
|
|
|
value |= 1;
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 0, value);
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 5, (seq << 4) | 1); /* do not force tps, search list 0 */
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
/* P_dintl_native, P_dintlv_inv, P_hrch, P_code_rate, P_select_hp */
|
|
|
|
value = 0;
|
|
|
|
if (1 != 0)
|
|
|
|
value |= (1 << 6);
|
2011-12-22 22:06:20 +00:00
|
|
|
if (ch->hierarchy == 1)
|
2007-07-27 13:08:51 +00:00
|
|
|
value |= (1 << 4);
|
|
|
|
if (1 == 1)
|
|
|
|
value |= 1;
|
2011-12-22 22:06:20 +00:00
|
|
|
switch ((ch->hierarchy == 0 || 1 == 1) ? ch->code_rate_HP : ch->code_rate_LP) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case FEC_2_3:
|
|
|
|
value |= (2 << 1);
|
|
|
|
break;
|
|
|
|
case FEC_3_4:
|
|
|
|
value |= (3 << 1);
|
|
|
|
break;
|
|
|
|
case FEC_5_6:
|
|
|
|
value |= (5 << 1);
|
|
|
|
break;
|
|
|
|
case FEC_7_8:
|
|
|
|
value |= (7 << 1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case FEC_1_2:
|
|
|
|
value |= (1 << 1);
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 208, value);
|
|
|
|
|
|
|
|
/* offset loop parameters */
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 26, 0x6680);
|
|
|
|
dib7000p_write_word(state, 32, 0x0003);
|
|
|
|
dib7000p_write_word(state, 29, 0x1273);
|
|
|
|
dib7000p_write_word(state, 33, 0x0005);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* P_dvsy_sync_wait */
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->transmission_mode) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case TRANSMISSION_MODE_8K:
|
|
|
|
value = 256;
|
|
|
|
break;
|
|
|
|
case TRANSMISSION_MODE_4K:
|
|
|
|
value = 128;
|
|
|
|
break;
|
|
|
|
case TRANSMISSION_MODE_2K:
|
|
|
|
default:
|
|
|
|
value = 64;
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->guard_interval) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case GUARD_INTERVAL_1_16:
|
|
|
|
value *= 2;
|
|
|
|
break;
|
|
|
|
case GUARD_INTERVAL_1_8:
|
|
|
|
value *= 4;
|
|
|
|
break;
|
|
|
|
case GUARD_INTERVAL_1_4:
|
|
|
|
value *= 8;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case GUARD_INTERVAL_1_32:
|
|
|
|
value *= 1;
|
|
|
|
break;
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
2010-09-07 15:50:46 +00:00
|
|
|
if (state->cfg.diversity_delay == 0)
|
2011-01-04 16:08:14 +00:00
|
|
|
state->div_sync_wait = (value * 3) / 2 + 48;
|
2010-09-07 15:50:46 +00:00
|
|
|
else
|
2011-01-04 16:08:14 +00:00
|
|
|
state->div_sync_wait = (value * 3) / 2 + state->cfg.diversity_delay;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2019-02-18 19:28:55 +00:00
|
|
|
/* deactivate the possibility of diversity reception if extended interleaver */
|
2011-12-22 22:06:20 +00:00
|
|
|
state->div_force_off = !1 && ch->transmission_mode != TRANSMISSION_MODE_8K;
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_set_diversity_in(&state->demod, state->div_state);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* channel estimation fine configuration */
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->modulation) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case QAM_64:
|
|
|
|
est[0] = 0x0148; /* P_adp_regul_cnt 0.04 */
|
|
|
|
est[1] = 0xfff0; /* P_adp_noise_cnt -0.002 */
|
|
|
|
est[2] = 0x00a4; /* P_adp_regul_ext 0.02 */
|
|
|
|
est[3] = 0xfff8; /* P_adp_noise_ext -0.001 */
|
|
|
|
break;
|
|
|
|
case QAM_16:
|
|
|
|
est[0] = 0x023d; /* P_adp_regul_cnt 0.07 */
|
|
|
|
est[1] = 0xffdf; /* P_adp_noise_cnt -0.004 */
|
|
|
|
est[2] = 0x00a4; /* P_adp_regul_ext 0.02 */
|
|
|
|
est[3] = 0xfff0; /* P_adp_noise_ext -0.002 */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
est[0] = 0x099a; /* P_adp_regul_cnt 0.3 */
|
|
|
|
est[1] = 0xffae; /* P_adp_noise_cnt -0.01 */
|
|
|
|
est[2] = 0x0333; /* P_adp_regul_ext 0.1 */
|
|
|
|
est[3] = 0xfff8; /* P_adp_noise_ext -0.002 */
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
for (value = 0; value < 4; value++)
|
|
|
|
dib7000p_write_word(state, 187 + value, est[value]);
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
static int dib7000p_autosearch_start(struct dvb_frontend *demod)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2011-12-22 22:06:20 +00:00
|
|
|
struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
|
2006-10-18 11:34:16 +00:00
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
2011-12-22 22:06:20 +00:00
|
|
|
struct dtv_frontend_properties schan;
|
2007-07-27 13:08:51 +00:00
|
|
|
u32 value, factor;
|
2011-01-04 07:54:31 +00:00
|
|
|
u32 internal = dib7000p_get_internal_freq(state);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
schan = *ch;
|
2011-12-22 22:06:20 +00:00
|
|
|
schan.modulation = QAM_64;
|
|
|
|
schan.guard_interval = GUARD_INTERVAL_1_32;
|
|
|
|
schan.transmission_mode = TRANSMISSION_MODE_8K;
|
|
|
|
schan.code_rate_HP = FEC_2_3;
|
|
|
|
schan.code_rate_LP = FEC_3_4;
|
|
|
|
schan.hierarchy = 0;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
dib7000p_set_channel(state, &schan, 7);
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
factor = BANDWIDTH_TO_KHZ(ch->bandwidth_hz);
|
2011-08-05 13:39:15 +00:00
|
|
|
if (factor >= 5000) {
|
|
|
|
if (state->version == SOC7090)
|
|
|
|
factor = 2;
|
|
|
|
else
|
|
|
|
factor = 1;
|
|
|
|
} else
|
2007-07-27 13:08:51 +00:00
|
|
|
factor = 6;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
value = 30 * internal * factor;
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 6, (u16) ((value >> 16) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 7, (u16) (value & 0xffff));
|
2011-01-04 07:54:31 +00:00
|
|
|
value = 100 * internal * factor;
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 8, (u16) ((value >> 16) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 9, (u16) (value & 0xffff));
|
2011-01-04 07:54:31 +00:00
|
|
|
value = 500 * internal * factor;
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 10, (u16) ((value >> 16) & 0xffff));
|
|
|
|
dib7000p_write_word(state, 11, (u16) (value & 0xffff));
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
value = dib7000p_read_word(state, 0);
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_write_word(state, 0, (u16) ((1 << 9) | value));
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_read_word(state, 1284);
|
|
|
|
dib7000p_write_word(state, 0, (u16) value);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_autosearch_is_irq(struct dvb_frontend *demod)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
u16 irq_pending = dib7000p_read_word(state, 1284);
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
if (irq_pending & 0x1)
|
2006-10-18 11:34:16 +00:00
|
|
|
return 1;
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
if (irq_pending & 0x2)
|
2006-10-18 11:34:16 +00:00
|
|
|
return 2;
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
return 0;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static void dib7000p_spur_protect(struct dib7000p_state *state, u32 rf_khz, u32 bw)
|
|
|
|
{
|
2011-01-04 07:54:31 +00:00
|
|
|
static s16 notch[] = { 16143, 14402, 12238, 9713, 6902, 3888, 759, -2392 };
|
|
|
|
static u8 sine[] = { 0, 2, 3, 5, 6, 8, 9, 11, 13, 14, 16, 17, 19, 20, 22,
|
|
|
|
24, 25, 27, 28, 30, 31, 33, 34, 36, 38, 39, 41, 42, 44, 45, 47, 48, 50, 51,
|
|
|
|
53, 55, 56, 58, 59, 61, 62, 64, 65, 67, 68, 70, 71, 73, 74, 76, 77, 79, 80,
|
|
|
|
82, 83, 85, 86, 88, 89, 91, 92, 94, 95, 97, 98, 99, 101, 102, 104, 105,
|
|
|
|
107, 108, 109, 111, 112, 114, 115, 117, 118, 119, 121, 122, 123, 125, 126,
|
|
|
|
128, 129, 130, 132, 133, 134, 136, 137, 138, 140, 141, 142, 144, 145, 146,
|
|
|
|
147, 149, 150, 151, 152, 154, 155, 156, 157, 159, 160, 161, 162, 164, 165,
|
|
|
|
166, 167, 168, 170, 171, 172, 173, 174, 175, 177, 178, 179, 180, 181, 182,
|
|
|
|
183, 184, 185, 186, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
|
|
|
|
199, 200, 201, 202, 203, 204, 205, 206, 207, 207, 208, 209, 210, 211, 212,
|
|
|
|
213, 214, 215, 215, 216, 217, 218, 219, 220, 220, 221, 222, 223, 224, 224,
|
|
|
|
225, 226, 227, 227, 228, 229, 229, 230, 231, 231, 232, 233, 233, 234, 235,
|
|
|
|
235, 236, 237, 237, 238, 238, 239, 239, 240, 241, 241, 242, 242, 243, 243,
|
|
|
|
244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 248, 249, 249, 249,
|
|
|
|
250, 250, 250, 251, 251, 251, 252, 252, 252, 252, 253, 253, 253, 253, 254,
|
|
|
|
254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
|
|
|
|
255, 255, 255, 255, 255, 255
|
|
|
|
};
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
u32 xtal = state->cfg.bw->xtal_hz / 1000;
|
2009-08-01 19:48:41 +00:00
|
|
|
int f_rel = DIV_ROUND_CLOSEST(rf_khz, xtal) * xtal - rf_khz;
|
2007-07-27 13:08:51 +00:00
|
|
|
int k;
|
2011-01-04 07:54:31 +00:00
|
|
|
int coef_re[8], coef_im[8];
|
2007-07-27 13:08:51 +00:00
|
|
|
int bw_khz = bw;
|
|
|
|
u32 pha;
|
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("relative position of the Spur: %dk (RF: %dk, XTAL: %dk)\n", f_rel, rf_khz, xtal);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (f_rel < -bw_khz / 2 || f_rel > bw_khz / 2)
|
2007-07-27 13:08:51 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
bw_khz /= 100;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 142, 0x0610);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
for (k = 0; k < 8; k++) {
|
2011-01-04 07:54:31 +00:00
|
|
|
pha = ((f_rel * (k + 1) * 112 * 80 / bw_khz) / 1000) & 0x3ff;
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (pha == 0) {
|
2007-07-27 13:08:51 +00:00
|
|
|
coef_re[k] = 256;
|
|
|
|
coef_im[k] = 0;
|
2011-01-04 07:54:31 +00:00
|
|
|
} else if (pha < 256) {
|
|
|
|
coef_re[k] = sine[256 - (pha & 0xff)];
|
|
|
|
coef_im[k] = sine[pha & 0xff];
|
2007-07-27 13:08:51 +00:00
|
|
|
} else if (pha == 256) {
|
|
|
|
coef_re[k] = 0;
|
|
|
|
coef_im[k] = 256;
|
|
|
|
} else if (pha < 512) {
|
2011-01-04 07:54:31 +00:00
|
|
|
coef_re[k] = -sine[pha & 0xff];
|
|
|
|
coef_im[k] = sine[256 - (pha & 0xff)];
|
2007-07-27 13:08:51 +00:00
|
|
|
} else if (pha == 512) {
|
|
|
|
coef_re[k] = -256;
|
|
|
|
coef_im[k] = 0;
|
|
|
|
} else if (pha < 768) {
|
2011-01-04 07:54:31 +00:00
|
|
|
coef_re[k] = -sine[256 - (pha & 0xff)];
|
|
|
|
coef_im[k] = -sine[pha & 0xff];
|
2007-07-27 13:08:51 +00:00
|
|
|
} else if (pha == 768) {
|
|
|
|
coef_re[k] = 0;
|
|
|
|
coef_im[k] = -256;
|
|
|
|
} else {
|
2011-01-04 07:54:31 +00:00
|
|
|
coef_re[k] = sine[pha & 0xff];
|
|
|
|
coef_im[k] = -sine[256 - (pha & 0xff)];
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
coef_re[k] *= notch[k];
|
2011-01-04 07:54:31 +00:00
|
|
|
coef_re[k] += (1 << 14);
|
|
|
|
if (coef_re[k] >= (1 << 24))
|
|
|
|
coef_re[k] = (1 << 24) - 1;
|
|
|
|
coef_re[k] /= (1 << 15);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
coef_im[k] *= notch[k];
|
2011-01-04 07:54:31 +00:00
|
|
|
coef_im[k] += (1 << 14);
|
|
|
|
if (coef_im[k] >= (1 << 24))
|
|
|
|
coef_im[k] = (1 << 24) - 1;
|
|
|
|
coef_im[k] /= (1 << 15);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("PALF COEF: %d re: %d im: %d\n", k, coef_re[k], coef_im[k]);
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
dib7000p_write_word(state, 143, (0 << 14) | (k << 10) | (coef_re[k] & 0x3ff));
|
|
|
|
dib7000p_write_word(state, 144, coef_im[k] & 0x3ff);
|
|
|
|
dib7000p_write_word(state, 143, (1 << 14) | (k << 10) | (coef_re[k] & 0x3ff));
|
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 143, 0);
|
2007-07-27 13:08:51 +00:00
|
|
|
}
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
static int dib7000p_tune(struct dvb_frontend *demod)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2011-12-22 22:06:20 +00:00
|
|
|
struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
|
2006-10-18 11:34:16 +00:00
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
u16 tmp = 0;
|
|
|
|
|
|
|
|
if (ch != NULL)
|
|
|
|
dib7000p_set_channel(state, ch, 0);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
// restart demod
|
|
|
|
dib7000p_write_word(state, 770, 0x4000);
|
|
|
|
dib7000p_write_word(state, 770, 0x0000);
|
|
|
|
msleep(45);
|
|
|
|
|
|
|
|
/* P_ctrl_inh_cor=0, P_ctrl_alpha_cor=4, P_ctrl_inh_isi=0, P_ctrl_alpha_isi=3, P_ctrl_inh_cor4=1, P_ctrl_alpha_cor4=3 */
|
2007-07-31 10:09:30 +00:00
|
|
|
tmp = (0 << 14) | (4 << 10) | (0 << 9) | (3 << 5) | (1 << 4) | (0x3);
|
|
|
|
if (state->sfn_workaround_active) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SFN workaround is active\n");
|
2007-07-31 10:09:30 +00:00
|
|
|
tmp |= (1 << 9);
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 166, 0x4000);
|
2007-07-31 10:09:30 +00:00
|
|
|
} else {
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 166, 0x0000);
|
2007-07-31 10:09:30 +00:00
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 29, tmp);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
// never achieved a lock with that bandwidth so far - wait for osc-freq to update
|
|
|
|
if (state->timf == 0)
|
|
|
|
msleep(200);
|
|
|
|
|
|
|
|
/* offset loop parameters */
|
|
|
|
|
|
|
|
/* P_timf_alpha, P_corm_alpha=6, P_corm_thres=0x80 */
|
|
|
|
tmp = (6 << 8) | 0x80;
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->transmission_mode) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case TRANSMISSION_MODE_2K:
|
|
|
|
tmp |= (2 << 12);
|
|
|
|
break;
|
2011-01-16 15:01:20 +00:00
|
|
|
case TRANSMISSION_MODE_4K:
|
2011-01-04 07:54:31 +00:00
|
|
|
tmp |= (3 << 12);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case TRANSMISSION_MODE_8K:
|
|
|
|
tmp |= (4 << 12);
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 26, tmp); /* timf_a(6xxx) */
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* P_ctrl_freeze_pha_shift=0, P_ctrl_pha_off_max */
|
|
|
|
tmp = (0 << 4);
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->transmission_mode) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case TRANSMISSION_MODE_2K:
|
|
|
|
tmp |= 0x6;
|
|
|
|
break;
|
2011-01-16 15:01:20 +00:00
|
|
|
case TRANSMISSION_MODE_4K:
|
2011-01-04 07:54:31 +00:00
|
|
|
tmp |= 0x7;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case TRANSMISSION_MODE_8K:
|
|
|
|
tmp |= 0x8;
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 32, tmp);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* P_ctrl_sfreq_inh=0, P_ctrl_sfreq_step */
|
|
|
|
tmp = (0 << 4);
|
2011-12-22 22:06:20 +00:00
|
|
|
switch (ch->transmission_mode) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case TRANSMISSION_MODE_2K:
|
|
|
|
tmp |= 0x6;
|
|
|
|
break;
|
|
|
|
case TRANSMISSION_MODE_4K:
|
|
|
|
tmp |= 0x7;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case TRANSMISSION_MODE_8K:
|
|
|
|
tmp |= 0x8;
|
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 33, tmp);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
tmp = dib7000p_read_word(state, 509);
|
2006-10-18 11:34:16 +00:00
|
|
|
if (!((tmp >> 6) & 0x1)) {
|
|
|
|
/* restart the fec */
|
2011-01-04 07:54:31 +00:00
|
|
|
tmp = dib7000p_read_word(state, 771);
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_write_word(state, 771, tmp | (1 << 1));
|
|
|
|
dib7000p_write_word(state, 771, tmp);
|
2011-01-04 07:54:31 +00:00
|
|
|
msleep(40);
|
|
|
|
tmp = dib7000p_read_word(state, 509);
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
// we achieved a lock - it's time to update the osc freq
|
2011-01-04 07:54:31 +00:00
|
|
|
if ((tmp >> 6) & 0x1) {
|
2007-07-27 13:08:51 +00:00
|
|
|
dib7000p_update_timf(state);
|
2011-01-04 07:54:31 +00:00
|
|
|
/* P_timf_alpha += 2 */
|
|
|
|
tmp = dib7000p_read_word(state, 26);
|
|
|
|
dib7000p_write_word(state, 26, (tmp & ~(0xf << 12)) | ((((tmp >> 12) & 0xf) + 5) << 12));
|
|
|
|
}
|
2007-07-27 13:08:51 +00:00
|
|
|
|
|
|
|
if (state->cfg.spur_protect)
|
2011-12-22 22:06:20 +00:00
|
|
|
dib7000p_spur_protect(state, ch->frequency / 1000, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
|
|
|
|
dib7000p_reset_stats(demod);
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
static int dib7000p_wakeup(struct dvb_frontend *demod)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
|
|
|
|
dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_ON);
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->version == SOC7090)
|
|
|
|
dib7000p_sad_calib(state);
|
2007-07-27 13:08:51 +00:00
|
|
|
return 0;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_sleep(struct dvb_frontend *demod)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
2011-01-04 07:54:31 +00:00
|
|
|
if (state->version == SOC7090)
|
2011-08-05 13:39:15 +00:00
|
|
|
return dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
|
2006-10-18 11:34:16 +00:00
|
|
|
return dib7000p_set_output_mode(state, OUTMODE_HIGH_Z) | dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_identify(struct dib7000p_state *st)
|
|
|
|
{
|
|
|
|
u16 value;
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("checking demod on I2C address: %d (%x)\n", st->i2c_addr, st->i2c_addr);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
if ((value = dib7000p_read_word(st, 768)) != 0x01b3) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("wrong Vendor ID (read=0x%x)\n", value);
|
2006-10-18 11:34:16 +00:00
|
|
|
return -EREMOTEIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((value = dib7000p_read_word(st, 769)) != 0x4000) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("wrong Device ID (%x)\n", value);
|
2006-10-18 11:34:16 +00:00
|
|
|
return -EREMOTEIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-04 14:58:30 +00:00
|
|
|
static int dib7000p_get_frontend(struct dvb_frontend *fe,
|
|
|
|
struct dtv_frontend_properties *fep)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
2011-01-04 07:54:31 +00:00
|
|
|
u16 tps = dib7000p_read_word(state, 463);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
fep->inversion = INVERSION_AUTO;
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->bandwidth_hz = BANDWIDTH_TO_HZ(state->current_bandwidth);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
switch ((tps >> 8) & 0x3) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case 0:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->transmission_mode = TRANSMISSION_MODE_2K;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->transmission_mode = TRANSMISSION_MODE_8K;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2011-12-22 22:06:20 +00:00
|
|
|
/* case 2: fep->transmission_mode = TRANSMISSION_MODE_4K; break; */
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (tps & 0x3) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case 0:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->guard_interval = GUARD_INTERVAL_1_32;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->guard_interval = GUARD_INTERVAL_1_16;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->guard_interval = GUARD_INTERVAL_1_8;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->guard_interval = GUARD_INTERVAL_1_4;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch ((tps >> 14) & 0x3) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case 0:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->modulation = QPSK;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->modulation = QAM_16;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
default:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->modulation = QAM_64;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* as long as the frontend_param structure is fixed for hierarchical transmission I refuse to use it */
|
|
|
|
/* (tps >> 13) & 0x1 == hrch is used, (tps >> 10) & 0x7 == alpha */
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->hierarchy = HIERARCHY_NONE;
|
2006-10-18 11:34:16 +00:00
|
|
|
switch ((tps >> 5) & 0x7) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case 1:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_HP = FEC_1_2;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_HP = FEC_2_3;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_HP = FEC_3_4;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 5:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_HP = FEC_5_6;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 7:
|
|
|
|
default:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_HP = FEC_7_8;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ((tps >> 2) & 0x7) {
|
2011-01-04 07:54:31 +00:00
|
|
|
case 1:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_LP = FEC_1_2;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_LP = FEC_2_3;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_LP = FEC_3_4;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 5:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_LP = FEC_5_6;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 7:
|
|
|
|
default:
|
2011-12-22 22:06:20 +00:00
|
|
|
fep->code_rate_LP = FEC_7_8;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* native interleaver: (dib7000p_read_word(state, 464) >> 5) & 0x1 */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
static int dib7000p_set_frontend(struct dvb_frontend *fe)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
[media] dvb: don't require a parameter for get_frontend
Just like set_frontend, use the dvb cache properties for get_frontend.
This is more consistent, as both functions are now symetric. Also,
at the places get_frontend is called, it makes sense to update the
cache.
Most of this patch were generated by this small perl script:
while (<>) { $file .= $_; }
if ($file =~ m/\.get_frontend\s*=\s*([\d\w_]+)/) {
my $get = $1;
$file =~ s/($get)(\s*\([^\,\)]+)\,\s*struct\s+dtv_frontend_properties\s*\*\s*([_\d\w]+)\)\s*\{/\1\2)\n{\n\tstruct dtv_frontend_properties *\3 = &fe->dtv_property_cache;/g;
}
print $file;
Of course, the changes at dvb_frontend.[ch] were made by hand,
as well as the changes on a few other places, where get_frontend()
is called internally inside the driver.
On some places, get_frontend() were just a void function. Those
occurrences were removed, as the DVB core handles such cases.
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
2011-12-30 14:30:21 +00:00
|
|
|
struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
|
2006-10-18 11:34:16 +00:00
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
2008-01-25 09:27:06 +00:00
|
|
|
int time, ret;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version == SOC7090)
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7090_set_diversity_in(fe, 0);
|
2011-08-05 13:39:15 +00:00
|
|
|
else
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_set_output_mode(state, OUTMODE_HIGH_Z);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
/* maybe the parameter has been changed */
|
2007-07-31 10:09:30 +00:00
|
|
|
state->sfn_workaround_active = buggy_sfn_workaround;
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
if (fe->ops.tuner_ops.set_params)
|
2011-12-24 15:24:33 +00:00
|
|
|
fe->ops.tuner_ops.set_params(fe);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2007-07-27 13:08:51 +00:00
|
|
|
/* start up the AGC */
|
|
|
|
state->agc_state = 0;
|
|
|
|
do {
|
2011-12-22 22:06:20 +00:00
|
|
|
time = dib7000p_agc_startup(fe);
|
2007-07-27 13:08:51 +00:00
|
|
|
if (time != -1)
|
|
|
|
msleep(time);
|
|
|
|
} while (time != -1);
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
if (fep->transmission_mode == TRANSMISSION_MODE_AUTO ||
|
|
|
|
fep->guard_interval == GUARD_INTERVAL_AUTO || fep->modulation == QAM_AUTO || fep->code_rate_HP == FEC_AUTO) {
|
2006-10-18 11:34:16 +00:00
|
|
|
int i = 800, found;
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
dib7000p_autosearch_start(fe);
|
2006-10-18 11:34:16 +00:00
|
|
|
do {
|
|
|
|
msleep(1);
|
|
|
|
found = dib7000p_autosearch_is_irq(fe);
|
|
|
|
} while (found == 0 && i--);
|
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("autosearch returns: %d\n", found);
|
2006-10-18 11:34:16 +00:00
|
|
|
if (found == 0 || found == 1)
|
2011-01-04 16:08:14 +00:00
|
|
|
return 0;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2016-02-04 14:58:30 +00:00
|
|
|
dib7000p_get_frontend(fe, fep);
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
ret = dib7000p_tune(fe);
|
2008-01-25 09:27:06 +00:00
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
/* make this a config parameter */
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->version == SOC7090) {
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7090_set_output_mode(fe, state->cfg.output_mode);
|
2011-08-05 13:39:15 +00:00
|
|
|
if (state->cfg.enMpegOutput == 0) {
|
|
|
|
dib7090_setDibTxMux(state, MPEG_ON_DIBTX);
|
|
|
|
dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
|
|
|
|
}
|
|
|
|
} else
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_set_output_mode(state, state->cfg.output_mode);
|
|
|
|
|
|
|
|
return ret;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2015-06-07 17:53:52 +00:00
|
|
|
static int dib7000p_get_stats(struct dvb_frontend *fe, enum fe_status stat);
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
|
2015-06-07 17:53:52 +00:00
|
|
|
static int dib7000p_read_status(struct dvb_frontend *fe, enum fe_status *stat)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 lock = dib7000p_read_word(state, 509);
|
|
|
|
|
|
|
|
*stat = 0;
|
|
|
|
|
|
|
|
if (lock & 0x8000)
|
|
|
|
*stat |= FE_HAS_SIGNAL;
|
|
|
|
if (lock & 0x3000)
|
|
|
|
*stat |= FE_HAS_CARRIER;
|
|
|
|
if (lock & 0x0100)
|
|
|
|
*stat |= FE_HAS_VITERBI;
|
|
|
|
if (lock & 0x0010)
|
|
|
|
*stat |= FE_HAS_SYNC;
|
2011-01-04 07:54:31 +00:00
|
|
|
if ((lock & 0x0038) == 0x38)
|
2006-10-18 11:34:16 +00:00
|
|
|
*stat |= FE_HAS_LOCK;
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
dib7000p_get_stats(fe, *stat);
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static int dib7000p_read_ber(struct dvb_frontend *fe, u32 * ber)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
*ber = (dib7000p_read_word(state, 500) << 16) | dib7000p_read_word(state, 501);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static int dib7000p_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
*unc = dib7000p_read_word(state, 506);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static int dib7000p_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 val = dib7000p_read_word(state, 394);
|
|
|
|
*strength = 65535 - val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
static u32 dib7000p_get_snr(struct dvb_frontend *fe)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2009-09-15 09:46:52 +00:00
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 val;
|
|
|
|
s32 signal_mant, signal_exp, noise_mant, noise_exp;
|
|
|
|
u32 result = 0;
|
|
|
|
|
|
|
|
val = dib7000p_read_word(state, 479);
|
|
|
|
noise_mant = (val >> 4) & 0xff;
|
|
|
|
noise_exp = ((val & 0xf) << 2);
|
|
|
|
val = dib7000p_read_word(state, 480);
|
|
|
|
noise_exp += ((val >> 14) & 0x3);
|
|
|
|
if ((noise_exp & 0x20) != 0)
|
|
|
|
noise_exp -= 0x40;
|
|
|
|
|
|
|
|
signal_mant = (val >> 6) & 0xFF;
|
2011-01-04 07:54:31 +00:00
|
|
|
signal_exp = (val & 0x3F);
|
2009-09-15 09:46:52 +00:00
|
|
|
if ((signal_exp & 0x20) != 0)
|
|
|
|
signal_exp -= 0x40;
|
|
|
|
|
|
|
|
if (signal_mant != 0)
|
2011-01-04 07:54:31 +00:00
|
|
|
result = intlog10(2) * 10 * signal_exp + 10 * intlog10(signal_mant);
|
2009-09-15 09:46:52 +00:00
|
|
|
else
|
|
|
|
result = intlog10(2) * 10 * signal_exp - 100;
|
|
|
|
|
|
|
|
if (noise_mant != 0)
|
2011-01-04 07:54:31 +00:00
|
|
|
result -= intlog10(2) * 10 * noise_exp + 10 * intlog10(noise_mant);
|
2009-09-15 09:46:52 +00:00
|
|
|
else
|
|
|
|
result -= intlog10(2) * 10 * noise_exp - 100;
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7000p_read_snr(struct dvb_frontend *fe, u16 *snr)
|
|
|
|
{
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
result = dib7000p_get_snr(fe);
|
|
|
|
|
2009-09-15 09:46:52 +00:00
|
|
|
*snr = result / ((1 << 24) / 10);
|
2006-10-18 11:34:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
static void dib7000p_reset_stats(struct dvb_frontend *demod)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
struct dtv_frontend_properties *c = &demod->dtv_property_cache;
|
|
|
|
u32 ucb;
|
|
|
|
|
|
|
|
memset(&c->strength, 0, sizeof(c->strength));
|
|
|
|
memset(&c->cnr, 0, sizeof(c->cnr));
|
|
|
|
memset(&c->post_bit_error, 0, sizeof(c->post_bit_error));
|
|
|
|
memset(&c->post_bit_count, 0, sizeof(c->post_bit_count));
|
|
|
|
memset(&c->block_error, 0, sizeof(c->block_error));
|
|
|
|
|
|
|
|
c->strength.len = 1;
|
|
|
|
c->cnr.len = 1;
|
|
|
|
c->block_error.len = 1;
|
|
|
|
c->block_count.len = 1;
|
|
|
|
c->post_bit_error.len = 1;
|
|
|
|
c->post_bit_count.len = 1;
|
|
|
|
|
|
|
|
c->strength.stat[0].scale = FE_SCALE_DECIBEL;
|
|
|
|
c->strength.stat[0].uvalue = 0;
|
|
|
|
|
|
|
|
c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
|
|
|
|
dib7000p_read_unc_blocks(demod, &ucb);
|
|
|
|
|
|
|
|
state->old_ucb = ucb;
|
|
|
|
state->ber_jiffies_stats = 0;
|
|
|
|
state->per_jiffies_stats = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct linear_segments {
|
|
|
|
unsigned x;
|
|
|
|
signed y;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Table to estimate signal strength in dBm.
|
|
|
|
* This table should be empirically determinated by measuring the signal
|
|
|
|
* strength generated by a RF generator directly connected into
|
|
|
|
* a device.
|
2014-05-29 17:44:57 +00:00
|
|
|
* This table was determinated by measuring the signal strength generated
|
|
|
|
* by a DTA-2111 RF generator directly connected into a dib7000p device
|
|
|
|
* (a Hauppauge Nova-TD stick), using a good quality 3 meters length
|
|
|
|
* RC6 cable and good RC6 connectors, connected directly to antenna 1.
|
|
|
|
* As the minimum output power of DTA-2111 is -31dBm, a 16 dBm attenuator
|
|
|
|
* were used, for the lower power values.
|
|
|
|
* The real value can actually be on other devices, or even at the
|
|
|
|
* second antena input, depending on several factors, like if LNA
|
|
|
|
* is enabled or not, if diversity is enabled, type of connectors, etc.
|
|
|
|
* Yet, it is better to use this measure in dB than a random non-linear
|
|
|
|
* percentage value, especially for antenna adjustments.
|
|
|
|
* On my tests, the precision of the measure using this table is about
|
|
|
|
* 0.5 dB, with sounds reasonable enough to adjust antennas.
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
*/
|
2014-05-29 17:44:57 +00:00
|
|
|
#define DB_OFFSET 131000
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
|
|
|
|
static struct linear_segments strength_to_db_table[] = {
|
2014-05-29 17:44:57 +00:00
|
|
|
{ 63630, DB_OFFSET - 20500},
|
|
|
|
{ 62273, DB_OFFSET - 21000},
|
|
|
|
{ 60162, DB_OFFSET - 22000},
|
|
|
|
{ 58730, DB_OFFSET - 23000},
|
|
|
|
{ 58294, DB_OFFSET - 24000},
|
|
|
|
{ 57778, DB_OFFSET - 25000},
|
|
|
|
{ 57320, DB_OFFSET - 26000},
|
|
|
|
{ 56779, DB_OFFSET - 27000},
|
|
|
|
{ 56293, DB_OFFSET - 28000},
|
|
|
|
{ 55724, DB_OFFSET - 29000},
|
|
|
|
{ 55145, DB_OFFSET - 30000},
|
|
|
|
{ 54680, DB_OFFSET - 31000},
|
|
|
|
{ 54293, DB_OFFSET - 32000},
|
|
|
|
{ 53813, DB_OFFSET - 33000},
|
|
|
|
{ 53427, DB_OFFSET - 34000},
|
|
|
|
{ 52981, DB_OFFSET - 35000},
|
|
|
|
|
|
|
|
{ 52636, DB_OFFSET - 36000},
|
|
|
|
{ 52014, DB_OFFSET - 37000},
|
|
|
|
{ 51674, DB_OFFSET - 38000},
|
|
|
|
{ 50692, DB_OFFSET - 39000},
|
|
|
|
{ 49824, DB_OFFSET - 40000},
|
|
|
|
{ 49052, DB_OFFSET - 41000},
|
|
|
|
{ 48436, DB_OFFSET - 42000},
|
|
|
|
{ 47836, DB_OFFSET - 43000},
|
|
|
|
{ 47368, DB_OFFSET - 44000},
|
|
|
|
{ 46468, DB_OFFSET - 45000},
|
|
|
|
{ 45597, DB_OFFSET - 46000},
|
|
|
|
{ 44586, DB_OFFSET - 47000},
|
|
|
|
{ 43667, DB_OFFSET - 48000},
|
|
|
|
{ 42673, DB_OFFSET - 49000},
|
|
|
|
{ 41816, DB_OFFSET - 50000},
|
|
|
|
{ 40876, DB_OFFSET - 51000},
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
{ 0, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static u32 interpolate_value(u32 value, struct linear_segments *segments,
|
|
|
|
unsigned len)
|
|
|
|
{
|
|
|
|
u64 tmp64;
|
|
|
|
u32 dx;
|
|
|
|
s32 dy;
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
if (value >= segments[0].x)
|
|
|
|
return segments[0].y;
|
|
|
|
if (value < segments[len-1].x)
|
|
|
|
return segments[len-1].y;
|
|
|
|
|
|
|
|
for (i = 1; i < len - 1; i++) {
|
|
|
|
/* If value is identical, no need to interpolate */
|
|
|
|
if (value == segments[i].x)
|
|
|
|
return segments[i].y;
|
|
|
|
if (value > segments[i].x)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Linear interpolation between the two (x,y) points */
|
|
|
|
dy = segments[i - 1].y - segments[i].y;
|
|
|
|
dx = segments[i - 1].x - segments[i].x;
|
|
|
|
|
|
|
|
tmp64 = value - segments[i].x;
|
|
|
|
tmp64 *= dy;
|
|
|
|
do_div(tmp64, dx);
|
|
|
|
ret = segments[i].y + tmp64;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: may require changes - this one was borrowed from dib8000 */
|
2014-10-09 13:29:35 +00:00
|
|
|
static u32 dib7000p_get_time_us(struct dvb_frontend *demod)
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
{
|
|
|
|
struct dtv_frontend_properties *c = &demod->dtv_property_cache;
|
|
|
|
u64 time_us, tmp64;
|
|
|
|
u32 tmp, denom;
|
|
|
|
int guard, rate_num, rate_denum = 1, bits_per_symbol;
|
|
|
|
int interleaving = 0, fft_div;
|
|
|
|
|
|
|
|
switch (c->guard_interval) {
|
|
|
|
case GUARD_INTERVAL_1_4:
|
|
|
|
guard = 4;
|
|
|
|
break;
|
|
|
|
case GUARD_INTERVAL_1_8:
|
|
|
|
guard = 8;
|
|
|
|
break;
|
|
|
|
case GUARD_INTERVAL_1_16:
|
|
|
|
guard = 16;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case GUARD_INTERVAL_1_32:
|
|
|
|
guard = 32;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (c->transmission_mode) {
|
|
|
|
case TRANSMISSION_MODE_2K:
|
|
|
|
fft_div = 4;
|
|
|
|
break;
|
|
|
|
case TRANSMISSION_MODE_4K:
|
|
|
|
fft_div = 2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case TRANSMISSION_MODE_8K:
|
|
|
|
fft_div = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (c->modulation) {
|
|
|
|
case DQPSK:
|
|
|
|
case QPSK:
|
|
|
|
bits_per_symbol = 2;
|
|
|
|
break;
|
|
|
|
case QAM_16:
|
|
|
|
bits_per_symbol = 4;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case QAM_64:
|
|
|
|
bits_per_symbol = 6;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ((c->hierarchy == 0 || 1 == 1) ? c->code_rate_HP : c->code_rate_LP) {
|
|
|
|
case FEC_1_2:
|
|
|
|
rate_num = 1;
|
|
|
|
rate_denum = 2;
|
|
|
|
break;
|
|
|
|
case FEC_2_3:
|
|
|
|
rate_num = 2;
|
|
|
|
rate_denum = 3;
|
|
|
|
break;
|
|
|
|
case FEC_3_4:
|
|
|
|
rate_num = 3;
|
|
|
|
rate_denum = 4;
|
|
|
|
break;
|
|
|
|
case FEC_5_6:
|
|
|
|
rate_num = 5;
|
|
|
|
rate_denum = 6;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case FEC_7_8:
|
|
|
|
rate_num = 7;
|
|
|
|
rate_denum = 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
denom = bits_per_symbol * rate_num * fft_div * 384;
|
|
|
|
|
2018-12-04 09:59:10 +00:00
|
|
|
/*
|
|
|
|
* FIXME: check if the math makes sense. If so, fill the
|
|
|
|
* interleaving var.
|
|
|
|
*/
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
/* If calculus gets wrong, wait for 1s for the next stats */
|
|
|
|
if (!denom)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Estimate the period for the total bit rate */
|
|
|
|
time_us = rate_denum * (1008 * 1562500L);
|
|
|
|
tmp64 = time_us;
|
|
|
|
do_div(tmp64, guard);
|
|
|
|
time_us = time_us + tmp64;
|
|
|
|
time_us += denom / 2;
|
|
|
|
do_div(time_us, denom);
|
|
|
|
|
|
|
|
tmp = 1008 * 96 * interleaving;
|
|
|
|
time_us += tmp + tmp / guard;
|
|
|
|
|
|
|
|
return time_us;
|
|
|
|
}
|
|
|
|
|
2015-06-07 17:53:52 +00:00
|
|
|
static int dib7000p_get_stats(struct dvb_frontend *demod, enum fe_status stat)
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = demod->demodulator_priv;
|
|
|
|
struct dtv_frontend_properties *c = &demod->dtv_property_cache;
|
|
|
|
int show_per_stats = 0;
|
|
|
|
u32 time_us = 0, val, snr;
|
|
|
|
u64 blocks, ucb;
|
|
|
|
s32 db;
|
|
|
|
u16 strength;
|
|
|
|
|
|
|
|
/* Get Signal strength */
|
|
|
|
dib7000p_read_signal_strength(demod, &strength);
|
|
|
|
val = strength;
|
|
|
|
db = interpolate_value(val,
|
|
|
|
strength_to_db_table,
|
|
|
|
ARRAY_SIZE(strength_to_db_table)) - DB_OFFSET;
|
|
|
|
c->strength.stat[0].svalue = db;
|
|
|
|
|
|
|
|
/* UCB/BER/CNR measures require lock */
|
|
|
|
if (!(stat & FE_HAS_LOCK)) {
|
|
|
|
c->cnr.len = 1;
|
|
|
|
c->block_count.len = 1;
|
|
|
|
c->block_error.len = 1;
|
|
|
|
c->post_bit_error.len = 1;
|
|
|
|
c->post_bit_count.len = 1;
|
|
|
|
c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if time for stats was elapsed */
|
|
|
|
if (time_after(jiffies, state->per_jiffies_stats)) {
|
|
|
|
state->per_jiffies_stats = jiffies + msecs_to_jiffies(1000);
|
|
|
|
|
|
|
|
/* Get SNR */
|
|
|
|
snr = dib7000p_get_snr(demod);
|
|
|
|
if (snr)
|
|
|
|
snr = (1000L * snr) >> 24;
|
|
|
|
else
|
|
|
|
snr = 0;
|
|
|
|
c->cnr.stat[0].svalue = snr;
|
|
|
|
c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
|
|
|
|
|
|
|
|
/* Get UCB measures */
|
|
|
|
dib7000p_read_unc_blocks(demod, &val);
|
|
|
|
ucb = val - state->old_ucb;
|
|
|
|
if (val < state->old_ucb)
|
|
|
|
ucb += 0x100000000LL;
|
|
|
|
|
|
|
|
c->block_error.stat[0].scale = FE_SCALE_COUNTER;
|
|
|
|
c->block_error.stat[0].uvalue = ucb;
|
|
|
|
|
|
|
|
/* Estimate the number of packets based on bitrate */
|
|
|
|
if (!time_us)
|
2014-10-09 13:29:35 +00:00
|
|
|
time_us = dib7000p_get_time_us(demod);
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
|
|
|
|
if (time_us) {
|
|
|
|
blocks = 1250000ULL * 1000000ULL;
|
|
|
|
do_div(blocks, time_us * 8 * 204);
|
|
|
|
c->block_count.stat[0].scale = FE_SCALE_COUNTER;
|
|
|
|
c->block_count.stat[0].uvalue += blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
show_per_stats = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get post-BER measures */
|
|
|
|
if (time_after(jiffies, state->ber_jiffies_stats)) {
|
2014-10-09 13:29:35 +00:00
|
|
|
time_us = dib7000p_get_time_us(demod);
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
|
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Next all layers stats available in %u us.\n", time_us);
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
|
|
|
|
dib7000p_read_ber(demod, &val);
|
|
|
|
c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
|
|
|
|
c->post_bit_error.stat[0].uvalue += val;
|
|
|
|
|
|
|
|
c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
|
|
|
|
c->post_bit_count.stat[0].uvalue += 100000000;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get PER measures */
|
|
|
|
if (show_per_stats) {
|
|
|
|
dib7000p_read_unc_blocks(demod, &val);
|
|
|
|
|
|
|
|
c->block_error.stat[0].scale = FE_SCALE_COUNTER;
|
|
|
|
c->block_error.stat[0].uvalue += val;
|
|
|
|
|
2014-10-09 13:29:35 +00:00
|
|
|
time_us = dib7000p_get_time_us(demod);
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
if (time_us) {
|
|
|
|
blocks = 1250000ULL * 1000000ULL;
|
|
|
|
do_div(blocks, time_us * 8 * 204);
|
|
|
|
c->block_count.stat[0].scale = FE_SCALE_COUNTER;
|
|
|
|
c->block_count.stat[0].uvalue += blocks;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static int dib7000p_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
tune->min_delay_ms = 1000;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dib7000p_release(struct dvb_frontend *demod)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *st = demod->demodulator_priv;
|
|
|
|
dibx000_exit_i2c_master(&st->i2c_master);
|
2011-01-04 07:54:31 +00:00
|
|
|
i2c_del_adapter(&st->dib7090_tuner_adap);
|
2006-10-18 11:34:16 +00:00
|
|
|
kfree(st);
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000pc_detection(struct i2c_adapter *i2c_adap)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2011-05-03 15:27:33 +00:00
|
|
|
u8 *tx, *rx;
|
2006-10-18 11:34:16 +00:00
|
|
|
struct i2c_msg msg[2] = {
|
2011-05-03 15:27:33 +00:00
|
|
|
{.addr = 18 >> 1, .flags = 0, .len = 2},
|
|
|
|
{.addr = 18 >> 1, .flags = I2C_M_RD, .len = 2},
|
2006-10-18 11:34:16 +00:00
|
|
|
};
|
2011-05-03 15:27:33 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
tx = kzalloc(2, GFP_KERNEL);
|
2011-05-03 15:27:33 +00:00
|
|
|
if (!tx)
|
|
|
|
return -ENOMEM;
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
rx = kzalloc(2, GFP_KERNEL);
|
2011-05-03 15:27:33 +00:00
|
|
|
if (!rx) {
|
|
|
|
ret = -ENOMEM;
|
2011-08-06 08:00:34 +00:00
|
|
|
goto rx_memory_error;
|
2011-05-03 15:27:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
msg[0].buf = tx;
|
|
|
|
msg[1].buf = rx;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
tx[0] = 0x03;
|
|
|
|
tx[1] = 0x00;
|
|
|
|
|
|
|
|
if (i2c_transfer(i2c_adap, msg, 2) == 2)
|
|
|
|
if (rx[0] == 0x01 && rx[1] == 0xb3) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("-D- DiB7000PC detected\n");
|
2019-08-17 06:42:24 +00:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
msg[0].addr = msg[1].addr = 0x40;
|
|
|
|
|
|
|
|
if (i2c_transfer(i2c_adap, msg, 2) == 2)
|
|
|
|
if (rx[0] == 0x01 && rx[1] == 0xb3) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("-D- DiB7000PC detected\n");
|
2019-08-17 06:42:24 +00:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("-D- DiB7000PC not detected\n");
|
2011-05-03 15:27:33 +00:00
|
|
|
|
2019-08-17 06:42:24 +00:00
|
|
|
out:
|
2011-05-03 15:27:33 +00:00
|
|
|
kfree(rx);
|
|
|
|
rx_memory_error:
|
|
|
|
kfree(tx);
|
|
|
|
return ret;
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *demod, enum dibx000_i2c_interface intf, int gating)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *st = demod->demodulator_priv;
|
|
|
|
return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
|
2009-09-18 07:08:43 +00:00
|
|
|
{
|
2011-01-04 07:54:31 +00:00
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 val = dib7000p_read_word(state, 235) & 0xffef;
|
|
|
|
val |= (onoff & 0x1) << 4;
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("PID filter enabled %d\n", onoff);
|
2011-01-04 07:54:31 +00:00
|
|
|
return dib7000p_write_word(state, 235, val);
|
2009-09-18 07:08:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
|
2009-09-18 07:08:43 +00:00
|
|
|
{
|
2011-01-04 07:54:31 +00:00
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("PID filter: index %x, PID %d, OnOff %d\n", id, pid, onoff);
|
2011-01-04 07:54:31 +00:00
|
|
|
return dib7000p_write_word(state, 241 + id, onoff ? (1 << 13) | pid : 0);
|
2009-09-18 07:08:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[])
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
2010-02-08 23:30:44 +00:00
|
|
|
struct dib7000p_state *dpst;
|
2006-10-18 11:34:16 +00:00
|
|
|
int k = 0;
|
|
|
|
u8 new_addr = 0;
|
|
|
|
|
2010-02-08 23:30:44 +00:00
|
|
|
dpst = kzalloc(sizeof(struct dib7000p_state), GFP_KERNEL);
|
|
|
|
if (!dpst)
|
2010-04-27 22:09:45 +00:00
|
|
|
return -ENOMEM;
|
2010-02-08 23:30:44 +00:00
|
|
|
|
|
|
|
dpst->i2c_adap = i2c;
|
2011-08-03 15:08:21 +00:00
|
|
|
mutex_init(&dpst->i2c_buffer_lock);
|
2010-02-08 23:30:44 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
for (k = no_of_demods - 1; k >= 0; k--) {
|
2010-02-08 23:30:44 +00:00
|
|
|
dpst->cfg = cfg[k];
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* designated i2c address */
|
2011-01-04 07:54:31 +00:00
|
|
|
if (cfg[k].default_i2c_addr != 0)
|
|
|
|
new_addr = cfg[k].default_i2c_addr + (k << 1);
|
|
|
|
else
|
|
|
|
new_addr = (0x40 + k) << 1;
|
2010-02-08 23:30:44 +00:00
|
|
|
dpst->i2c_addr = new_addr;
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(dpst, 1287, 0x0003); /* sram lead in, rdy */
|
2010-02-08 23:30:44 +00:00
|
|
|
if (dib7000p_identify(dpst) != 0) {
|
|
|
|
dpst->i2c_addr = default_addr;
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(dpst, 1287, 0x0003); /* sram lead in, rdy */
|
2010-02-08 23:30:44 +00:00
|
|
|
if (dib7000p_identify(dpst) != 0) {
|
2006-10-18 11:34:16 +00:00
|
|
|
dprintk("DiB7000P #%d: not identified\n", k);
|
2010-02-08 23:30:44 +00:00
|
|
|
kfree(dpst);
|
2006-10-18 11:34:16 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* start diversity to pull_down div_str - just for i2c-enumeration */
|
2010-02-08 23:30:44 +00:00
|
|
|
dib7000p_set_output_mode(dpst, OUTMODE_DIVERSITY);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* set new i2c address and force divstart */
|
2010-02-08 23:30:44 +00:00
|
|
|
dib7000p_write_word(dpst, 1285, (new_addr << 2) | 0x2);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("IC %d initialized (to i2c_address 0x%x)\n", k, new_addr);
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (k = 0; k < no_of_demods; k++) {
|
2010-02-08 23:30:44 +00:00
|
|
|
dpst->cfg = cfg[k];
|
2011-01-04 07:54:31 +00:00
|
|
|
if (cfg[k].default_i2c_addr != 0)
|
|
|
|
dpst->i2c_addr = (cfg[k].default_i2c_addr + k) << 1;
|
|
|
|
else
|
|
|
|
dpst->i2c_addr = (0x40 + k) << 1;
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
// unforce divstr
|
2010-02-08 23:30:44 +00:00
|
|
|
dib7000p_write_word(dpst, 1285, dpst->i2c_addr << 2);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
|
|
|
/* deactivate div - it was just for i2c-enumeration */
|
2010-02-08 23:30:44 +00:00
|
|
|
dib7000p_set_output_mode(dpst, OUTMODE_HIGH_Z);
|
2006-10-18 11:34:16 +00:00
|
|
|
}
|
|
|
|
|
2010-02-08 23:30:44 +00:00
|
|
|
kfree(dpst);
|
2006-10-18 11:34:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
static const s32 lut_1000ln_mant[] = {
|
|
|
|
6908, 6956, 7003, 7047, 7090, 7131, 7170, 7208, 7244, 7279, 7313, 7346, 7377, 7408, 7438, 7467, 7495, 7523, 7549, 7575, 7600
|
|
|
|
};
|
|
|
|
|
|
|
|
static s32 dib7000p_get_adc_power(struct dvb_frontend *fe)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u32 tmp_val = 0, exp = 0, mant = 0;
|
|
|
|
s32 pow_i;
|
|
|
|
u16 buf[2];
|
|
|
|
u8 ix = 0;
|
|
|
|
|
|
|
|
buf[0] = dib7000p_read_word(state, 0x184);
|
|
|
|
buf[1] = dib7000p_read_word(state, 0x185);
|
|
|
|
pow_i = (buf[0] << 16) | buf[1];
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("raw pow_i = %d\n", pow_i);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
tmp_val = pow_i;
|
|
|
|
while (tmp_val >>= 1)
|
|
|
|
exp++;
|
|
|
|
|
|
|
|
mant = (pow_i * 1000 / (1 << exp));
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk(" mant = %d exp = %d\n", mant / 1000, exp);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
ix = (u8) ((mant - 1000) / 100); /* index of the LUT */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk(" ix = %d\n", ix);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
pow_i = (lut_1000ln_mant[ix] + 693 * (exp - 20) - 6908);
|
|
|
|
pow_i = (pow_i << 8) / 1000;
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk(" pow_i = %d\n", pow_i);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
return pow_i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int map_addr_to_serpar_number(struct i2c_msg *msg)
|
|
|
|
{
|
|
|
|
if ((msg->buf[0] <= 15))
|
|
|
|
msg->buf[0] -= 1;
|
|
|
|
else if (msg->buf[0] == 17)
|
|
|
|
msg->buf[0] = 15;
|
|
|
|
else if (msg->buf[0] == 16)
|
|
|
|
msg->buf[0] = 17;
|
|
|
|
else if (msg->buf[0] == 19)
|
|
|
|
msg->buf[0] = 16;
|
|
|
|
else if (msg->buf[0] >= 21 && msg->buf[0] <= 25)
|
|
|
|
msg->buf[0] -= 3;
|
|
|
|
else if (msg->buf[0] == 28)
|
|
|
|
msg->buf[0] = 23;
|
2011-01-04 16:08:14 +00:00
|
|
|
else
|
2011-01-04 07:54:31 +00:00
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int w7090p_tuner_write_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
|
|
|
|
u8 n_overflow = 1;
|
|
|
|
u16 i = 1000;
|
|
|
|
u16 serpar_num = msg[0].buf[0];
|
|
|
|
|
|
|
|
while (n_overflow == 1 && i) {
|
|
|
|
n_overflow = (dib7000p_read_word(state, 1984) >> 1) & 0x1;
|
|
|
|
i--;
|
|
|
|
if (i == 0)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Tuner ITF: write busy (overflow)\n");
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 1985, (1 << 6) | (serpar_num & 0x3f));
|
|
|
|
dib7000p_write_word(state, 1986, (msg[0].buf[1] << 8) | msg[0].buf[2]);
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int w7090p_tuner_read_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
|
|
|
|
u8 n_overflow = 1, n_empty = 1;
|
|
|
|
u16 i = 1000;
|
|
|
|
u16 serpar_num = msg[0].buf[0];
|
|
|
|
u16 read_word;
|
|
|
|
|
|
|
|
while (n_overflow == 1 && i) {
|
|
|
|
n_overflow = (dib7000p_read_word(state, 1984) >> 1) & 0x1;
|
|
|
|
i--;
|
|
|
|
if (i == 0)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("TunerITF: read busy (overflow)\n");
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 1985, (0 << 6) | (serpar_num & 0x3f));
|
|
|
|
|
|
|
|
i = 1000;
|
|
|
|
while (n_empty == 1 && i) {
|
|
|
|
n_empty = dib7000p_read_word(state, 1984) & 0x1;
|
|
|
|
i--;
|
|
|
|
if (i == 0)
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("TunerITF: read busy (empty)\n");
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
read_word = dib7000p_read_word(state, 1987);
|
|
|
|
msg[1].buf[0] = (read_word >> 8) & 0xff;
|
|
|
|
msg[1].buf[1] = (read_word) & 0xff;
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int w7090p_tuner_rw_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
|
|
|
|
{
|
|
|
|
if (map_addr_to_serpar_number(&msg[0]) == 0) { /* else = Tuner regs to ignore : DIG_CFG, CTRL_RF_LT, PLL_CFG, PWM1_REG, ADCCLK, DIG_CFG_3; SLEEP_EN... */
|
|
|
|
if (num == 1) { /* write */
|
|
|
|
return w7090p_tuner_write_serpar(i2c_adap, msg, 1);
|
|
|
|
} else { /* read */
|
|
|
|
return w7090p_tuner_read_serpar(i2c_adap, msg, 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2011-08-05 17:10:40 +00:00
|
|
|
static int dib7090p_rw_on_apb(struct i2c_adapter *i2c_adap,
|
|
|
|
struct i2c_msg msg[], int num, u16 apb_address)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
|
|
|
|
u16 word;
|
|
|
|
|
|
|
|
if (num == 1) { /* write */
|
|
|
|
dib7000p_write_word(state, apb_address, ((msg[0].buf[1] << 8) | (msg[0].buf[2])));
|
|
|
|
} else {
|
|
|
|
word = dib7000p_read_word(state, apb_address);
|
|
|
|
msg[1].buf[0] = (word >> 8) & 0xff;
|
|
|
|
msg[1].buf[1] = (word) & 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7090_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
|
|
|
|
|
|
|
|
u16 apb_address = 0, word;
|
|
|
|
int i = 0;
|
|
|
|
switch (msg[0].buf[0]) {
|
|
|
|
case 0x12:
|
|
|
|
apb_address = 1920;
|
|
|
|
break;
|
|
|
|
case 0x14:
|
|
|
|
apb_address = 1921;
|
|
|
|
break;
|
|
|
|
case 0x24:
|
|
|
|
apb_address = 1922;
|
|
|
|
break;
|
|
|
|
case 0x1a:
|
|
|
|
apb_address = 1923;
|
|
|
|
break;
|
|
|
|
case 0x22:
|
|
|
|
apb_address = 1924;
|
|
|
|
break;
|
|
|
|
case 0x33:
|
|
|
|
apb_address = 1926;
|
|
|
|
break;
|
|
|
|
case 0x34:
|
|
|
|
apb_address = 1927;
|
|
|
|
break;
|
|
|
|
case 0x35:
|
|
|
|
apb_address = 1928;
|
|
|
|
break;
|
|
|
|
case 0x36:
|
|
|
|
apb_address = 1929;
|
|
|
|
break;
|
|
|
|
case 0x37:
|
|
|
|
apb_address = 1930;
|
|
|
|
break;
|
|
|
|
case 0x38:
|
|
|
|
apb_address = 1931;
|
|
|
|
break;
|
|
|
|
case 0x39:
|
|
|
|
apb_address = 1932;
|
|
|
|
break;
|
|
|
|
case 0x2a:
|
|
|
|
apb_address = 1935;
|
|
|
|
break;
|
|
|
|
case 0x2b:
|
|
|
|
apb_address = 1936;
|
|
|
|
break;
|
|
|
|
case 0x2c:
|
|
|
|
apb_address = 1937;
|
|
|
|
break;
|
|
|
|
case 0x2d:
|
|
|
|
apb_address = 1938;
|
|
|
|
break;
|
|
|
|
case 0x2e:
|
|
|
|
apb_address = 1939;
|
|
|
|
break;
|
|
|
|
case 0x2f:
|
|
|
|
apb_address = 1940;
|
|
|
|
break;
|
|
|
|
case 0x30:
|
|
|
|
apb_address = 1941;
|
|
|
|
break;
|
|
|
|
case 0x31:
|
|
|
|
apb_address = 1942;
|
|
|
|
break;
|
|
|
|
case 0x32:
|
|
|
|
apb_address = 1943;
|
|
|
|
break;
|
|
|
|
case 0x3e:
|
|
|
|
apb_address = 1944;
|
|
|
|
break;
|
|
|
|
case 0x3f:
|
|
|
|
apb_address = 1945;
|
|
|
|
break;
|
|
|
|
case 0x40:
|
|
|
|
apb_address = 1948;
|
|
|
|
break;
|
|
|
|
case 0x25:
|
|
|
|
apb_address = 914;
|
|
|
|
break;
|
|
|
|
case 0x26:
|
|
|
|
apb_address = 915;
|
|
|
|
break;
|
|
|
|
case 0x27:
|
2011-08-05 13:39:15 +00:00
|
|
|
apb_address = 917;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 0x28:
|
2011-08-05 13:39:15 +00:00
|
|
|
apb_address = 916;
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
case 0x1d:
|
|
|
|
i = ((dib7000p_read_word(state, 72) >> 12) & 0x3);
|
|
|
|
word = dib7000p_read_word(state, 384 + i);
|
|
|
|
msg[1].buf[0] = (word >> 8) & 0xff;
|
|
|
|
msg[1].buf[1] = (word) & 0xff;
|
|
|
|
return num;
|
|
|
|
case 0x1f:
|
|
|
|
if (num == 1) { /* write */
|
|
|
|
word = (u16) ((msg[0].buf[1] << 8) | msg[0].buf[2]);
|
|
|
|
word &= 0x3;
|
2011-01-04 16:08:14 +00:00
|
|
|
word = (dib7000p_read_word(state, 72) & ~(3 << 12)) | (word << 12);
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(state, 72, word); /* Set the proper input */
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-18 19:28:55 +00:00
|
|
|
if (apb_address != 0) /* R/W access via APB */
|
2011-01-04 07:54:31 +00:00
|
|
|
return dib7090p_rw_on_apb(i2c_adap, msg, num, apb_address);
|
|
|
|
else /* R/W access via SERPAR */
|
|
|
|
return w7090p_tuner_rw_serpar(i2c_adap, msg, num);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 dib7000p_i2c_func(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
return I2C_FUNC_I2C;
|
|
|
|
}
|
|
|
|
|
2017-07-09 22:18:15 +00:00
|
|
|
static const struct i2c_algorithm dib7090_tuner_xfer_algo = {
|
2011-01-04 07:54:31 +00:00
|
|
|
.master_xfer = dib7090_tuner_xfer,
|
|
|
|
.functionality = dib7000p_i2c_func,
|
|
|
|
};
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *st = fe->demodulator_priv;
|
|
|
|
return &st->dib7090_tuner_adap;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7090_host_bus_drive(struct dib7000p_state *state, u8 drive)
|
|
|
|
{
|
|
|
|
u16 reg;
|
|
|
|
|
|
|
|
/* drive host bus 2, 3, 4 */
|
|
|
|
reg = dib7000p_read_word(state, 1798) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
|
|
|
|
reg |= (drive << 12) | (drive << 6) | drive;
|
|
|
|
dib7000p_write_word(state, 1798, reg);
|
|
|
|
|
|
|
|
/* drive host bus 5,6 */
|
|
|
|
reg = dib7000p_read_word(state, 1799) & ~((0x7 << 2) | (0x7 << 8));
|
|
|
|
reg |= (drive << 8) | (drive << 2);
|
|
|
|
dib7000p_write_word(state, 1799, reg);
|
|
|
|
|
|
|
|
/* drive host bus 7, 8, 9 */
|
|
|
|
reg = dib7000p_read_word(state, 1800) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
|
|
|
|
reg |= (drive << 12) | (drive << 6) | drive;
|
|
|
|
dib7000p_write_word(state, 1800, reg);
|
|
|
|
|
|
|
|
/* drive host bus 10, 11 */
|
|
|
|
reg = dib7000p_read_word(state, 1801) & ~((0x7 << 2) | (0x7 << 8));
|
|
|
|
reg |= (drive << 8) | (drive << 2);
|
|
|
|
dib7000p_write_word(state, 1801, reg);
|
|
|
|
|
|
|
|
/* drive host bus 12, 13, 14 */
|
|
|
|
reg = dib7000p_read_word(state, 1802) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
|
|
|
|
reg |= (drive << 12) | (drive << 6) | drive;
|
|
|
|
dib7000p_write_word(state, 1802, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 dib7090_calcSyncFreq(u32 P_Kin, u32 P_Kout, u32 insertExtSynchro, u32 syncSize)
|
|
|
|
{
|
|
|
|
u32 quantif = 3;
|
|
|
|
u32 nom = (insertExtSynchro * P_Kin + syncSize);
|
|
|
|
u32 denom = P_Kout;
|
|
|
|
u32 syncFreq = ((nom << quantif) / denom);
|
|
|
|
|
|
|
|
if ((syncFreq & ((1 << quantif) - 1)) != 0)
|
|
|
|
syncFreq = (syncFreq >> quantif) + 1;
|
|
|
|
else
|
|
|
|
syncFreq = (syncFreq >> quantif);
|
|
|
|
|
|
|
|
if (syncFreq != 0)
|
|
|
|
syncFreq = syncFreq - 1;
|
|
|
|
|
|
|
|
return syncFreq;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7090_cfg_DibTx(struct dib7000p_state *state, u32 P_Kin, u32 P_Kout, u32 insertExtSynchro, u32 synchroMode, u32 syncWord, u32 syncSize)
|
|
|
|
{
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Configure DibStream Tx\n");
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
dib7000p_write_word(state, 1615, 1);
|
|
|
|
dib7000p_write_word(state, 1603, P_Kin);
|
|
|
|
dib7000p_write_word(state, 1605, P_Kout);
|
|
|
|
dib7000p_write_word(state, 1606, insertExtSynchro);
|
|
|
|
dib7000p_write_word(state, 1608, synchroMode);
|
|
|
|
dib7000p_write_word(state, 1609, (syncWord >> 16) & 0xffff);
|
|
|
|
dib7000p_write_word(state, 1610, syncWord & 0xffff);
|
|
|
|
dib7000p_write_word(state, 1612, syncSize);
|
|
|
|
dib7000p_write_word(state, 1615, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7090_cfg_DibRx(struct dib7000p_state *state, u32 P_Kin, u32 P_Kout, u32 synchroMode, u32 insertExtSynchro, u32 syncWord, u32 syncSize,
|
|
|
|
u32 dataOutRate)
|
|
|
|
{
|
|
|
|
u32 syncFreq;
|
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Configure DibStream Rx\n");
|
2011-01-04 16:08:14 +00:00
|
|
|
if ((P_Kin != 0) && (P_Kout != 0)) {
|
2011-01-04 07:54:31 +00:00
|
|
|
syncFreq = dib7090_calcSyncFreq(P_Kin, P_Kout, insertExtSynchro, syncSize);
|
|
|
|
dib7000p_write_word(state, 1542, syncFreq);
|
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 1554, 1);
|
|
|
|
dib7000p_write_word(state, 1536, P_Kin);
|
|
|
|
dib7000p_write_word(state, 1537, P_Kout);
|
|
|
|
dib7000p_write_word(state, 1539, synchroMode);
|
|
|
|
dib7000p_write_word(state, 1540, (syncWord >> 16) & 0xffff);
|
|
|
|
dib7000p_write_word(state, 1541, syncWord & 0xffff);
|
|
|
|
dib7000p_write_word(state, 1543, syncSize);
|
|
|
|
dib7000p_write_word(state, 1544, dataOutRate);
|
|
|
|
dib7000p_write_word(state, 1554, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
static void dib7090_enMpegMux(struct dib7000p_state *state, int onoff)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
2011-08-05 13:39:15 +00:00
|
|
|
u16 reg_1287 = dib7000p_read_word(state, 1287);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
switch (onoff) {
|
|
|
|
case 1:
|
|
|
|
reg_1287 &= ~(1<<7);
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
reg_1287 |= (1<<7);
|
|
|
|
break;
|
|
|
|
}
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7000p_write_word(state, 1287, reg_1287);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
static void dib7090_configMpegMux(struct dib7000p_state *state,
|
|
|
|
u16 pulseWidth, u16 enSerialMode, u16 enSerialClkDiv2)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("Enable Mpeg mux\n");
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_enMpegMux(state, 0);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
/* If the input mode is MPEG do not divide the serial clock */
|
|
|
|
if ((enSerialMode == 1) && (state->input_mode_mpeg == 1))
|
|
|
|
enSerialClkDiv2 = 0;
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7000p_write_word(state, 1287, ((pulseWidth & 0x1f) << 2)
|
|
|
|
| ((enSerialMode & 0x1) << 1)
|
|
|
|
| (enSerialClkDiv2 & 0x1));
|
|
|
|
|
|
|
|
dib7090_enMpegMux(state, 1);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
static void dib7090_setDibTxMux(struct dib7000p_state *state, int mode)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
2011-08-05 13:39:15 +00:00
|
|
|
u16 reg_1288 = dib7000p_read_word(state, 1288) & ~(0x7 << 7);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
switch (mode) {
|
|
|
|
case MPEG_ON_DIBTX:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SET MPEG ON DIBSTREAM TX\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_cfg_DibTx(state, 8, 5, 0, 0, 0, 0);
|
|
|
|
reg_1288 |= (1<<9);
|
|
|
|
break;
|
|
|
|
case DIV_ON_DIBTX:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SET DIV_OUT ON DIBSTREAM TX\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_cfg_DibTx(state, 5, 5, 0, 0, 0, 0);
|
|
|
|
reg_1288 |= (1<<8);
|
|
|
|
break;
|
|
|
|
case ADC_ON_DIBTX:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SET ADC_OUT ON DIBSTREAM TX\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_cfg_DibTx(state, 20, 5, 10, 0, 0, 0);
|
|
|
|
reg_1288 |= (1<<7);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dib7000p_write_word(state, 1288, reg_1288);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
static void dib7090_setHostBusMux(struct dib7000p_state *state, int mode)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
2011-08-05 13:39:15 +00:00
|
|
|
u16 reg_1288 = dib7000p_read_word(state, 1288) & ~(0x7 << 4);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
switch (mode) {
|
2011-08-05 13:39:15 +00:00
|
|
|
case DEMOUT_ON_HOSTBUS:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SET DEM OUT OLD INTERF ON HOST BUS\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_enMpegMux(state, 0);
|
|
|
|
reg_1288 |= (1<<6);
|
|
|
|
break;
|
|
|
|
case DIBTX_ON_HOSTBUS:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SET DIBSTREAM TX ON HOST BUS\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_enMpegMux(state, 0);
|
|
|
|
reg_1288 |= (1<<5);
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2011-08-05 13:39:15 +00:00
|
|
|
case MPEG_ON_HOSTBUS:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("SET MPEG MUX ON HOST BUS\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
reg_1288 |= (1<<4);
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
2011-01-04 16:08:14 +00:00
|
|
|
default:
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7000p_write_word(state, 1288, reg_1288);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2014-08-20 19:58:35 +00:00
|
|
|
static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
2011-08-05 13:39:15 +00:00
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 reg_1287;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
switch (onoff) {
|
2011-08-05 13:39:15 +00:00
|
|
|
case 0: /* only use the internal way - not the diversity input */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("%s mode OFF : by default Enable Mpeg INPUT\n", __func__);
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_cfg_DibRx(state, 8, 5, 0, 0, 0, 8, 0);
|
|
|
|
|
|
|
|
/* Do not divide the serial clock of MPEG MUX */
|
|
|
|
/* in SERIAL MODE in case input mode MPEG is used */
|
|
|
|
reg_1287 = dib7000p_read_word(state, 1287);
|
|
|
|
/* enSerialClkDiv2 == 1 ? */
|
|
|
|
if ((reg_1287 & 0x1) == 1) {
|
|
|
|
/* force enSerialClkDiv2 = 0 */
|
|
|
|
reg_1287 &= ~0x1;
|
|
|
|
dib7000p_write_word(state, 1287, reg_1287);
|
|
|
|
}
|
|
|
|
state->input_mode_mpeg = 1;
|
|
|
|
break;
|
|
|
|
case 1: /* both ways */
|
|
|
|
case 2: /* only the diversity input */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("%s ON : Enable diversity INPUT\n", __func__);
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_cfg_DibRx(state, 5, 5, 0, 0, 0, 0, 0);
|
|
|
|
state->input_mode_mpeg = 0;
|
|
|
|
break;
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7000p_set_diversity_in(&state->demod, onoff);
|
2011-01-04 07:54:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode)
|
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
|
|
|
|
u16 outreg, smo_mode, fifo_threshold;
|
|
|
|
u8 prefer_mpeg_mux_use = 1;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
dib7090_host_bus_drive(state, 1);
|
|
|
|
|
|
|
|
fifo_threshold = 1792;
|
|
|
|
smo_mode = (dib7000p_read_word(state, 235) & 0x0050) | (1 << 1);
|
|
|
|
outreg = dib7000p_read_word(state, 1286) & ~((1 << 10) | (0x7 << 6) | (1 << 1));
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case OUTMODE_HIGH_Z:
|
|
|
|
outreg = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTMODE_MPEG2_SERIAL:
|
|
|
|
if (prefer_mpeg_mux_use) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode TS_SERIAL using Mpeg Mux\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_configMpegMux(state, 3, 1, 1);
|
|
|
|
dib7090_setHostBusMux(state, MPEG_ON_HOSTBUS);
|
|
|
|
} else {/* Use Smooth block */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode TS_SERIAL using Smooth bloc\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
|
|
|
|
outreg |= (2<<6) | (0 << 1);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTMODE_MPEG2_PAR_GATED_CLK:
|
|
|
|
if (prefer_mpeg_mux_use) {
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode TS_PARALLEL_GATED using Mpeg Mux\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_configMpegMux(state, 2, 0, 0);
|
|
|
|
dib7090_setHostBusMux(state, MPEG_ON_HOSTBUS);
|
|
|
|
} else { /* Use Smooth block */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode TS_PARALLEL_GATED using Smooth block\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
|
|
|
|
outreg |= (0<<6);
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTMODE_MPEG2_PAR_CONT_CLK: /* Using Smooth block only */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode TS_PARALLEL_CONT using Smooth block\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
|
|
|
|
outreg |= (1<<6);
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTMODE_MPEG2_FIFO: /* Using Smooth block because not supported by new Mpeg Mux bloc */
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode TS_FIFO using Smooth block\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
|
|
|
|
outreg |= (5<<6);
|
2011-01-04 07:54:31 +00:00
|
|
|
smo_mode |= (3 << 1);
|
|
|
|
fifo_threshold = 512;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTMODE_DIVERSITY:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode MODE_DIVERSITY\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_setDibTxMux(state, DIV_ON_DIBTX);
|
|
|
|
dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OUTMODE_ANALOG_ADC:
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("setting output mode MODE_ANALOG_ADC\n");
|
2011-08-05 13:39:15 +00:00
|
|
|
dib7090_setDibTxMux(state, ADC_ON_DIBTX);
|
|
|
|
dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
|
2011-01-04 07:54:31 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-08-05 13:39:15 +00:00
|
|
|
if (mode != OUTMODE_HIGH_Z)
|
|
|
|
outreg |= (1 << 10);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
if (state->cfg.output_mpeg2_in_188_bytes)
|
|
|
|
smo_mode |= (1 << 5);
|
|
|
|
|
|
|
|
ret |= dib7000p_write_word(state, 235, smo_mode);
|
|
|
|
ret |= dib7000p_write_word(state, 236, fifo_threshold); /* synchronous fread */
|
2011-08-05 13:39:15 +00:00
|
|
|
ret |= dib7000p_write_word(state, 1286, outreg);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
|
|
|
u16 en_cur_state;
|
|
|
|
|
2016-10-14 12:35:33 +00:00
|
|
|
dprintk("sleep dib7090: %d\n", onoff);
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
en_cur_state = dib7000p_read_word(state, 1922);
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
if (en_cur_state > 0xff)
|
2011-01-04 07:54:31 +00:00
|
|
|
state->tuner_enable = en_cur_state;
|
|
|
|
|
|
|
|
if (onoff)
|
2011-01-04 16:08:14 +00:00
|
|
|
en_cur_state &= 0x00ff;
|
2011-01-04 07:54:31 +00:00
|
|
|
else {
|
|
|
|
if (state->tuner_enable != 0)
|
|
|
|
en_cur_state = state->tuner_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
dib7000p_write_word(state, 1922, en_cur_state);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7090_get_adc_power(struct dvb_frontend *fe)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
return dib7000p_get_adc_power(fe);
|
|
|
|
}
|
|
|
|
|
2014-05-29 12:20:15 +00:00
|
|
|
static int dib7090_slave_reset(struct dvb_frontend *fe)
|
2011-01-04 07:54:31 +00:00
|
|
|
{
|
|
|
|
struct dib7000p_state *state = fe->demodulator_priv;
|
2011-01-04 16:08:14 +00:00
|
|
|
u16 reg;
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
reg = dib7000p_read_word(state, 1794);
|
|
|
|
dib7000p_write_word(state, 1794, reg | (4 << 12));
|
2011-01-04 07:54:31 +00:00
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
dib7000p_write_word(state, 1032, 0xffff);
|
|
|
|
return 0;
|
2011-01-04 07:54:31 +00:00
|
|
|
}
|
|
|
|
|
2016-08-09 21:32:21 +00:00
|
|
|
static const struct dvb_frontend_ops dib7000p_ops;
|
2014-05-29 12:20:15 +00:00
|
|
|
static struct dvb_frontend *dib7000p_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg)
|
2006-10-18 11:34:16 +00:00
|
|
|
{
|
|
|
|
struct dvb_frontend *demod;
|
|
|
|
struct dib7000p_state *st;
|
|
|
|
st = kzalloc(sizeof(struct dib7000p_state), GFP_KERNEL);
|
|
|
|
if (st == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
memcpy(&st->cfg, cfg, sizeof(struct dib7000p_config));
|
|
|
|
st->i2c_adap = i2c_adap;
|
|
|
|
st->i2c_addr = i2c_addr;
|
|
|
|
st->gpio_val = cfg->gpio_val;
|
|
|
|
st->gpio_dir = cfg->gpio_dir;
|
|
|
|
|
2008-04-22 18:37:01 +00:00
|
|
|
/* Ensure the output mode remains at the previous default if it's
|
|
|
|
* not specifically set by the caller.
|
|
|
|
*/
|
2011-01-04 07:54:31 +00:00
|
|
|
if ((st->cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (st->cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
|
2008-04-22 18:37:01 +00:00
|
|
|
st->cfg.output_mode = OUTMODE_MPEG2_FIFO;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
demod = &st->demod;
|
2006-10-18 11:34:16 +00:00
|
|
|
demod->demodulator_priv = st;
|
|
|
|
memcpy(&st->demod.ops, &dib7000p_ops, sizeof(struct dvb_frontend_ops));
|
2011-08-03 15:08:21 +00:00
|
|
|
mutex_init(&st->i2c_buffer_lock);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
dib7000p_write_word(st, 1287, 0x0003); /* sram lead in, rdy */
|
2009-09-23 16:41:27 +00:00
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
if (dib7000p_identify(st) != 0)
|
|
|
|
goto error;
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
st->version = dib7000p_read_word(st, 897);
|
|
|
|
|
2009-10-01 01:59:09 +00:00
|
|
|
/* FIXME: make sure the dev.parent field is initialized, or else
|
2009-07-20 03:45:25 +00:00
|
|
|
request_firmware() will hit an OOPS (this should be moved somewhere
|
|
|
|
more common) */
|
|
|
|
st->i2c_master.gated_tuner_i2c_adap.dev.parent = i2c_adap->dev.parent;
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
dibx000_init_i2c_master(&st->i2c_master, DIB7000P, st->i2c_adap, st->i2c_addr);
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
/* init 7090 tuner adapter */
|
2018-09-10 12:19:16 +00:00
|
|
|
strscpy(st->dib7090_tuner_adap.name, "DiB7090 tuner interface",
|
|
|
|
sizeof(st->dib7090_tuner_adap.name));
|
2011-01-04 07:54:31 +00:00
|
|
|
st->dib7090_tuner_adap.algo = &dib7090_tuner_xfer_algo;
|
|
|
|
st->dib7090_tuner_adap.algo_data = NULL;
|
|
|
|
st->dib7090_tuner_adap.dev.parent = st->i2c_adap->dev.parent;
|
|
|
|
i2c_set_adapdata(&st->dib7090_tuner_adap, st);
|
|
|
|
i2c_add_adapter(&st->dib7090_tuner_adap);
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
dib7000p_demod_reset(st);
|
|
|
|
|
[media] dib7000p: Add DVBv5 stats support
Adds DVBv5 stats support. For now, just mimic whatever dib8000
does, as they're very similar, with regards to statistics.
However, dib7000p_get_time_us() likely require some
adjustments, as I didn't actually reviewed the formula
for it to work with DVB-T. Still, better than nothing,
as latter patches can improve it.
This patch also doesn't show the signal strength in dB
yet. The code is already there, but it requires to be
callibrated.
A latter patch will do the calibration.
It seems that this patch is also a bug fix: Before this
patch, the frontend were not tuning with some userspace
tools. I suspect that dib7000p firmware or hardware
internally expects that the statistics to be collected,
in order for it to work. With this patch, the DVB core
will always retrive statistics, even if userspace doesn't
request. So, it makes the device work on all tested apps.
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>
2014-05-29 17:44:56 +00:00
|
|
|
dib7000p_reset_stats(demod);
|
|
|
|
|
2011-01-04 07:54:31 +00:00
|
|
|
if (st->version == SOC7090) {
|
|
|
|
dib7090_set_output_mode(demod, st->cfg.output_mode);
|
|
|
|
dib7090_set_diversity_in(demod, 0);
|
|
|
|
}
|
|
|
|
|
2006-10-18 11:34:16 +00:00
|
|
|
return demod;
|
|
|
|
|
2011-01-04 16:08:14 +00:00
|
|
|
error:
|
2006-10-18 11:34:16 +00:00
|
|
|
kfree(st);
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-05-29 12:20:15 +00:00
|
|
|
|
|
|
|
void *dib7000p_attach(struct dib7000p_ops *ops)
|
|
|
|
{
|
|
|
|
if (!ops)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ops->slave_reset = dib7090_slave_reset;
|
|
|
|
ops->get_adc_power = dib7090_get_adc_power;
|
|
|
|
ops->dib7000pc_detection = dib7000pc_detection;
|
|
|
|
ops->get_i2c_tuner = dib7090_get_i2c_tuner;
|
|
|
|
ops->tuner_sleep = dib7090_tuner_sleep;
|
|
|
|
ops->init = dib7000p_init;
|
|
|
|
ops->set_agc1_min = dib7000p_set_agc1_min;
|
|
|
|
ops->set_gpio = dib7000p_set_gpio;
|
|
|
|
ops->i2c_enumeration = dib7000p_i2c_enumeration;
|
|
|
|
ops->pid_filter = dib7000p_pid_filter;
|
|
|
|
ops->pid_filter_ctrl = dib7000p_pid_filter_ctrl;
|
|
|
|
ops->get_i2c_master = dib7000p_get_i2c_master;
|
|
|
|
ops->update_pll = dib7000p_update_pll;
|
|
|
|
ops->ctrl_timf = dib7000p_ctrl_timf;
|
|
|
|
ops->get_agc_values = dib7000p_get_agc_values;
|
|
|
|
ops->set_wbd_ref = dib7000p_set_wbd_ref;
|
|
|
|
|
|
|
|
return ops;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dib7000p_attach);
|
2006-10-18 11:34:16 +00:00
|
|
|
|
2016-08-09 21:32:21 +00:00
|
|
|
static const struct dvb_frontend_ops dib7000p_ops = {
|
2011-12-22 22:06:20 +00:00
|
|
|
.delsys = { SYS_DVBT },
|
2006-10-18 11:34:16 +00:00
|
|
|
.info = {
|
2011-01-04 07:54:31 +00:00
|
|
|
.name = "DiBcom 7000PC",
|
2018-07-05 22:59:36 +00:00
|
|
|
.frequency_min_hz = 44250 * kHz,
|
|
|
|
.frequency_max_hz = 867250 * kHz,
|
|
|
|
.frequency_stepsize_hz = 62500,
|
2011-01-04 07:54:31 +00:00
|
|
|
.caps = FE_CAN_INVERSION_AUTO |
|
|
|
|
FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
|
|
|
|
FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
|
|
|
|
FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
|
|
|
|
FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
|
|
|
|
},
|
|
|
|
|
|
|
|
.release = dib7000p_release,
|
|
|
|
|
|
|
|
.init = dib7000p_wakeup,
|
|
|
|
.sleep = dib7000p_sleep,
|
|
|
|
|
2011-12-22 22:06:20 +00:00
|
|
|
.set_frontend = dib7000p_set_frontend,
|
2011-01-04 07:54:31 +00:00
|
|
|
.get_tune_settings = dib7000p_fe_get_tune_settings,
|
2011-12-22 22:06:20 +00:00
|
|
|
.get_frontend = dib7000p_get_frontend,
|
2011-01-04 07:54:31 +00:00
|
|
|
|
|
|
|
.read_status = dib7000p_read_status,
|
|
|
|
.read_ber = dib7000p_read_ber,
|
2006-10-18 11:34:16 +00:00
|
|
|
.read_signal_strength = dib7000p_read_signal_strength,
|
2011-01-04 07:54:31 +00:00
|
|
|
.read_snr = dib7000p_read_snr,
|
|
|
|
.read_ucblocks = dib7000p_read_unc_blocks,
|
2006-10-18 11:34:16 +00:00
|
|
|
};
|
|
|
|
|
2016-01-24 14:56:58 +00:00
|
|
|
MODULE_AUTHOR("Olivier Grenie <olivie.grenie@parrot.com>");
|
|
|
|
MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
|
2006-10-18 11:34:16 +00:00
|
|
|
MODULE_DESCRIPTION("Driver for the DiBcom 7000PC COFDM demodulator");
|
|
|
|
MODULE_LICENSE("GPL");
|