DDBridge 0.9.10 driver updates
PATCH 3/12 stv0367dd: Support for STV 0367 DVB-C/T (DD) demodulator
In reply to Maik BroemmeAdded support for the STV 0367 DVB-C/T demodulator used by recent Digital Devices hardware. This will allow update of ddbridge driver to support newer devices like DVBCT V6.1 DVB adapter.
--- drivers/media/dvb-frontends/Kconfig | 9 + drivers/media/dvb-frontends/Makefile | 1 + drivers/media/dvb-frontends/stv0367dd.c | 2329 +++++++++++++++++ drivers/media/dvb-frontends/stv0367dd.h | 48 + drivers/media/dvb-frontends/stv0367dd_regs.h | 3442 ++++++++++++++++++++++++++ 5 files changed, 5829 insertions(+) create mode 100644 drivers/media/dvb-frontends/stv0367dd.c create mode 100644 drivers/media/dvb-frontends/stv0367dd.h create mode 100644 drivers/media/dvb-frontends/stv0367dd_regs.h
drivers/media/dvb-frontends/Kconfig +9 -0
@@ -56,6 +56,15 @@ config DVB_TDA18271C2DD Say Y when you want to support this tuner. +config DVB_STV0367DD + tristate "STV 0367 (DD)" + depends on DVB_CORE && I2C + default m if DVB_FE_CUSTOMISE + help + STV 0367 DVB-C/T demodulator (Digital Devices driver). + + Say Y when you want to support this frontend. + comment "DVB-S (satellite) frontends" depends on DVB_CORE
drivers/media/dvb-frontends/Makefile +1 -0
@@ -97,6 +97,7 @@ obj-$(CONFIG_DVB_STV0367) += stv0367.o obj-$(CONFIG_DVB_CXD2820R) += cxd2820r.o obj-$(CONFIG_DVB_DRXK) += drxk.o obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o +obj-$(CONFIG_DVB_STV0367DD) += stv0367dd.o obj-$(CONFIG_DVB_IT913X_FE) += it913x-fe.o obj-$(CONFIG_DVB_A8293) += a8293.o obj-$(CONFIG_DVB_TDA10071) += tda10071.o
drivers/media/dvb-frontends/stv0367dd.c new file +2329 -0
2,329 lines not on this page · raw message
drivers/media/dvb-frontends/stv0367dd.h new file +48 -0
48 lines not on this page · raw message
drivers/media/dvb-frontends/stv0367dd_regs.h new file +3442 -0
601 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
1.8.4.2
Part of the diff is not shown here. View the raw message.
PATCH 4/12 tda18212dd: Support for NXP TDA18212 (DD) silicon tuner
In reply to Maik BroemmeAdded support for the NXP TDA18212 silicon tuner used by recent Digital Devices hardware. This will allow update of ddbridge driver to support newer devices.
--- drivers/media/dvb-frontends/Kconfig | 9 + drivers/media/dvb-frontends/Makefile | 1 + drivers/media/dvb-frontends/tda18212dd.c | 934 +++++++++++++++++++++++++++++++ drivers/media/dvb-frontends/tda18212dd.h | 37 ++ 4 files changed, 981 insertions(+) create mode 100644 drivers/media/dvb-frontends/tda18212dd.c create mode 100644 drivers/media/dvb-frontends/tda18212dd.h
drivers/media/dvb-frontends/Kconfig +9 -0
@@ -65,6 +65,15 @@ config DVB_STV0367DD Say Y when you want to support this frontend. +config DVB_TDA18212DD + tristate "NXP TDA18212 silicon tuner (DD)" + depends on DVB_CORE && I2C + default m if DVB_FE_CUSTOMISE + help + NXP TDA18212 silicon tuner (Digital Devices driver). + + Say Y when you want to support this tuner. + comment "DVB-S (satellite) frontends" depends on DVB_CORE
drivers/media/dvb-frontends/Makefile +1 -0
@@ -98,6 +98,7 @@ obj-$(CONFIG_DVB_CXD2820R) += cxd2820r.o obj-$(CONFIG_DVB_DRXK) += drxk.o obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o obj-$(CONFIG_DVB_STV0367DD) += stv0367dd.o +obj-$(CONFIG_DVB_TDA18212DD) += tda18212dd.o obj-$(CONFIG_DVB_IT913X_FE) += it913x-fe.o obj-$(CONFIG_DVB_A8293) += a8293.o obj-$(CONFIG_DVB_TDA10071) += tda10071.o
drivers/media/dvb-frontends/tda18212dd.c new file +934 -0
934 lines not on this page · raw message
drivers/media/dvb-frontends/tda18212dd.h new file +37 -0
@@ -0,0 +1,37 @@ +/* +* tda18212dd.h: Driver for the TDA18212 tuner +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#ifndef _TDA18212DD_H_ +#define _TDA18212DD_H_ + +#if IS_ENABLED (CONFIG_DVB_TDA18212DD ) +struct dvb_frontend *tda18212dd_attach (struct dvb_frontend *fe, +struct i2c_adapter *i2c,u8 adr); +#else +static inline struct dvb_frontend *tda18212dd_attach (struct dvb_frontend *fe, +struct i2c_adapter *i2c,u8 adr); +{ +printk (KERN_WARNING "%s: driver disabled by Kconfig\n" , __func__); +return NULL ; +} +#endif + +#endif
Signature · 1 line
1.8.4.2
PATCH 5/12 cxd2843: Support for CXD2843ER demodulator for DVB-T/T2/C/C2
In reply to Maik BroemmeAdded support for the CXD2843ER demodulator for DVB-T/T2/C/C2 used by recent Digital Devices hardware.
--- drivers/media/dvb-frontends/Kconfig | 9 + drivers/media/dvb-frontends/Makefile | 1 + drivers/media/dvb-frontends/cxd2843.c | 1647 +++++++++++++++++++++++++++++++++ drivers/media/dvb-frontends/cxd2843.h | 47 + 4 files changed, 1704 insertions(+) create mode 100644 drivers/media/dvb-frontends/cxd2843.c create mode 100644 drivers/media/dvb-frontends/cxd2843.h
drivers/media/dvb-frontends/Kconfig +9 -0
@@ -74,6 +74,15 @@ config DVB_TDA18212DD Say Y when you want to support this tuner. +config DVB_CXD2843 + tristate "CXD2843ER based for DVB-T/T2/C/C2" + depends on DVB_CORE && I2C + default m if DVB_FE_CUSTOMISE + help + Sony CXD2843ER/CXD2837ER DVB-T/T2/C/C2 demodulator. + + Say Y when you want to support this frontend. + comment "DVB-S (satellite) frontends" depends on DVB_CORE
drivers/media/dvb-frontends/Makefile +1 -0
@@ -99,6 +99,7 @@ obj-$(CONFIG_DVB_DRXK) += drxk.o obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o obj-$(CONFIG_DVB_STV0367DD) += stv0367dd.o obj-$(CONFIG_DVB_TDA18212DD) += tda18212dd.o +obj-$(CONFIG_DVB_CXD2843) += cxd2843.o obj-$(CONFIG_DVB_IT913X_FE) += it913x-fe.o obj-$(CONFIG_DVB_A8293) += a8293.o obj-$(CONFIG_DVB_TDA10071) += tda10071.o
drivers/media/dvb-frontends/cxd2843.c new file +1647 -0
1,647 lines not on this page · raw message
drivers/media/dvb-frontends/cxd2843.h new file +47 -0
47 lines not on this page · raw message
Signature · 1 line
1.8.4.2
PATCH 6/12 dvb-core: export dvb_usercopy and new DVB device constants
In reply to Maik BroemmeAdded EXPORT_SYMBOL(dvb_usercopy) to allow new ddbridge driver to use it. It is questionable if I should use it in this way or not. If not I will fix it.
Added two new DVB device constants DVB_DEVICE_CI and DVB_DEVICE_MOD required by newer ddbridge driver. Again it is questionable to use them or modify ddbridge driver.
--- drivers/media/dvb-core/dvbdev.c | 1 + drivers/media/dvb-core/dvbdev.h | 2 ++ 2 files changed, 3 insertions(+)
drivers/media/dvb-core/dvbdev.c +1 -0
@@ -438,6 +438,7 @@ out:kfree (mbuf);return err; } +EXPORT_SYMBOL (dvb_usercopy);static int dvb_uevent (struct device *dev,struct kobj_uevent_env *env) {
drivers/media/dvb-core/dvbdev.h +2 -0
@@ -47,6 +47,8 @@#define DVB_DEVICE_CA 6#define DVB_DEVICE_NET 7#define DVB_DEVICE_OSD 8 +#define DVB_DEVICE_CI 9 +#define DVB_DEVICE_MOD 10#define DVB_DEFINE_MOD_OPT_ADAPTER_NR (adapter_nr) \ static short adapter_nr[] = \
Signature · 1 line
1.8.4.2
PATCH 7/12 ddbridge: Updated ddbridge registers
In reply to Maik BroemmeUpdated ddbridge registers:
- Added GPIO and MDIO registers
- Added Clock Generator (Sil598 @ 0xAA I2c)
- Added DAC (AD9781/AD9783 SPI)
- Added Temperature Monitor (2x LM75A @ 0x90,0x92 I2c)
- Added CI Interface (only CI-Bridge)
- Added output control registers
- Added modulator channels
- Removed unneded defines (might be added later again if needed)
--- drivers/media/pci/ddbridge/ddbridge-regs.h | 273 ++++++++++++++++++----------- 1 file changed, 168 insertions(+), 105 deletions(-)
drivers/media/pci/ddbridge/ddbridge-regs.h +168 -105
@@ -1,47 +1,53 @@/* -* ddbridge-regs.h: Digital Devices PCIe bridge driver +* ddbridge-regs.h: Digital Devices PCIe bridge driver * -* Copyright (C) 2010-2011 Digital Devices GmbH +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> * -* This program is free software; you can redistribute it and/or -* modify it under the terms of the GNU General Public License -* version 2 only, as published by the Free Software Foundation. +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. * +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. * -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* -* You should have received a copy of the GNU General Public License -* along with this program; if not, write to the Free Software -* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -* 02110-1301, USA -* Or, point your browser to http://www.gnu.org/copyleft/gpl.html +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA */ -/* DD-DVBBridgeV1.h 273 2010-09-17 05:03:16Z manfred */ +#ifndef _DDBRIDGE_REGS_H_ +#define _DDBRIDGE_REGS_H_/* Register Definitions */ +#define CUR_REGISTERMAP_VERSION 0x10003 +#define CUR_REGISTERMAP_VERSION_CI 0x10000 +#define CUR_REGISTERMAP_VERSION_MOD 0x10000 -#define CUR_REGISTERMAP_VERSION 0x10000 - -#define HARDWARE_VERSION 0x00 -#define REGISTERMAP_VERSION 0x04 +#define HARDWARE_VERSION 0x00 +#define REGISTERMAP_VERSION 0x04 -/* ------------------------------------------------------------------------- */ /* SPI Controller */ +#define SPI_CONTROL 0x10 +#define SPI_DATA 0x14 -#define SPI_CONTROL 0x10 -#define SPI_DATA 0x14 +/* GPIO */ +#define GPIO_OUTPUT 0x20 +#define GPIO_DIRECTION 0x28 -/* ------------------------------------------------------------------------- */ +/* MDIO */ +#define MDIO_CTRL 0x20 +#define MDIO_ADR 0x24 +#define MDIO_REG 0x28 +#define MDIO_VAL 0x2C -/* Interrupt controller */ -/* How many MSI's are available depends on HW (Min 2 max 8) */ -/* How many are usable also depends on Host platform */ +/* How many MSI's are available depends on HW (Min 2 max 8) +How many are usable also depends on Host platform */ +/* Interrupt controller */ #define INTERRUPT_BASE (0x40)#define INTERRUPT_ENABLE (INTERRUPT_BASE + 0x00)
@@ -57,95 +63,152 @@#define INTERRUPT_STATUS (INTERRUPT_BASE + 0x20)#define INTERRUPT_ACK (INTERRUPT_BASE + 0x20) -#define INTMASK_I2C1 (0x00000001) -#define INTMASK_I2C2 (0x00000002) -#define INTMASK_I2C3 (0x00000004) -#define INTMASK_I2C4 (0x00000008) - -#define INTMASK_CIRQ1 (0x00000010) -#define INTMASK_CIRQ2 (0x00000020) -#define INTMASK_CIRQ3 (0x00000040) -#define INTMASK_CIRQ4 (0x00000080) - -#define INTMASK_TSINPUT1 (0x00000100) -#define INTMASK_TSINPUT2 (0x00000200) -#define INTMASK_TSINPUT3 (0x00000400) -#define INTMASK_TSINPUT4 (0x00000800) -#define INTMASK_TSINPUT5 (0x00001000) -#define INTMASK_TSINPUT6 (0x00002000) -#define INTMASK_TSINPUT7 (0x00004000) -#define INTMASK_TSINPUT8 (0x00008000) - -#define INTMASK_TSOUTPUT1 (0x00010000) -#define INTMASK_TSOUTPUT2 (0x00020000) -#define INTMASK_TSOUTPUT3 (0x00040000) -#define INTMASK_TSOUTPUT4 (0x00080000) - -/* ------------------------------------------------------------------------- */ -/* I2C Master Controller */ - -#define I2C_BASE (0x80)/* Byte offset */ - -#define I2C_COMMAND (0x00) -#define I2C_TIMING (0x04) -#define I2C_TASKLENGTH (0x08)/* High read, low write */ -#define I2C_TASKADDRESS (0x0C)/* High read, low write */ +/* Clock Generator (Sil598 @ 0xAA I2c) */ +#define CLOCKGEN_BASE (0x80) +#define CLOCKGEN_CONTROL (CLOCKGEN_BASE + 0x00) +#define CLOCKGEN_INDEX (CLOCKGEN_BASE + 0x04) +#define CLOCKGEN_WRITEDATA (CLOCKGEN_BASE + 0x08) +#define CLOCKGEN_READDATA (CLOCKGEN_BASE + 0x0C) -#define I2C_MONITOR (0x1C) +/* DAC (AD9781/AD9783 SPI) */ +#define DAC_BASE (0x090) +#define DAC_CONTROL (DAC_BASE) +#define DAC_WRITE_DATA (DAC_BASE+4) +#define DAC_READ_DATA (DAC_BASE+8) -#define I2C_BASE_1 (I2C_BASE + 0x00) -#define I2C_BASE_2 (I2C_BASE + 0x20) -#define I2C_BASE_3 (I2C_BASE + 0x40) -#define I2C_BASE_4 (I2C_BASE + 0x60) +#define DAC_CONTROL_STARTIO (0x100) +#define DAC_CONTROL_RESET (0x200) -#define I2C_BASE_N (i) (I2C_BASE + (i) * 0x20) +/* Temperature Monitor (2x LM75A @ 0x90,0x92 I2c) */ +#define TEMPMON_BASE (0xA0) +#define TEMPMON_CONTROL (TEMPMON_BASE + 0x00) +#define TEMPMON_SENSOR1 (TEMPMON_BASE + 0x08) // SHORT Temperature in °C x 256 +#define TEMPMON_SENSOR2 (TEMPMON_BASE + 0x0C) // SHORT Temperature in °C x 256 -#define I2C_TASKMEM_BASE (0x1000)/* Byte offset */ -#define I2C_TASKMEM_SIZE (0x1000) - -#define I2C_SPEED_400 (0x04030404) -#define I2C_SPEED_200 (0x09080909) -#define I2C_SPEED_154 (0x0C0B0C0C) -#define I2C_SPEED_100 (0x13121313) -#define I2C_SPEED_77 (0x19181919) -#define I2C_SPEED_50 (0x27262727) - - -/* ------------------------------------------------------------------------- */ -/* DMA Controller */ - -#define DMA_BASE_WRITE (0x100) -#define DMA_BASE_READ (0x140) +/* I2C Master Controller */ +#define I2C_BASE (0x80)/* Byte offset */ -#define DMA_CONTROL (0x00)/* 64 */ -#define DMA_ERROR (0x04)/* 65 ( only read instance ) */ +#define I2C_COMMAND (0x00) +#define I2C_TIMING (0x04) +#define I2C_TASKLENGTH (0x08)/* High read, low write */ +#define I2C_TASKADDRESS (0x0C)/* High read, low write */ +#define I2C_TASKMEM_BASE (0x1000)/* Byte offset */ +#define I2C_TASKMEM_SIZE (0x0800) -#define DMA_DIAG_CONTROL (0x1C)/* 71 */ -#define DMA_DIAG_PACKETCOUNTER_LOW (0x20)/* 72 */ -#define DMA_DIAG_PACKETCOUNTER_HIGH (0x24)/* 73 */ -#define DMA_DIAG_TIMECOUNTER_LOW (0x28)/* 74 */ -#define DMA_DIAG_TIMECOUNTER_HIGH (0x2C)/* 75 */ -#define DMA_DIAG_RECHECKCOUNTER (0x30)/* 76 ( Split completions on read ) */ -#define DMA_DIAG_WAITTIMEOUTINIT (0x34)/* 77 */ -#define DMA_DIAG_WAITOVERFLOWCOUNTER (0x38)/* 78 */ -#define DMA_DIAG_WAITCOUNTER (0x3C)/* 79 */ +#define I2C_SPEED_400 (0x04030404) +#define I2C_SPEED_100 (0x13121313) -/* ------------------------------------------------------------------------- */ -/* DMA Buffer */ +/* DMA Controller */ +#define DMA_BASE_WRITE (0x100) +#define DMA_BASE_READ (0x140) +/* DMA Buffer */ #define TS_INPUT_BASE (0x200) -#define TS_INPUT_CONTROL (i) (TS_INPUT_BASE + (i) * 16 + 0x00) +#define TS_INPUT_CONTROL (i) (TS_INPUT_BASE + (i) * 0x10 + 0x00) +#define TS_INPUT_CONTROL2 (i) (TS_INPUT_BASE + (i) * 0x10 + 0x04) -#define TS_OUTPUT_BASE (0x280) -#define TS_OUTPUT_CONTROL (i) (TS_OUTPUT_BASE + (i) * 16 + 0x00) +#define TS_OUTPUT_BASE (0x280) +#define TS_OUTPUT_CONTROL (i) (TS_OUTPUT_BASE + (i) * 0x10 + 0x00) +#define TS_OUTPUT_CONTROL2 (i) (TS_OUTPUT_BASE + (i) * 0x10 + 0x04)#define DMA_BUFFER_BASE (0x300) - -#define DMA_BUFFER_CONTROL (i) (DMA_BUFFER_BASE + (i) * 16 + 0x00) -#define DMA_BUFFER_ACK (i) (DMA_BUFFER_BASE + (i) * 16 + 0x04) -#define DMA_BUFFER_CURRENT (i) (DMA_BUFFER_BASE + (i) * 16 + 0x08) -#define DMA_BUFFER_SIZE (i) (DMA_BUFFER_BASE + (i) * 16 + 0x0c) +#define DMA_BUFFER_CONTROL (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x00) +#define DMA_BUFFER_ACK (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x04) +#define DMA_BUFFER_CURRENT (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x08) +#define DMA_BUFFER_SIZE (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x0c)#define DMA_BASE_ADDRESS_TABLE (0x2000) -#define DMA_BASE_ADDRESS_TABLE_ENTRIES (512) +/* CI Interface (only CI-Bridge) */ +#define CI_BASE (0x400) +#define CI_CONTROL (i) (CI_BASE + (i) * 32 + 0x00) + +#define CI_DO_ATTRIBUTE_RW (i) (CI_BASE + (i) * 32 + 0x04) +#define CI_DO_IO_RW (i) (CI_BASE + (i) * 32 + 0x08) +#define CI_READDATA (i) (CI_BASE + (i) * 32 + 0x0c) +#define CI_DO_READ_ATTRIBUTES (i) (CI_BASE + (i) * 32 + 0x10) + +#define CI_RESET_CAM (0x00000001) +#define CI_POWER_ON (0x00000002) +#define CI_ENABLE (0x00000004) +#define CI_BYPASS_DISABLE (0x00000010) + +#define CI_CAM_READY (0x00010000) +#define CI_CAM_DETECT (0x00020000) +#define CI_READY (0x80000000) + +#define CI_READ_CMD (0x40000000) +#define CI_WRITE_CMD (0x80000000) + +#define CI_BUFFER_BASE (0x3000) +#define CI_BUFFER_SIZE (0x0800) + +#define CI_BUFFER (i) (CI_BUFFER_BASE + (i) * CI_BUFFER_SIZE ) + +#define VCO1_BASE (0xC0) +#define VCO1_CONTROL (VCO1_BASE + 0x00) +#define VCO1_DATA (VCO1_BASE + 0x04) // 24 Bit +#define VCO1_CONTROL_WRITE (0x00000001) // 1 = Trigger write, resets when done +#define VCO1_CONTROL_CE (0x00000002) // 0 = Put VCO into power down + +#define VCO2_BASE (0xC8) +#define VCO2_CONTROL (VCO2_BASE + 0x00) +#define VCO2_DATA (VCO2_BASE + 0x04) // 24 Bit +#define VCO2_CONTROL_WRITE (0x00000001) // 1 = Trigger write, resets when done +#define VCO2_CONTROL_CE (0x00000002) // 0 = Put VCO into power down + +#define VCO3_BASE (0xD0) +#define VCO3_CONTROL (VCO3_BASE + 0x00) +#define VCO3_DATA (VCO3_BASE + 0x04) // 32 Bit +#define VCO3_CONTROL_WRITE (0x00000001) // 1 = Trigger write, resets when done +#define VCO3_CONTROL_CE (0x00000002) // 0 = Put VCO into power down + +#define RF_ATTENUATOR (0xD8) + +/* Output control */ +#define IQOUTPUT_BASE (0x240) +#define IQOUTPUT_CONTROL (IQOUTPUT_BASE + 0x00) +#define IQOUTPUT_CONTROL2 (IQOUTPUT_BASE + 0x04) +#define IQOUTPUT_POSTSCALER (IQOUTPUT_BASE + 0x0C) +#define IQOUTPUT_PRESCALER (IQOUTPUT_BASE + 0x10) + +#define IQOUTPUT_EQUALIZER_0 (IQOUTPUT_BASE + 0x14) + +#define IQOUTPUT_CONTROL_RESET (0x00000001) +#define IQOUTPUT_CONTROL_ENABLE (0x00000002) +#define IQOUTPUT_CONTROL_BYPASS_EQUALIZER (0x00000010) + +#define MODULATOR_BASE (0x200) +#define MODULATOR_CONTROL (MODULATOR_BASE) +#define MODULATOR_IQTABLE_END (MODULATOR_BASE+4) +#define MODULATOR_IQTABLE_INDEX (MODULATOR_BASE+8) +#define MODULATOR_IQTABLE_DATA (MODULATOR_BASE+12) + +#define MODULATOR_IQTABLE_INDEX_IQ_MASK ( 0x00008000 ) +#define MODULATOR_IQTABLE_INDEX_SEL_I ( 0x00000000 ) +#define MODULATOR_IQTABLE_INDEX_SEL_Q ( MODULATOR_IQTABLE_INDEX_IQ_MASK ) + +/* Modulator Channels */ +#define CHANNEL_BASE (0x400) +#define CHANNEL_CONTROL (i) (CHANNEL_BASE + (i) * 64 + 0x00) +#define CHANNEL_SETTINGS (i) (CHANNEL_BASE + (i) * 64 + 0x04) +#define CHANNEL_RATE_INCR (i) (CHANNEL_BASE + (i) * 64 + 0x0C) +#define CHANNEL_PCR_ADJUST_OUTL (i) (CHANNEL_BASE + (i) * 64 + 0x10) +#define CHANNEL_PCR_ADJUST_OUTH (i) (CHANNEL_BASE + (i) * 64 + 0x14) +#define CHANNEL_PCR_ADJUST_INL (i) (CHANNEL_BASE + (i) * 64 + 0x18) +#define CHANNEL_PCR_ADJUST_INH (i) (CHANNEL_BASE + (i) * 64 + 0x1C) +#define CHANNEL_PCR_ADJUST_ACCUL (i) (CHANNEL_BASE + (i) * 64 + 0x20) +#define CHANNEL_PCR_ADJUST_ACCUH (i) (CHANNEL_BASE + (i) * 64 + 0x24) +#define CHANNEL_PKT_COUNT_OUT (i) (CHANNEL_BASE + (i) * 64 + 0x28) +#define CHANNEL_PKT_COUNT_IN (i) (CHANNEL_BASE + (i) * 64 + 0x2C) + +#define CHANNEL_CONTROL_RESET (0x00000001) +#define CHANNEL_CONTROL_ENABLE_DVB (0x00000002) +#define CHANNEL_CONTROL_ENABLE_IQ (0x00000004) +#define CHANNEL_CONTROL_ENABLE_SOURCE (0x00000008) +#define CHANNEL_CONTROL_ENABLE_PCRADJUST (0x00000010) +#define CHANNEL_CONTROL_FREEZE_STATUS (0x00000100) + +#define CHANNEL_CONTROL_BUSY (0x01000000) + +#endif
Signature · 1 line
1.8.4.2
PATCH 1/12 dvb-frontends: Support for DVB-C2 to DVB frontends
In reply to Maik BroemmeAdded support for DVB-C2 to DVB frontends. It will be required by cxd2843 and tda18212dd (Digital Devices) frontends.
--- include/uapi/linux/dvb/frontend.h | 1 + 1 file changed, 1 insertion(+)
include/uapi/linux/dvb/frontend.h +1 -0
@@ -410,6 +410,7 @@ typedef enum fe_delivery_system {SYS_DVBT2 ,SYS_TURBO ,SYS_DVBC_ANNEX_C , +SYS_DVBC2 , } fe_delivery_system_t;/* backward compatibility */
Signature · 1 line
1.8.4.2
PATCH 2/12 tda18271c2dd: Fix description of NXP TDA18271C2 silicon tuner
In reply to Maik BroemmeAdded (DD) to NXP TDA18271C2 silicon tuner as this tuner was specifically added for Digital Devices ddbridge driver.
--- drivers/media/dvb-frontends/Kconfig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/media/dvb-frontends/Kconfig +2 -2
@@ -48,11 +48,11 @@ config DVB_DRXK Say Y when you want to support this frontend. config DVB_TDA18271C2DD - tristate "NXP TDA18271C2 silicon tuner" + tristate "NXP TDA18271C2 silicon tuner (DD)" depends on DVB_CORE && I2C default m if !MEDIA_SUBDRV_AUTOSELECT help - NXP TDA18271 silicon tuner. + NXP TDA18271 silicon tuner (Digital Devices driver). Say Y when you want to support this tuner.
Signature · 1 line
1.8.4.2
cover DDBridge 0.9.10 driver updates
I've updated the current DDBridge to latest version 0.9.10 from Ralph Metzler available at:
http://www.metzlerbros.de/dddvb/dddvb-0.9.10.tar.bz2
I've merged the driver to work with current v4l/dvb tree and I will maintain the driver for v4l/dvb in future. The coming patch series is the first version and I explicitly want to get feedback and hints if some parts are merged at wrong places, etc... The following changes were made:
- MSI enabled by default (some issues left with i2c timeouts)
- no support for Digital Devices Octonet
- no support for DVB Netstream
- removed unused module parameters 'tt' and 'vlan' (used by Octonet)
- removed unused registers to cleanup code (might be added later again if needed)
The following devices are supported by the driver update:
- Octopus DVB adapter
- Octopus V3 DVB adapter
- Octopus LE DVB adapter
- Octopus OEM
- Octopus Mini
- Cine S2 V6 DVB adapter
- Cine S2 V6.5 DVB adapter
- Octopus CI
- Octopus CI single
- DVBCT V6.1 DVB adapter
- DVB-C modulator
- SaTiX-S2 V3 DVB adapter
I might merge the Octonet and DVB Netstream drivers from Ralphs source later once the current committed DDBridge driver updates are merged in mainline.
Maik Broemme (12):
dvb-frontends: Support for DVB-C2 to DVB frontends
tda18271c2dd: Fix description of NXP TDA18271C2 silicon tuner
stv0367dd: Support for STV 0367 DVB-C/T (DD) demodulator
tda18212dd: Support for NXP TDA18212 (DD) silicon tuner
cxd2843: Support for CXD2843ER demodulator for DVB-T/T2/C/C2
dvb-core: export dvb_usercopy and new DVB device constants
ddbridge: Updated ddbridge registers
ddbridge: Moved i2c interfaces into separate file
ddbridge: Support for the Digital Devices Resi DVB-C Modulator card
ddbridge: Update ddbridge driver to version 0.9.10
ddbridge: Update ddbridge header for 0.9.10 changes
ddbridge: Kconfig and Makefile fixes to build latest ddbridge
drivers/media/dvb-core/dvbdev.c | 1 drivers/media/dvb-core/dvbdev.h | 2 drivers/media/dvb-frontends/Kconfig | 31 drivers/media/dvb-frontends/Makefile | 3 drivers/media/dvb-frontends/cxd2843.c | 1647 ++++++++++++ drivers/media/dvb-frontends/cxd2843.h | 47 drivers/media/dvb-frontends/stv0367dd.c | 2329 ++++++++++++++++++ drivers/media/dvb-frontends/stv0367dd.h | 48 drivers/media/dvb-frontends/stv0367dd_regs.h | 3442 +++++++++++++++++++++++++++ drivers/media/dvb-frontends/tda18212dd.c | 934 +++++++ drivers/media/dvb-frontends/tda18212dd.h | 37 drivers/media/pci/ddbridge/Kconfig | 21 drivers/media/pci/ddbridge/Makefile | 2 drivers/media/pci/ddbridge/ddbridge-core.c | 3085 +++++++++++++++++------- drivers/media/pci/ddbridge/ddbridge-i2c.c | 239 + drivers/media/pci/ddbridge/ddbridge-mod.c | 1033 ++++++++ drivers/media/pci/ddbridge/ddbridge-regs.h | 273 +- drivers/media/pci/ddbridge/ddbridge.h | 408 ++- include/uapi/linux/dvb/frontend.h | 1 19 files changed, 12555 insertions(+), 1028 deletions(-)
--Maik
PATCH 8/12 ddbridge: Moved i2c interfaces into separate file
Moved i2c interfaces from ddbridge-core.c into separate file.
--- drivers/media/pci/ddbridge/ddbridge-i2c.c | 239 ++++++++++++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 drivers/media/pci/ddbridge/ddbridge-i2c.c
drivers/media/pci/ddbridge/ddbridge-i2c.c new file +239 -0
@@ -0,0 +1,239 @@ +/* +* ddbridge-i2c.c: Digital Devices bridge i2c driver +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include "ddbridge.h" +#include "ddbridge-regs.h" + +static int i2c_cmd (struct ddb_i2c *i2c,u32 adr,u32 cmd) +{ +struct ddb *dev = i2c->dev; +int stat; +u32 val; +u32 istat; + +// i2c->done = 0; +ddbwritel (dev, (adr <<9 ) | cmd, i2c->regs +I2C_COMMAND ); + +// TODO: fix timeout issue. +// stat = wait_event_timeout(i2c->wq, i2c->done == 1, HZ); + stat =wait_for_completion_timeout (&i2c->completion,HZ ); +if (stat <=0 ) { +printk (KERN_ERR "DDBridge I2C timeout, card %d, port %d\n" , + dev->nr, i2c->nr); + istat =ddbreadl (dev,INTERRUPT_STATUS ); +printk (KERN_ERR "DDBridge IRS %08x\n" , istat); +ddbwritel (dev, istat,INTERRUPT_ACK ); +return -EIO ; + } + val =ddbreadl (dev, i2c->regs +I2C_COMMAND ); +if (val &0x70000 ) +return -EIO ; +return 0 ; +} + +static int i2c_master_xfer (struct i2c_adapter *adapter, +struct i2c_msg msg[],int num) +{ +struct ddb_i2c *i2c = (struct ddb_i2c *)i2c_get_adapdata (adapter); +struct ddb *dev = i2c->dev; +u8 addr =0 ; + +if (num) + addr = msg[0 ].addr; +if (num ==2 && msg[1 ].flags &I2C_M_RD && + !(msg[0 ].flags &I2C_M_RD )) { +memcpy_toio (dev->regs +I2C_TASKMEM_BASE + i2c->wbuf, + msg[0 ].buf, msg[0 ].len); +ddbwritel (dev, msg[0 ].len|(msg[1 ].len <<16 ), + i2c->regs +I2C_TASKLENGTH ); +if (!i2c_cmd (i2c, addr,1 )) { +memcpy_fromio (msg[1 ].buf, + dev->regs +I2C_TASKMEM_BASE + i2c->rbuf, + msg[1 ].len); +return num; + } + } +if (num ==1 && !(msg[0 ].flags &I2C_M_RD )) { +ddbcpyto (dev,I2C_TASKMEM_BASE + i2c->wbuf, + msg[0 ].buf, msg[0 ].len); +ddbwritel (dev, msg[0 ].len, i2c->regs +I2C_TASKLENGTH ); +if (!i2c_cmd (i2c, addr,2 )) { +return num; + } + } +if (num ==1 && (msg[0 ].flags &I2C_M_RD )) { +ddbwritel (dev, msg[0 ].len <<16 , i2c->regs +I2C_TASKLENGTH ); +if (!i2c_cmd (i2c, addr,3 )) { +ddbcpyfrom (dev, msg[0 ].buf, +I2C_TASKMEM_BASE + i2c->rbuf, msg[0 ].len); +return num; + } + } +return -EIO ; +} + +static u32 i2c_functionality (struct i2c_adapter *adap) +{ +return I2C_FUNC_SMBUS_EMUL ; +} + +static void i2c_handler (unsigned long priv) +{ +struct ddb_i2c *i2c = (struct ddb_i2c *) priv; + +complete (&i2c->completion); +} + +static struct i2c_algorithm i2c_algo = { + .master_xfer = i2c_master_xfer, + .functionality = i2c_functionality, +}; + +int ddb_i2c_write (struct i2c_adapter *adap,u8 adr,u8 *data,int len) +{ +struct i2c_msg msg = {.addr = adr, .flags =0 , .buf = data, .len = len}; + +return (i2c_transfer (adap, &msg,1 ) ==1 ) ?0 :-1 ; +} + +int ddb_i2c_read (struct i2c_adapter *adapter,u8 adr,u8 *val) +{ +struct i2c_msg msgs[1 ] = {{.addr = adr, .flags =I2C_M_RD , + .buf = val, .len =1 } }; +return (i2c_transfer (adapter, msgs,1 ) ==1 ) ?0 :-1 ; +} + +int ddb_i2c_read_regs (struct i2c_adapter *adapter, +u8 adr,u8 reg,u8 *val,u8 len) +{ +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = ®, .len =1 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len = len } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_read_regs16 (struct i2c_adapter *adapter, +u8 adr,u16 reg,u8 *val,u8 len) +{ +u8 reg16[2 ] = { reg >>8 , reg }; +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = reg16, .len =2 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len = len } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_read_reg (struct i2c_adapter *adapter,u8 adr,u8 reg,u8 *val) +{ +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = ®, .len =1 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len =1 } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_read_reg16 (struct i2c_adapter *adapter,u8 adr, +u16 reg,u8 *val) +{ +u8 msg[2 ] = {reg >>8 , reg &0xff }; +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = msg, .len =2 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len =1 } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_write_reg16 (struct i2c_adapter *adap,u8 adr, +u16 reg,u8 val) +{ +u8 msg[3 ] = {reg >>8 , reg &0xff , val}; + +return ddb_i2c_write (adap, adr, msg,3 ); +} + +int ddb_i2c_write_reg (struct i2c_adapter *adap,u8 adr, +u8 reg,u8 val) +{ +u8 msg[2 ] = {reg, val}; + +return ddb_i2c_write (adap, adr, msg,2 ); +} + +void ddb_i2c_release (struct ddb *dev) +{ +int i; +struct ddb_i2c *i2c; +struct i2c_adapter *adap; + +for (i =0 ; i < dev->info->i2c_num; i++) { + i2c = &dev->i2c[i]; + adap = &i2c->adap; +i2c_del_adapter (adap); + } +} + +int ddb_i2c_init (struct ddb *dev) +{ +int i, j, stat =0 ; +struct ddb_i2c *i2c; +struct i2c_adapter *adap; + +for (i =0 ; i < dev->info->i2c_num; i++) { + i2c = &dev->i2c[i]; + dev->handler[i] = i2c_handler; + dev->handler_data[i] = (unsigned long ) i2c; + i2c->dev = dev; + i2c->nr = i; + i2c->wbuf = i * (I2C_TASKMEM_SIZE /4 ); + i2c->rbuf = i2c->wbuf + (I2C_TASKMEM_SIZE /8 ); + i2c->regs =0x80 + i *0x20 ; +ddbwritel (dev,I2C_SPEED_100 , i2c->regs +I2C_TIMING ); +ddbwritel (dev, (i2c->rbuf <<16 ) | i2c->wbuf, + i2c->regs +I2C_TASKADDRESS ); +// init_waitqueue_head(&i2c->wq); +init_completion (&i2c->completion); + + adap = &i2c->adap; +i2c_set_adapdata (adap, i2c); +#ifdef I2C_ADAP_CLASS_TV_DIGITAL + adap->class =I2C_ADAP_CLASS_TV_DIGITAL |I2C_CLASS_TV_ANALOG ; +#else +#ifdef I2C_CLASS_TV_ANALOG + adap->class =I2C_CLASS_TV_ANALOG ; +#endif +#endif +strcpy (adap->name,"ddbridge" ); + adap->algo = &i2c_algo; + adap->algo_data = (void *)i2c; + adap->dev.parent = dev->dev; + stat =i2c_add_adapter (adap); +if (stat) +break ; + } +if (stat) +for (j =0 ; j < i; j++) { + i2c = &dev->i2c[j]; + adap = &i2c->adap; +i2c_del_adapter (adap); + } +return stat; +}
Signature · 1 line
1.8.4.2
PATCH 9/12 ddbridge: Support for the Digital Devices Resi DVB-C Modulator card
In reply to Maik BroemmeAdded support for the Digital Devices Resi DVB-C Modulator card.
--- drivers/media/pci/ddbridge/ddbridge-mod.c | 1033 +++++++++++++++++++++++++++++ 1 file changed, 1033 insertions(+) create mode 100644 drivers/media/pci/ddbridge/ddbridge-mod.c
drivers/media/pci/ddbridge/ddbridge-mod.c new file +1033 -0
@@ -0,0 +1,1033 @@ +/* +* ddbridge-mod.c: Digital Devices DVB modulator driver +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include "ddbridge.h" +#include "ddbridge-regs.h" + +inline s64 ConvertPCR (s64 a) +{ +s32 ext; +s64 b; + + b =div_s64_rem (a,300 <<22 , &ext); + +return (b <<31 ) | ext; + +} + +inline s64 NegConvertPCR (s64 a) +{ +s32 ext; +s64 b; + + b = -div_s64_rem (a,300 <<22 , &ext); + +if ( ext !=0 ) { + ext = (300 <<22 ) - ext; + b -=1 ; + } +return (b <<31 ) | ext; +} + +inline s64 RoundPCR (s64 a) +{ +s64 b = a + (HW_LSB_MASK >>1 ); +return b & ~(HW_LSB_MASK -1 ); +} + +inline s64 RoundPCRUp (s64 a) +{ +s64 b = a + (HW_LSB_MASK -1 ); +return b & ~(HW_LSB_MASK -1 ); +} + +inline s64 RoundPCRDown (s64 a) +{ +return a & ~(HW_LSB_MASK -1 ); +} + +static int mod_busy (struct ddb *dev,int chan) +{ +u32 creg; + +while (1 ) { + creg =ddbreadl (dev,CHANNEL_CONTROL (chan)); +if (creg ==0xffffffff ) +return -EFAULT ; +if ((creg &CHANNEL_CONTROL_BUSY ) ==0 ) +break ; + } +return 0 ; +} + +void ddbridge_mod_output_stop (struct ddb_output *output) +{ +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + + mod->State =CM_IDLE ; + mod->Control =0 ; +ddbwritel (dev,0 ,CHANNEL_CONTROL (output->nr)); + +mod_busy (dev, output->nr); +printk ("mod_output_stop %d.%d\n" , dev->nr, output->nr); +} + +static void mod_set_incs (struct ddb_output *output) +{ +s64 pcr; +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + + pcr =ConvertPCR (mod->PCRIncrement); +ddbwritel (dev, pcr &0xffffffff , +CHANNEL_PCR_ADJUST_OUTL (output->nr)); +ddbwritel (dev, (pcr >>32 ) &0xffffffff , +CHANNEL_PCR_ADJUST_OUTH (output->nr)); +mod_busy (dev, output->nr); + + pcr =NegConvertPCR (mod->PCRDecrement); +ddbwritel (dev, pcr &0xffffffff , +CHANNEL_PCR_ADJUST_INL (output->nr)); +ddbwritel (dev, (pcr >>32 ) &0xffffffff , +CHANNEL_PCR_ADJUST_INH (output->nr)); +mod_busy (dev, output->nr); + +} + +static u32 qamtab[6 ] = {0x000 ,0x600 ,0x601 ,0x602 ,0x903 ,0x604 }; + +void ddbridge_mod_output_start (struct ddb_output *output) +{ +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + +// PCRIncrement = RoundPCR(PCRIncrement); +// PCRDecrement = RoundPCR(PCRDecrement); + + mod->LastInPacketCount =0 ; + mod->LastOutPacketCount =0 ; + mod->InOverflowPacketCount =0 ; + mod->OutOverflowPacketCount =0 ; + mod->LastInPackets =0 ; + mod->LastOutPackets =0 ; + mod->LastPCRAdjust =0 ; + mod->PCRRunningCorr =0 ; + mod->MinInputPackets =524288 /2 ;// we interrupt every 0x80000=524288 packets + mod->PCRIncrement =0 ;// PCRIncrement; + mod->PCRDecrement =0 ;// PCRDecrement; + + mod->State =CM_STARTUP ; + mod->StateCounter =CM_STARTUP_DELAY ; + +ddbwritel (dev,0 ,CHANNEL_CONTROL (output->nr)); +udelay (10 ); +ddbwritel (dev,CHANNEL_CONTROL_RESET ,CHANNEL_CONTROL (output->nr)); +udelay (10 ); +ddbwritel (dev,0 ,CHANNEL_CONTROL (output->nr)); + +// QAM: 600 601 602 903 604 = 16 32 64 128 256 +// ddbwritel(dev, 0x604, CHANNEL_SETTINGS(output->nr)); +ddbwritel (dev, qamtab[mod->modulation],CHANNEL_SETTINGS (output->nr)); + +ddbwritel (dev, mod->rate_inc,CHANNEL_RATE_INCR (output->nr)); +mod_busy (dev, output->nr); + +mod_set_incs (output); + + mod->Control = (CHANNEL_CONTROL_ENABLE_IQ | +CHANNEL_CONTROL_ENABLE_DVB | +CHANNEL_CONTROL_ENABLE_SOURCE ); + +ddbwritel (dev, mod->Control,CHANNEL_CONTROL (output->nr)); +printk ("mod_output_start %d.%d\n" , dev->nr, output->nr); +} + +static void mod_write_dac_register (struct ddb *dev,u8 Index,u8 Value) +{ +u32 RegValue =0 ; + +ddbwritel (dev, Value,DAC_WRITE_DATA ); +ddbwritel (dev,DAC_CONTROL_STARTIO | Index,DAC_CONTROL ); +do { + RegValue =ddbreadl (dev,DAC_CONTROL ); + }while ((RegValue &DAC_CONTROL_STARTIO ) !=0 ); +} + +static void mod_write_dac_register2 (struct ddb *dev,u8 Index,u16 Value) +{ +u32 RegValue =0 ; + +ddbwritel (dev, Value,DAC_WRITE_DATA ); +ddbwritel (dev,DAC_CONTROL_STARTIO |0x20 | Index,DAC_CONTROL ); +do { + RegValue =ddbreadl (dev,DAC_CONTROL ); + }while ((RegValue &DAC_CONTROL_STARTIO ) !=0 ); +} + +static int mod_read_dac_register (struct ddb *dev,u8 Index,u8 *pValue) +{ +u32 RegValue =0 ; + +ddbwritel (dev,DAC_CONTROL_STARTIO |0x80 | Index,DAC_CONTROL ); +do { + RegValue =ddbreadl (dev,DAC_CONTROL ); + }while ( (RegValue &DAC_CONTROL_STARTIO ) !=0 ); + + RegValue =ddbreadl (dev,DAC_READ_DATA ); + *pValue = (u8 ) RegValue; +return 0 ; +} + +static void mod_set_up_converter_vco1 (struct ddb *dev,u32 Value) +{ +u32 RegValue =0 ; + +/* Extra delay before writing N divider */ +if ((Value &0x03 ) ==0x02 ) +msleep (50 ); +do { + RegValue =ddbreadl (dev,VCO1_CONTROL ); + }while ( (RegValue &VCO1_CONTROL_WRITE ) !=0 ); + +if ((RegValue &VCO1_CONTROL_CE ) ==0 ) { + RegValue |=VCO1_CONTROL_CE ; +ddbwritel (dev, RegValue,VCO1_CONTROL ); +msleep (10 ); + } + +ddbwritel (dev, Value,VCO1_DATA ); +ddbwritel (dev, RegValue |VCO1_CONTROL_WRITE ,VCO1_CONTROL ); +} + +static void mod_set_up_converter_vco2 (struct ddb *dev,u32 Value) +{ +u32 RegValue =0 ; + +/* Extra delay before writing N divider */ +if ((Value &0x03 ) ==0x02 ) +msleep (50 ); +do { + RegValue =ddbreadl (dev,VCO2_CONTROL ); + }while ((RegValue &VCO2_CONTROL_WRITE ) !=0 ); + +if ((RegValue &VCO2_CONTROL_CE ) ==0 ) { + RegValue |=VCO2_CONTROL_CE ; +ddbwritel (dev, RegValue,VCO2_CONTROL ); +msleep (10 ); + } + +ddbwritel (dev, Value,VCO2_DATA ); +ddbwritel (dev, RegValue |VCO2_CONTROL_WRITE ,VCO2_CONTROL ); +} + +static void mod_set_down_converter_vco (struct ddb *dev,u32 Value) +{ +u32 RegValue =0 ; + +do { + RegValue =ddbreadl (dev,VCO3_CONTROL ); + }while ( (RegValue &VCO3_CONTROL_WRITE ) !=0 ); + +if ((RegValue &VCO3_CONTROL_CE ) ==0 ) { + RegValue |=VCO3_CONTROL_CE ; +ddbwritel (dev, RegValue,VCO3_CONTROL ); +msleep (10 ); + } +ddbwritel (dev, Value,VCO3_DATA ); +ddbwritel (dev, RegValue |VCO3_CONTROL_WRITE ,VCO3_CONTROL ); +} + +static int mod_set_attenuator (struct ddb *dev,u32 Value) +{ +if (Value >31 ) +return -EINVAL ; +ddbwritel (dev, Value,RF_ATTENUATOR ); +return 0 ; +} + +static void mod_si598_readreg (struct ddb *dev,u8 index,u8 *val) +{ +ddbwritel (dev, index,CLOCKGEN_INDEX ); +ddbwritel (dev,1 ,CLOCKGEN_CONTROL ); +msleep (5 ); + *val =ddbreadl (dev,CLOCKGEN_READDATA ); +} + +static void mod_si598_writereg (struct ddb *dev,u8 index,u8 val) +{ +ddbwritel (dev, index,CLOCKGEN_INDEX ); +ddbwritel (dev, val,CLOCKGEN_WRITEDATA ); +ddbwritel (dev,3 ,CLOCKGEN_CONTROL ); +msleep (5 ); +} + +static int mod_set_si598 (struct ddb *dev,u32 freq) +{ +u8 Data[6 ]; +u64 fDCO =0 ; +u64 RFreq =0 ; +u32 fOut =10000000 ; +u64 m_fXtal =0 ; +u32 N =0 ; +u64 HSDiv =0 ; + +u32 fxtal; +u64 MinDiv, MaxDiv, Div; +u64 RF ; + +if (freq <10000000 || freq >525000000 ) +return -EINVAL ; +mod_si598_writereg (dev,137 ,0x10 ); + +if (m_fXtal ==0 ) { +mod_si598_writereg (dev,135 ,0x01 ); +mod_si598_readreg (dev,7 , &Data[0 ]); +mod_si598_readreg (dev,8 , &Data[1 ]); +mod_si598_readreg (dev,9 , &Data[2 ]); +mod_si598_readreg (dev,10 , &Data[3 ]); +mod_si598_readreg (dev,11 , &Data[4 ]); +mod_si598_readreg (dev,12 , &Data[5 ]); + +printk (" Data = %02x %02x %02x %02x %02x %02x\n" , + Data[0 ],Data[1 ],Data[2 ],Data[3 ],Data[4 ],Data[5 ]); + RFreq = (((u64 )Data[1 ] &0x3F ) <<32 ) | ((u64 )Data[2 ] <<24 ) | + ((u64 )Data[3 ] <<16 ) | ((u64 )Data[4 ] <<8 ) | ((u64 )Data[5 ]); +if (RFreq ==0 ) +return -EINVAL ; + HSDiv = ((Data[0 ] &0xE0 ) >>5 ) +4 ; +if (HSDiv ==8 || HSDiv ==10 ) +return -EINVAL ; +N = (((u32)(Data[0 ] &0x1F ) <<2 ) | ((u32)(Data[1 ] &0xE0 ) >>6 )) +1 ; + fDCO = fOut * (u64)(HSDiv *N ); + m_fXtal = fDCO <<28 ; +printk ("fxtal %016llx rfreq %016llx\n" , m_fXtal, RFreq); + + m_fXtal += RFreq >>1 ; + m_fXtal =div64_u64 (m_fXtal, RFreq); + +printk (" fOut = %d fXtal = %d fDCO = %d HDIV = %2d, N = %3d \n" , + (u32 ) fOut, (u32 ) m_fXtal, (u32 ) fDCO, (u32 ) HSDiv,N ); + } + + fOut = freq; + MinDiv =4850000000ULL ;do_div (MinDiv, freq); MinDiv +=1 ; + MaxDiv =5670000000ULL ;do_div (MaxDiv, freq); + Div =5260000000ULL ;do_div (Div, freq); + +if ( Div < MinDiv ) + Div = Div +1 ; +printk (" fOut = %d MinDiv = %4d MaxDiv = %4d StartDiv = %d\n" , fOut, (u32 ) MinDiv, (u32 ) MaxDiv, (u32 ) Div); + +if ( Div <=11 ) { +N =1 ; + HSDiv = Div; + }else { +int retry =100 ; +while (retry >0 ) { +N =0 ; + HSDiv = Div; +while ( (HSDiv >11 )/*|| ((HSDiv * N) != Div)*/ ) { +N =N +2 ; + HSDiv = Div; +do_div (HSDiv,N ); +if (N >128 ) +break ; + } +printk (" %3d: %llu %u %u %u\n" , retry, Div, (u32 ) HSDiv*N , (u32 ) HSDiv,N ); +if (HSDiv *N < MinDiv) { + Div = Div +2 ; + }else if (HSDiv *N > MaxDiv) { + Div = Div -2 ; + }else +break ; + retry = retry -1 ; + } +if ( retry ==0 ) { +printk (" FAIL \n" ); +return -EINVAL ; + } + } + +if (HSDiv ==8 || HSDiv ==10 ) { + HSDiv = HSDiv >>1 ; +N =N *2 ; + } + +if (HSDiv <4 ) +return -EINVAL ; + + + fDCO = (u64 )fOut * (u64 )N * (u64 )HSDiv; +printk ("fdco %16llx\n" , fDCO); + RFreq = fDCO<<28 ; +printk ("%16llx %16llx\n" , fDCO, RFreq); + + fxtal = m_fXtal; +do_div (RFreq, fxtal); +printk ("%16llx %d\n" , RFreq, fxtal); +RF = RFreq; + +// printk("fOut = %d fXtal = %d fDCO = %d HDIV = %d, N = %d, RFreq = %d\n",fOut,m_fXtal,fDCO,HSDiv,N,RFreq); +// printk("%16llx\n", RF); + + Data[0 ] = (u8)( ((HSDiv -4 ) <<5 ) | ((N -1 ) >>2 ) ); + Data[1 ] = (u8)( (((N -1 ) &0x03 ) <<6 ) | ((RF >>32 ) &0x3F ) ); + Data[2 ] = (u8)( (RF >>24 ) &0xFF ); + Data[3 ] = (u8)( (RF >>16 ) &0xFF ); + Data[4 ] = (u8)( (RF >>8 ) &0xFF ); + Data[5 ] = (u8)( (RF ) &0xFF ); + +printk (" Data = %02x %02x %02x %02x %02x %02x\n" , + Data[0 ], Data[1 ], Data[2 ], Data[3 ], Data[4 ], Data[5 ]); +mod_si598_writereg (dev,7 , Data[0 ]); +mod_si598_writereg (dev,8 , Data[1 ]); +mod_si598_writereg (dev,9 , Data[2 ]); +mod_si598_writereg (dev,10 , Data[3 ]); +mod_si598_writereg (dev,11 , Data[4 ]); +mod_si598_writereg (dev,12 , Data[5 ]); + +mod_si598_writereg (dev,137 ,0x00 ); +mod_si598_writereg (dev,135 ,0x40 ); +return 0 ; +} + + +static void mod_bypass_equalizer (struct ddb *dev,int bypass) +{ +u32 RegValue; + + RegValue =ddbreadl (dev,IQOUTPUT_CONTROL ); + RegValue &= ~IQOUTPUT_CONTROL_BYPASS_EQUALIZER ; + RegValue |= (bypass ?IQOUTPUT_CONTROL_BYPASS_EQUALIZER :0x00 ); +ddbwritel (dev, RegValue,IQOUTPUT_CONTROL ); +} + +static int mod_set_equalizer (struct ddb *dev,u32 Num,s16 *cTable) +{ +u32 i, adr =IQOUTPUT_EQUALIZER_0 ; + +if (Num >11 ) +return -EINVAL ; + +for (i =0 ; i <11 - Num; i +=1 ) { +ddbwritel (dev,0 , adr); + adr +=4 ; + } +for (i =0 ; i < Num; i +=1 ) { +ddbwritel (dev, (u32 ) cTable[i], adr); + adr +=4 ; + } +return 0 ; +} + +static int mod_init_dac_input (struct ddb *dev) +{ +u8 Set =0 ; +u8 Hld =0 ; +u8 Sample =0 ; + +u8 Seek =0 ; +u8 ReadSeek =0 ; + +u8 SetTable[32 ]; +u8 HldTable[32 ]; +u8 SeekTable[32 ]; + +u8 Sample1 =0xFF ; +u8 Sample2 =0xFF ; + +u8 SelectSample =0xFF ; +u8 DiffMin =0xFF ; + +for (Sample =0 ; Sample <32 ; Sample++ ) { + Set =0 ; + Hld =0 ; + +mod_write_dac_register (dev,0x04 , Set <<4 | Hld); +mod_write_dac_register (dev,0x05 , Sample); +mod_read_dac_register (dev,0x06 , &ReadSeek); + Seek = ReadSeek &0x01 ; + SeekTable[Sample] = Seek; + + HldTable[Sample] =15 ; + +for (Hld =1 ; Hld <16 ; Hld +=1 ) { +mod_write_dac_register (dev,0x04 , Set <<4 | Hld); +mod_read_dac_register (dev,0x06 , &ReadSeek); + +if ((ReadSeek &0x01 ) != Seek) + { + HldTable[Sample] = Hld; +break ; + } + } + + Hld =0 ; + SetTable[Sample] =15 ; +for (Set =1 ; Set <16 ; Set +=1 ) { +mod_write_dac_register (dev,0x04 , Set <<4 | Hld); +mod_read_dac_register (dev,0x06 , &ReadSeek); + +if ( (ReadSeek &0x01 ) != Seek ) { + SetTable[Sample] = Set; +break ; + } + } + } + + Seek =1 ; +for (Sample =0 ; Sample <32 ; Sample +=1 ) { +// printk(" %2d: %d %2d %2d\n", Sample,SeekTable[Sample],SetTable[Sample],HldTable[Sample]); + +if (Sample1 ==0xFF && SeekTable[Sample] ==1 && Seek ==0 ) + Sample1 = Sample; +if (Sample1 !=0xFF && Sample2 ==0xFF && SeekTable[Sample] ==0 && Seek ==1 ) + Sample2 = Sample; + Seek = SeekTable[Sample]; + } + +if (Sample1 ==0xFF || Sample2 ==0xFF ) { +printk (" No valid window found\n" ); +return -EINVAL ; + } + +printk (" Window = %d - %d\n" , Sample1, Sample2); + +for (Sample = Sample1; Sample < Sample2; Sample +=1 ) { +if (SetTable[Sample] < HldTable[Sample]) { +if (HldTable[Sample] - SetTable[Sample] < DiffMin) { + DiffMin = HldTable[Sample] - SetTable[Sample]; + SelectSample = Sample; + } + } + } + +printk ("Select Sample %d\n" , SelectSample); + +if (SelectSample ==0xFF ) { +printk ("No valid sample found\n" ); +return -EINVAL ; + } + +if (HldTable[SelectSample] + SetTable[SelectSample] <8 ) { +printk ("Too high jitter\n" ); +return -EINVAL ; + } + +mod_write_dac_register (dev,0x04 ,0x00 ); +mod_write_dac_register (dev,0x05 , (SelectSample -1 ) &0x1F ); +mod_read_dac_register (dev,0x06 , &Seek); +mod_write_dac_register (dev,0x05 , (SelectSample +1 ) &0x1F ); +mod_read_dac_register (dev,0x06 ,&ReadSeek); + Seek &= ReadSeek; + +mod_write_dac_register (dev,0x05 , SelectSample); +mod_read_dac_register (dev,0x06 , &ReadSeek); + Seek &= ReadSeek; +if ( (Seek &0x01 ) ==0 ) { +printk ("Insufficient timing margin\n" ); +return -EINVAL ; + } +printk ("Done\n" ); +return 0 ; +} + +static void mod_set_up1 (struct ddb *dev,u32 Frequency,u32 Ref,u32 Ext) +{ +u32 RDiv = Ext / Ref; + + Frequency = Frequency / Ref; +mod_set_up_converter_vco1 (dev,0x360001 | (RDiv <<2 )); +mod_set_up_converter_vco1 (dev,0x0ff128 ); +mod_set_up_converter_vco1 (dev,0x02 | (Frequency <<8 )); +} + +static void mod_set_up2 (struct ddb *dev,u32 Frequency,u32 Ref,u32 Ext) +{ +u32 Rdiv = Ext / Ref; +u32 PreScale =8 ; + + Frequency = Frequency / Ref; +mod_set_up_converter_vco2 (dev,0x360001 | (Rdiv <<2 )); +mod_set_up_converter_vco2 (dev,0x0fc128 | (((PreScale -8 ) /8 ) <<22 )); +mod_set_up_converter_vco2 (dev,0x02 | ((Frequency / PreScale) <<8 ) + | (Frequency & (PreScale -1 )) <<2 ); +} + +static int mod_set_down (struct ddb *dev,u32 Frequency,u32 Ref,u32 Ext) +{ +u32 BandSelect = Ref *8 ; +u32 RefMul =1 ; +u32 RefDiv2 =1 ; +u32 RefDiv = Ext * RefMul / (Ref * RefDiv2); + +if (Frequency <2200 || Frequency >4000 ) +return -EINVAL ; + + Frequency = Frequency / Ref; + +mod_set_down_converter_vco (dev,0x0080003C | ((BandSelect &0xFF ) <<12 )); +mod_set_down_converter_vco (dev,0x00000003 ); +mod_set_down_converter_vco (dev,0x18001E42 | ((RefMul-1 ) <<25 ) | + ((RefDiv2-1 ) <<24 ) | (RefDiv <<14 ) ); +mod_set_down_converter_vco (dev,0x08008021 ); +mod_set_down_converter_vco (dev, Frequency <<15 ); +return 0 ; +} + +static int mod_set_dac_clock (struct ddb *dev,u32 Frequency) +{ +int hr, i; + +if (Frequency) { +ddbwritel (dev,DAC_CONTROL_RESET ,DAC_CONTROL ); +msleep (10 ); +if (mod_set_si598 (dev, Frequency)) { +printk ("mod_set_si598 failed\n" ); +return -1 ; + } +msleep (50 ); +ddbwritel (dev,0x000 ,DAC_CONTROL ); +msleep (10 ); +mod_write_dac_register (dev,0 ,0x02 ); + } + +for (i =0 ; i <10 ; i++) { + hr =mod_init_dac_input (dev); +if (hr ==0 ) +break ; +msleep (100 ); + } +printk ("mod_set_dac_clock OK\n" ); +return hr; +} + +static void mod_set_dac_current (struct ddb *dev,u32 Current1,u32 Current2) +{ +mod_write_dac_register2 (dev,0x0b , Current1 &0x3ff ); +mod_write_dac_register2 (dev,0x0f , Current2 &0x3ff ); +} + +static void mod_output_enable (struct ddb *dev,int enable) +{ + +u32 RegValue; + + RegValue =ddbreadl (dev,IQOUTPUT_CONTROL ); + RegValue &= ~(IQOUTPUT_CONTROL_ENABLE |IQOUTPUT_CONTROL_RESET ); +ddbwritel (dev, RegValue,IQOUTPUT_CONTROL ); + +if (enable) { +ddbwritel (dev, RegValue |IQOUTPUT_CONTROL_RESET ,IQOUTPUT_CONTROL ); +msleep (10 ); +ddbwritel (dev, RegValue,IQOUTPUT_CONTROL ); +ddbwritel (dev, RegValue |IQOUTPUT_CONTROL_ENABLE ,IQOUTPUT_CONTROL ); + } +} + +static int mod_set_iq (struct ddb *dev,u32 steps,u32 chan,u32 freq) +{ +u32 i, j, k, fac =8 ; +u32 s1 =22 , s2 =33 ; +u64 amp = (1ULL <<17 ) -1ULL ; +u64 s =0 , c = (amp << s1), ss; +u64 frq =0xC90FDAA22168C234ULL ; +u32 *iqtab; +u32 iqtabadr; +u32 volatile regval; + + iqtab =kmalloc ((steps +1 ) *4 ,GFP_KERNEL ); +if (!iqtab) +return -ENOMEM ; + frq =div64_u64 (frq, steps * fac) >> (61 - s2); + +/* create sine table */ +for (i =0 ; i <= steps * fac /4 ; i++) { +if (!(i & (fac -1 ))) { + j = i / fac; + ss = s >> s1; +// ss = ((s >> (s1 - 1)) + 1) >> 1; + + iqtab[j] = iqtab[steps /2 - j] = ss; + iqtab[steps /2 + j] = iqtab[steps - j] = -ss; + } + c -= ((s * frq) >> s2); + s += ((c * frq) >> s2); + } + + iqtabadr = chan <<16 ; +ddbwritel (dev, chan &0x0f ,MODULATOR_IQTABLE_INDEX ); +for (i = j =0 , k = steps /4 ; i < steps; i++) { +ddbwritel (dev, (iqtabadr + i) |MODULATOR_IQTABLE_INDEX_SEL_I , +MODULATOR_IQTABLE_INDEX ); +ddbwritel (dev, iqtab[j],MODULATOR_IQTABLE_DATA ); + regval =ddbreadl (dev,MODULATOR_CONTROL ); +ddbwritel (dev, (iqtabadr + i) |MODULATOR_IQTABLE_INDEX_SEL_Q , +MODULATOR_IQTABLE_INDEX ); +ddbwritel (dev, iqtab[k],MODULATOR_IQTABLE_DATA ); + regval =ddbreadl (dev,MODULATOR_CONTROL ); + j += freq; + j %= steps; + k += freq; + k %= steps; + } +ddbwritel (dev, steps -1 ,MODULATOR_IQTABLE_END ); +kfree (iqtab); +return 0 ; +} + +u32 eqtab[] = { +0x0000FFDB ,0x00000121 ,0x0000FF0A ,0x000003D7 , +0x000001C4 ,0x000005A5 ,0x000009CC ,0x0000F50D , +0x00001B23 ,0x0000EEB7 ,0x00006A28 +}; + +static void mod_set_channelsumshift (struct ddb *dev,u32 shift) +{ +ddbwritel (dev, (shift &3 ) <<2 ,MODULATOR_CONTROL ); +} + +static void mod_pre_eq_gain (struct ddb *dev,u16 gain) +{ +ddbwritel (dev, gain,IQOUTPUT_PRESCALER ); +} + +static void mod_post_eq_gain (struct ddb *dev,u16 igain,u16 qgain) +{ +ddbwritel (dev, ((u32 )qgain <<16 ) | igain,IQOUTPUT_POSTSCALER ); +} + +static int set_base_frequency (struct ddb *dev,u32 freq) +{ +u32 Ext =40 ; +u32 UP1Frequency =290 ; +u32 UP2Frequency =1896 ; +u32 down, freq10; + +printk ("set base to %u\n" , freq); + dev->mod_base.frequency = freq; + freq /=1000000 ; + freq10 = dev->mod_base.flat_start +4 ; + down = freq +9 *8 + freq10 + UP1Frequency + UP2Frequency; + +if ((freq10 +9 *8 ) > (dev->mod_base.flat_end -4 )) { +printk ("Frequency out of range %d\n" , freq10); +return -EINVAL ; + } +if (down %8 ) { +printk (" Invalid Frequency %d\n" , down); +return -EINVAL ; + } +return mod_set_down (dev, down,8 , Ext); +} + +static int mod_init (struct ddb *dev,u32 Frequency) +{ +int stat =0 ; +u8 *buffer; +struct DDMOD_FLASH *flash; +u32 Ext =40 ; +u32 UP1Frequency =290 ; +u32 UP2Frequency =1896 ; +u32 DownFrequency; +u32 FrequencyCH10; +u32 iqfreq, iqsteps, i; + + buffer =kmalloc (4096 ,GFP_KERNEL ); +if (!buffer) +return -ENOMEM ; + flash = (struct DDMOD_FLASH *) buffer; + +ddbridge_flashread (dev, buffer,DDMOD_FLASH_START ,4096 ); + +if (flash->Magic !=DDMOD_FLASH_MAGIC && flash->Magic !=1 ) { + stat = -EINVAL ; + goto fail; + } +printk ("srate = %d\n" , flash->DataSet[0 ].Symbolrate *1000 ); + +mod_output_enable (dev,0 ); + stat =mod_set_dac_clock (dev, flash->DataSet[0 ].DACFrequency *1000 ); +if (stat <0 ) { +printk ("setting DAC clock failed\n" ); + goto fail; + } +mod_set_dac_current (dev,512 ,512 ); + +ddbwritel (dev, flash->DataSet[0 ].Control2,IQOUTPUT_CONTROL2 ); + +mod_set_up1 (dev, UP1Frequency,5 , Ext); +mod_set_up2 (dev, UP2Frequency,8 , Ext); + + dev->mod_base.flat_start = flash->DataSet[0 ].FlatStart; + dev->mod_base.flat_end = flash->DataSet[0 ].FlatEnd; + + Frequency /=1000000 ; + FrequencyCH10 = flash->DataSet[0 ].FlatStart +4 ; + DownFrequency = Frequency +9 *8 + FrequencyCH10 + UP1Frequency + UP2Frequency; +printk ("CH10 = %d, Down = %d\n" , FrequencyCH10, DownFrequency); + + +if ((FrequencyCH10 +9 *8 ) > (flash->DataSet[0 ].FlatEnd -4 )) { +printk ("Frequency out of range %d\n" , FrequencyCH10); + stat = -EINVAL ; + goto fail; + } + +if (DownFrequency %8 !=0 ) { +printk (" Invalid Frequency %d\n" , DownFrequency); + stat = -EINVAL ; + goto fail; + } + +mod_set_down (dev, DownFrequency,8 , Ext); + +for (i =0 ; i <10 ; i++) { +ddbwritel (dev,0 ,CHANNEL_CONTROL (i)); + + iqfreq = flash->DataSet[0 ].FrequencyFactor * (FrequencyCH10 + (9 - i) *8 ); + iqsteps = flash->DataSet[0 ].IQTableLength; +mod_set_iq (dev, iqsteps, i, iqfreq); + + dev->mod[i].modulation =QAM_256 ; + } + +mod_bypass_equalizer (dev,1 ); +mod_set_equalizer (dev,11 , flash->DataSet[0 ].EQTap); +mod_bypass_equalizer (dev,0 ); +mod_post_eq_gain (dev, flash->DataSet[0 ].PostScaleI, flash->DataSet[0 ].PostScaleQ); +mod_pre_eq_gain (dev, flash->DataSet[0 ].PreScale); +// mod_pre_eq_gain(dev, 0x0680); +printk ("prescaler %04x\n" , flash->DataSet[0 ].PreScale); +mod_set_channelsumshift (dev,2 ); +mod_output_enable (dev,1 ); + +// mod_set_attenuator(dev, 10); +fail: +kfree (buffer); +return stat; +} + + +void ddbridge_mod_rate_handler (unsigned long data) +{ +struct ddb_output *output = (struct ddb_output *) data; +struct ddb_dma *dma = output->dma; +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + +u32 chan = output->nr; +u32 OutPacketCount; +u32 InPacketCount; +u64 OutPackets, InPackets; +s64 PCRAdjust; +u32 PCRAdjustExt, PCRAdjustExtFrac, InPacketDiff, OutPacketDiff; +s32 PCRCorr; + +s64 pcr; +s64 PCRIncrementDiff; +s64 PCRIncrement; +u64 mul; + +if (!mod->do_handle) +return ; +printk ("rate_handler\n" ); + +spin_lock (&dma->lock); +ddbwritel (dev, mod->Control |CHANNEL_CONTROL_FREEZE_STATUS , +CHANNEL_CONTROL (output->nr)); + + OutPacketCount =ddbreadl (dev,CHANNEL_PKT_COUNT_OUT (chan)); +if (OutPacketCount < mod->LastOutPacketCount ) + mod->OutOverflowPacketCount +=1 ; + mod->LastOutPacketCount = OutPacketCount; + + InPacketCount =ddbreadl (dev,CHANNEL_PKT_COUNT_IN (chan)); +if (InPacketCount < mod->LastInPacketCount ) + mod->InOverflowPacketCount +=1 ; + mod->LastInPacketCount = InPacketCount; + + OutPackets = ((u64) (mod->OutOverflowPacketCount) <<20 ) | OutPacketCount; + InPackets = ((u64) (mod->InOverflowPacketCount) <<20 ) | InPacketCount; + + PCRAdjust = (s64) ((u64 )ddbreadl (dev,CHANNEL_PCR_ADJUST_ACCUL (chan)) | + (((u64 )ddbreadl (dev,CHANNEL_PCR_ADJUST_ACCUH (chan)) <<32 ))); + PCRAdjustExt = (u32)((PCRAdjust &0x7FFFFFFF ) >>22 ); + PCRAdjustExtFrac = (u32)((PCRAdjust &0x003FFFFF ) >>12 ); + PCRAdjust >>=31 ; + InPacketDiff = (u32) (InPackets - mod->LastInPackets); + OutPacketDiff = (u32) (OutPackets - mod->LastOutPackets); + PCRCorr =0 ; + +switch (mod->State) { +case CM_STARTUP : +if (mod->StateCounter) { +if (mod->StateCounter ==1 ) { + mul = (0x1000000 * (u64) (OutPacketDiff - InPacketDiff - InPacketDiff/1000 )); +if (OutPacketDiff) + mod->rate_inc =div_u64 (mul, OutPacketDiff); +else + mod->rate_inc =0 ; +printk ("RI %08x\n" , mod->rate_inc); +ddbwritel (dev, mod->rate_inc,CHANNEL_RATE_INCR (output->nr)); +mod_busy (dev, output->nr); +// #define PACKET_CLOCKS (27000000ULL*1504) +// #define FACTOR (1024<<12) +// double Increment = FACTOR*PACKET_CLOCKS/double(m_OutputBitrate); +// double Decrement = FACTOR*PACKET_CLOCKS/double(m_InputBitrate); + mod->PCRIncrement =3348148758ULL ; +if (InPacketDiff) + mod->PCRDecrement =div_u64 (3348148758ULL * (u64 ) OutPacketDiff, + InPacketDiff); +else + mod->PCRDecrement =0 ; +mod_set_incs (output); + } + mod->StateCounter--; +break ; + } +if (InPacketDiff >= mod->MinInputPackets) { + mod->State =CM_ADJUST ; + mod->Control |=CHANNEL_CONTROL_ENABLE_PCRADJUST ; + mod->InPacketsSum =0 ; + mod->OutPacketsSum =0 ; + mod->PCRAdjustSum =0 ; + mod->StateCounter =CM_AVERAGE ; + } +break ; + +case CM_ADJUST : +if (InPacketDiff < mod->MinInputPackets) { +printk ("PCR Adjust reset IN: %u Min: %u\n" , + InPacketDiff, mod->MinInputPackets); + mod->InPacketsSum =0 ; + mod->OutPacketsSum =0 ; + mod->PCRAdjustSum =0 ; + mod->StateCounter =CM_AVERAGE ; +ddbwritel (dev, + (mod->Control |CHANNEL_CONTROL_FREEZE_STATUS ) & + ~CHANNEL_CONTROL_ENABLE_PCRADJUST , +CHANNEL_CONTROL (chan)); +break ; + } + + mod->PCRAdjustSum += (s32 ) PCRAdjust; + mod->InPacketsSum += InPacketDiff; + mod->OutPacketsSum += OutPacketDiff; +if (mod->StateCounter--) +break ; + +if (mod->OutPacketsSum) + PCRIncrement =div_s64 ((s64 )mod->InPacketsSum * + (s64 )mod->PCRDecrement + + (s64)(mod->OutPacketsSum >>1 ) , + mod->OutPacketsSum); +else + PCRIncrement =0 ; + +if ( mod->PCRAdjustSum >0 ) + PCRIncrement =RoundPCRDown (PCRIncrement); +else + PCRIncrement =RoundPCRUp (PCRIncrement); + + PCRIncrementDiff = PCRIncrement - mod->PCRIncrement; +if ( PCRIncrementDiff >HW_LSB_MASK ) + PCRIncrementDiff =HW_LSB_MASK ; +if ( PCRIncrementDiff < -HW_LSB_MASK ) + PCRIncrementDiff = -HW_LSB_MASK ; + + mod->PCRIncrement += PCRIncrementDiff; + pcr =ConvertPCR (mod->PCRIncrement); +printk ("outl %016llx\n" , pcr); +ddbwritel (dev, pcr &0xffffffff , +CHANNEL_PCR_ADJUST_OUTL (output->nr)); +ddbwritel (dev, (pcr >>32 ) &0xffffffff , +CHANNEL_PCR_ADJUST_OUTH (output->nr)); +mod_busy (dev, chan); + + PCRCorr = (s32) (PCRIncrementDiff >>HW_LSB_SHIFT ); + mod->PCRRunningCorr += PCRCorr; + + mod->InPacketsSum =0 ; + mod->OutPacketsSum =0 ; + mod->PCRAdjustSum =0 ; + mod->StateCounter =CM_AVERAGE ; +break ; + +default : +break ; + } +ddbwritel (dev, mod->Control,CHANNEL_CONTROL (chan)); + + mod->LastInPackets = InPackets; + mod->LastOutPackets = OutPackets; + mod->LastPCRAdjust = (s32 ) PCRAdjust; + +printk ("chan %d out %016llx in %016llx indiff %08x\n" , chan, OutPackets, InPackets, InPacketDiff); +printk ("cnt %d pcra %016llx pcraext %08x pcraextfrac %08x pcrcorr %08x pcri %016llx\n" , + mod->StateCounter, PCRAdjust, PCRAdjustExt, PCRAdjustExtFrac, PCRCorr, mod->PCRIncrement); +// Channel,OutPackets,InPackets,InPacketDiff,PCRAdjust,PCRAdjustExt,PCRAdjustExtFrac,PCRCorr, mod->PCRRunningCorr,mod->StateCounter )); +spin_unlock (&dma->lock); +} + +int ddbridge_mod_do_ioctl (struct file *file,unsigned int cmd,void *parg) +{ +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb *dev = output->port->dev; + +// unsigned long arg = (unsigned long) parg; +int ret =0 ; + +switch (cmd) { +case DVB_MOD_SET : + { +struct dvb_mod_params *mp = parg; + +if (mp->base_frequency != dev->mod_base.frequency) +if (set_base_frequency (dev, mp->base_frequency)) +return -EINVAL ; +mod_set_attenuator (dev, mp->attenuator); +break ; + } +case DVB_MOD_CHANNEL_SET : + { +struct dvb_mod_channel_params *cp = parg; + +if (cp->modulation >QAM_256 ) +return -EINVAL ; + dev->mod[output->nr].modulation = cp->modulation; + dev->mod[output->nr].rate_inc = cp->rate_increment; +ddbwritel (dev, dev->mod[output->nr].rate_inc,CHANNEL_RATE_INCR (output->nr)); +break ; + } +default : + ret = -EINVAL ; +break ; + } +return ret; +} + +int ddbridge_mod_init (struct ddb *dev) +{ +return mod_init (dev,722000000 ); +}
Signature · 1 line
1.8.4.2
PATCH 10/12 ddbridge: Update ddbridge driver to version 0.9.10
In reply to Maik BroemmeUpdated ddbridge driver to version 0.9.10.
--- drivers/media/pci/ddbridge/ddbridge-core.c | 3085 ++++++++++++++++++++-------- 1 file changed, 2236 insertions(+), 849 deletions(-)
drivers/media/pci/ddbridge/ddbridge-core.c +2236 -849
@@ -1,284 +1,216 @@/* -* ddbridge.c: Digital Devices PCIe bridge driver +* ddbridge-core.c: Digital Devices PCIe bridge driver * -* Copyright (C) 2010-2011 Digital Devices GmbH +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> * -* This program is free software; you can redistribute it and/or -* modify it under the terms of the GNU General Public License -* version 2 only, as published by the Free Software Foundation. +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. * +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. * -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* -* You should have received a copy of the GNU General Public License -* along with this program; if not, write to the Free Software -* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -* 02110-1301, USA -* Or, point your browser to http://www.gnu.org/copyleft/gpl.html +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA */ -#include <linux/module.h> -#include <linux/init.h> -#include <linux/interrupt.h> -#include <linux/delay.h> -#include <linux/slab.h> -#include <linux/poll.h> -#include <linux/io.h> -#include <linux/pci.h> -#include <linux/pci_ids.h> -#include <linux/timer.h> -#include <linux/i2c.h> -#include <linux/swab.h> -#include <linux/vmalloc.h> #include "ddbridge.h" -#include "ddbridge-regs.h" -#include "tda18271c2dd.h" +#include "cxd2843.h" +#include "lnbh24.h" #include "stv6110x.h" #include "stv090x.h" -#include "lnbh24.h" +#include "tda18212dd.h" +#include "stv0367dd.h" +#ifdef CONFIG_DVB_TDA18212 +#include "tda18212.h" +#endif +#ifdef CONFIG_DVB_DRXK #include "drxk.h" +#include "tda18271c2dd.h" +#endif -DVB_DEFINE_MOD_OPT_ADAPTER_NR (adapter_nr); - -/* MSI had problems with lost interrupts, fixed but needs testing */ -#undef CONFIG_PCI_MSI +static DEFINE_MUTEX (redirect_lock); -/******************************************************************************/ +static struct workqueue_struct *ddb_wq; +static int adapter_alloc; -static int i2c_read (struct i2c_adapter *adapter,u8 adr,u8 *val) -{ -struct i2c_msg msgs[1 ] = {{.addr = adr, .flags =I2C_M_RD , - .buf = val, .len =1 } }; -return (i2c_transfer (adapter, msgs,1 ) ==1 ) ?0 :-1 ; -} +module_param (adapter_alloc, int,0444 ); +MODULE_PARM_DESC (adapter_alloc,"0-one adapter per io, 1-one per tab with io, 2-one per tab, 3-one for all" ); -static int i2c_read_reg (struct i2c_adapter *adapter,u8 adr,u8 reg,u8 *val) -{ -struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , - .buf = ®, .len =1 }, - {.addr = adr, .flags =I2C_M_RD , - .buf = val, .len =1 } }; -return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; -} +static int ci_bitrate =72000 ; +module_param (ci_bitrate, int,0444 ); +MODULE_PARM_DESC (ci_bitrate," Bitrate for output to CI." ); -static int i2c_read_reg16 (struct i2c_adapter *adapter,u8 adr, -u16 reg,u8 *val) -{ -u8 msg[2 ] = {reg>>8 , reg&0xff }; -struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , - .buf = msg, .len =2 }, - {.addr = adr, .flags =I2C_M_RD , - .buf = val, .len =1 } }; -return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; -} +static int ts_loop =-1 ; +module_param (ts_loop, int,0444 ); +MODULE_PARM_DESC (ts_loop,"TS in/out test loop on port ts_loop" ); -static int ddb_i2c_cmd (struct ddb_i2c *i2c,u32 adr,u32 cmd) -{ -struct ddb *dev = i2c->dev; -int stat; -u32 val; +#define DDB_MAX_ADAPTER 32 +static struct ddb *ddbs[DDB_MAX_ADAPTER ]; - i2c->done =0 ; -ddbwritel ((adr <<9 ) | cmd, i2c->regs +I2C_COMMAND ); - stat =wait_event_timeout (i2c->wq, i2c->done ==1 ,HZ ); -if (stat <=0 ) { -printk (KERN_ERR "I2C timeout\n" ); - {/* MSI debugging*/ -u32 istat =ddbreadl (INTERRUPT_STATUS ); -printk (KERN_ERR "IRS %08x\n" , istat); -ddbwritel (istat,INTERRUPT_ACK ); - } -return -EIO ; - } - val =ddbreadl (i2c->regs+I2C_COMMAND ); -if (val &0x70000 ) -return -EIO ; -return 0 ; -} +DVB_DEFINE_MOD_OPT_ADAPTER_NR (adapter_nr); -static int ddb_i2c_master_xfer (struct i2c_adapter *adapter, -struct i2c_msg msg[],int num) +static void ddb_set_dma_table (struct ddb *dev,struct ddb_dma *dma) { -struct ddb_i2c *i2c = (struct ddb_i2c *)i2c_get_adapdata (adapter); -struct ddb *dev = i2c->dev; -u8 addr =0 ; - -if (num) - addr = msg[0 ].addr; - -if (num ==2 && msg[1 ].flags &I2C_M_RD && - !(msg[0 ].flags &I2C_M_RD )) { -memcpy_toio (dev->regs +I2C_TASKMEM_BASE + i2c->wbuf, - msg[0 ].buf, msg[0 ].len); -ddbwritel (msg[0 ].len|(msg[1 ].len <<16 ), - i2c->regs+I2C_TASKLENGTH ); -if (!ddb_i2c_cmd (i2c, addr,1 )) { -memcpy_fromio (msg[1 ].buf, - dev->regs +I2C_TASKMEM_BASE + i2c->rbuf, - msg[1 ].len); -return num; - } - } +u32 i, base; +u64 mem; -if (num ==1 && !(msg[0 ].flags &I2C_M_RD )) { -ddbcpyto (I2C_TASKMEM_BASE + i2c->wbuf, msg[0 ].buf, msg[0 ].len); -ddbwritel (msg[0 ].len, i2c->regs +I2C_TASKLENGTH ); -if (!ddb_i2c_cmd (i2c, addr,2 )) -return num; - } -if (num ==1 && (msg[0 ].flags &I2C_M_RD )) { -ddbwritel (msg[0 ].len <<16 , i2c->regs +I2C_TASKLENGTH ); -if (!ddb_i2c_cmd (i2c, addr,3 )) { -ddbcpyfrom (msg[0 ].buf, -I2C_TASKMEM_BASE + i2c->rbuf, msg[0 ].len); -return num; - } +if (!dma) +return ; + base =DMA_BASE_ADDRESS_TABLE + dma->nr *0x100 ; +for (i =0 ; i < dma->num; i++) { + mem = dma->pbuf[i]; +ddbwritel (dev, mem &0xffffffff , base + i *8 ); +ddbwritel (dev, mem >>32 , base + i *8 +4 ); } -return -EIO ; + dma->bufreg = (dma->div <<16 ) | + ((dma->num &0x1f ) <<11 ) | + ((dma->size >>7 ) &0x7ff ); } - -static u32 ddb_i2c_functionality (struct i2c_adapter *adap) +static void ddb_set_dma_tables (struct ddb *dev) { -return I2C_FUNC_SMBUS_EMUL ; -} +u32 i; -struct i2c_algorithm ddb_i2c_algo = { - .master_xfer = ddb_i2c_master_xfer, - .functionality = ddb_i2c_functionality, -}; +for (i =0 ; i < dev->info->port_num *2 ; i++) +ddb_set_dma_table (dev, dev->input[i].dma); +for (i =0 ; i < dev->info->port_num; i++) +ddb_set_dma_table (dev, dev->output[i].dma); +} -static void ddb_i2c_release (struct ddb *dev) +static void ddb_redirect_dma (struct ddb *dev, +struct ddb_dma *sdma, +struct ddb_dma *ddma) { -int i; -struct ddb_i2c *i2c; -struct i2c_adapter *adap; +u32 i, base; +u64 mem; -for (i =0 ; i < dev->info->port_num; i++) { - i2c = &dev->i2c[i]; - adap = &i2c->adap; -i2c_del_adapter (adap); + sdma->bufreg = ddma->bufreg; + base =DMA_BASE_ADDRESS_TABLE + sdma->nr *0x100 ; +for (i =0 ; i < ddma->num; i++) { + mem = ddma->pbuf[i]; +ddbwritel (dev, mem &0xffffffff , base + i *8 ); +ddbwritel (dev, mem >>32 , base + i *8 +4 ); } } -static int ddb_i2c_init (struct ddb *dev) +static int ddb_unredirect (struct ddb_port *port) { -int i, j, stat =0 ; -struct ddb_i2c *i2c; -struct i2c_adapter *adap; - -for (i =0 ; i < dev->info->port_num; i++) { - i2c = &dev->i2c[i]; - i2c->dev = dev; - i2c->nr = i; - i2c->wbuf = i * (I2C_TASKMEM_SIZE /4 ); - i2c->rbuf = i2c->wbuf + (I2C_TASKMEM_SIZE /8 ); - i2c->regs =0x80 + i *0x20 ; -ddbwritel (I2C_SPEED_100 , i2c->regs +I2C_TIMING ); -ddbwritel ((i2c->rbuf <<16 ) | i2c->wbuf, - i2c->regs +I2C_TASKADDRESS ); -init_waitqueue_head (&i2c->wq); - - adap = &i2c->adap; -i2c_set_adapdata (adap, i2c); -#ifdef I2C_ADAP_CLASS_TV_DIGITAL - adap->class =I2C_ADAP_CLASS_TV_DIGITAL |I2C_CLASS_TV_ANALOG ; -#else -#ifdef I2C_CLASS_TV_ANALOG - adap->class =I2C_CLASS_TV_ANALOG ; -#endif -#endif -strcpy (adap->name,"ddbridge" ); - adap->algo = &ddb_i2c_algo; - adap->algo_data = (void *)i2c; - adap->dev.parent = &dev->pdev->dev; - stat =i2c_add_adapter (adap); -if (stat) -break ; +struct ddb_input *oredi, *iredi =0 ; +struct ddb_output *iredo =0 ; + +// printk("unredirect %d.%d\n", port->dev->nr, port->nr); +mutex_lock (&redirect_lock); +if (port->output->dma->running) { +mutex_unlock (&redirect_lock); +return -EBUSY ; } -if (stat) -for (j =0 ; j < i; j++) { - i2c = &dev->i2c[j]; - adap = &i2c->adap; -i2c_del_adapter (adap); - } -return stat; + oredi = port->output->redi; +if (!oredi) + goto done; +if (port->input[0 ]) { + iredi = port->input[0 ]->redi; + iredo = port->input[0 ]->redo; + +if (iredo) { + iredo->port->output->redi = oredi; +if (iredo->port->input[0 ]) { + iredo->port->input[0 ]->redi = iredi; +ddb_redirect_dma (oredi->port->dev, + oredi->dma, iredo->dma); + } + port->input[0 ]->redo =0 ; +ddb_set_dma_table (port->dev, port->input[0 ]->dma); + } + oredi->redi = iredi; + port->input[0 ]->redi =0 ; + } + oredi->redo =0 ; + port->output->redi =0 ; + +ddb_set_dma_table (oredi->port->dev, oredi->dma); +done: +mutex_unlock (&redirect_lock); +return 0 ; } +static int ddb_redirect (u32 i,u32 p) +{ +struct ddb *idev = ddbs[(i >>4 ) &0x1f ]; +struct ddb_input *input, *input2; +struct ddb *pdev = ddbs[(p >>4 ) &0x1f ]; +struct ddb_port *port; -/******************************************************************************/ -/******************************************************************************/ -/******************************************************************************/ +if (!idev->has_dma || !pdev->has_dma) +return -EINVAL ; +if (!idev || !pdev) +return -EINVAL ; -#if 0 -static void set_table (struct ddb *dev,u32 off, -dma_addr_t *pbuf,u32 num) -{ -u32 i, base; -u64 mem; + port = &pdev->port[p &0x0f ]; +if (!port->output) +return -EINVAL ; +if (ddb_unredirect (port)) +return -EBUSY ; - base =DMA_BASE_ADDRESS_TABLE + off; -for (i =0 ; i < num; i++) { - mem = pbuf[i]; -ddbwritel (mem &0xffffffff , base + i *8 ); -ddbwritel (mem >>32 , base + i *8 +4 ); - } -} -#endif +if (i ==8 ) +return 0 ; -static void ddb_address_table (struct ddb *dev) -{ -u32 i, j, base; -u64 mem; -dma_addr_t *pbuf; - -for (i =0 ; i < dev->info->port_num *2 ; i++) { - base =DMA_BASE_ADDRESS_TABLE + i *0x100 ; - pbuf = dev->input[i].pbuf; -for (j =0 ; j < dev->input[i].dma_buf_num; j++) { - mem = pbuf[j]; -ddbwritel (mem &0xffffffff , base + j *8 ); -ddbwritel (mem >>32 , base + j *8 +4 ); - } + input = &idev->input[i &7 ]; +if (!input) +return -EINVAL ; + +mutex_lock (&redirect_lock); +if (port->output->dma->running || input->dma->running) { +mutex_unlock (&redirect_lock); +return -EBUSY ; } -for (i =0 ; i < dev->info->port_num; i++) { - base =DMA_BASE_ADDRESS_TABLE +0x800 + i *0x100 ; - pbuf = dev->output[i].pbuf; -for (j =0 ; j < dev->output[i].dma_buf_num; j++) { - mem = pbuf[j]; -ddbwritel (mem &0xffffffff , base + j *8 ); -ddbwritel (mem >>32 , base + j *8 +4 ); - } +if ((input2 = port->input[0 ])) { +if (input->redi) { + input2->redi = input->redi; + input->redi =0 ; + }else + input2->redi = input; } + input->redo = port->output; + port->output->redi = input; + +ddb_redirect_dma (input->port->dev, input->dma, port->output->dma); +mutex_unlock (&redirect_lock); +return 0 ; } -static void io_free (struct pci_dev *pdev,u8 **vbuf, -dma_addr_t *pbuf,u32 size,int num) +static void dma_free (struct pci_dev *pdev,struct ddb_dma *dma,int dir) {int i; -for (i =0 ; i < num; i++) { -if (vbuf[i]) { -pci_free_consistent (pdev, size, vbuf[i], pbuf[i]); - vbuf[i] =0 ; +if (!dma) +return ; +for (i =0 ; i < dma->num; i++) { +if (dma->vbuf[i]) { +pci_free_consistent (pdev, dma->size, + dma->vbuf[i], dma->pbuf[i]); + dma->vbuf[i] =0 ; } } } -static int io_alloc (struct pci_dev *pdev,u8 **vbuf, -dma_addr_t *pbuf,u32 size,int num) +static int dma_alloc (struct pci_dev *pdev,struct ddb_dma *dma,int dir) {int i; -for (i =0 ; i < num; i++) { - vbuf[i] =pci_alloc_consistent (pdev, size, &pbuf[i]); -if (!vbuf[i]) +if (!dma) +return 0 ; +for (i =0 ; i < dma->num; i++) { + dma->vbuf[i] =pci_alloc_consistent (pdev, dma->size, + &dma->pbuf[i]); +if (!dma->vbuf[i])return -ENOMEM ; }return 0 ;
@@ -293,34 +225,24 @@ static int ddb_buffers_alloc(struct ddb *dev) port = &dev->port[i];switch (port->class) {case DDB_PORT_TUNER : -if (io_alloc (dev->pdev, port->input[0 ]->vbuf, - port->input[0 ]->pbuf, - port->input[0 ]->dma_buf_size, - port->input[0 ]->dma_buf_num) <0 ) +if (dma_alloc (dev->pdev, port->input[0 ]->dma,0 ) <0 )return -1 ; -if (io_alloc (dev->pdev, port->input[1 ]->vbuf, - port->input[1 ]->pbuf, - port->input[1 ]->dma_buf_size, - port->input[1 ]->dma_buf_num) <0 ) +if (dma_alloc (dev->pdev, port->input[1 ]->dma,0 ) <0 )return -1 ;break ;case DDB_PORT_CI : -if (io_alloc (dev->pdev, port->input[0 ]->vbuf, - port->input[0 ]->pbuf, - port->input[0 ]->dma_buf_size, - port->input[0 ]->dma_buf_num) <0 ) +case DDB_PORT_LOOP : +if (dma_alloc (dev->pdev, port->input[0 ]->dma,0 ) <0 )return -1 ; -if (io_alloc (dev->pdev, port->output->vbuf, - port->output->pbuf, - port->output->dma_buf_size, - port->output->dma_buf_num) <0 ) +case DDB_PORT_MOD : +if (dma_alloc (dev->pdev, port->output->dma,1 ) <0 )return -1 ;break ;default :break ; } } -ddb_address_table (dev); +ddb_set_dma_tables (dev);return 0 ; }
@@ -328,112 +250,171 @@ static void ddb_buffers_free(struct ddb *dev) {int i;struct ddb_port *port; - +for (i =0 ; i < dev->info->port_num; i++) { port = &dev->port[i]; -io_free (dev->pdev, port->input[0 ]->vbuf, - port->input[0 ]->pbuf, - port->input[0 ]->dma_buf_size, - port->input[0 ]->dma_buf_num); -io_free (dev->pdev, port->input[1 ]->vbuf, - port->input[1 ]->pbuf, - port->input[1 ]->dma_buf_size, - port->input[1 ]->dma_buf_num); -io_free (dev->pdev, port->output->vbuf, - port->output->pbuf, - port->output->dma_buf_size, - port->output->dma_buf_num); + +if (port->input[0 ]) +dma_free (dev->pdev, port->input[0 ]->dma,0 ); +if (port->input[1 ]) +dma_free (dev->pdev, port->input[1 ]->dma,0 ); +if (port->output) +dma_free (dev->pdev, port->output->dma,1 ); } } -static void ddb_input_start (struct ddb_input *input) +static void ddb_output_start (struct ddb_output *output) { -struct ddb *dev = input->port->dev; +struct ddb *dev = output->port->dev; +u32 con2; -spin_lock_irq (&input->lock); - input->cbuf =0 ; - input->coff =0 ; + con2 = ((output->port->obr <<13 ) +71999 ) /72000 ; + con2 = (con2 <<16 ) | output->port->gap; -/* reset */ -ddbwritel (0 ,TS_INPUT_CONTROL (input->nr)); -ddbwritel (2 ,TS_INPUT_CONTROL (input->nr)); -ddbwritel (0 ,TS_INPUT_CONTROL (input->nr)); +if (output->dma) { +spin_lock_irq (&output->dma->lock); + output->dma->cbuf =0 ; + output->dma->coff =0 ; +ddbwritel (dev,0 ,DMA_BUFFER_CONTROL (output->dma->nr)); + } +if (output->port->class ==DDB_PORT_MOD ) +ddbridge_mod_output_start (output); +else { +ddbwritel (dev,0 ,TS_OUTPUT_CONTROL (output->nr)); +ddbwritel (dev,2 ,TS_OUTPUT_CONTROL (output->nr)); +ddbwritel (dev,0 ,TS_OUTPUT_CONTROL (output->nr)); +ddbwritel (dev,0x3c ,TS_OUTPUT_CONTROL (output->nr)); +ddbwritel (dev, con2,TS_OUTPUT_CONTROL2 (output->nr)); + } +if (output->dma) { +ddbwritel (dev, output->dma->bufreg,DMA_BUFFER_SIZE (output->dma->nr)); +ddbwritel (dev,0 ,DMA_BUFFER_ACK (output->dma->nr)); +ddbwritel (dev,1 ,DMA_BASE_READ ); +ddbwritel (dev,3 ,DMA_BUFFER_CONTROL (output->dma->nr)); + } +if (output->port->class !=DDB_PORT_MOD ) { +if (output->port->input[0 ]->port->class ==DDB_PORT_LOOP ) +// ddbwritel(dev, 0x15, TS_OUTPUT_CONTROL(output->nr)); +// ddbwritel(dev, 0x45, TS_OUTPUT_CONTROL(output->nr)); +ddbwritel (dev, (1 <<13 ) |0x15 ,TS_OUTPUT_CONTROL (output->nr)); +else +ddbwritel (dev,0x1d ,TS_OUTPUT_CONTROL (output->nr)); + } +if (output->dma) { + output->dma->running =1 ; +spin_unlock_irq (&output->dma->lock); + } +} -ddbwritel ((1 <<16 ) | - (input->dma_buf_num <<11 ) | - (input->dma_buf_size >>7 ), -DMA_BUFFER_SIZE (input->nr)); -ddbwritel (0 ,DMA_BUFFER_ACK (input->nr)); +static void ddb_output_stop (struct ddb_output *output) +{ +struct ddb *dev = output->port->dev; -ddbwritel (1 ,DMA_BASE_WRITE ); -ddbwritel (3 ,DMA_BUFFER_CONTROL (input->nr)); -ddbwritel (9 ,TS_INPUT_CONTROL (input->nr)); - input->running =1 ; -spin_unlock_irq (&input->lock); +if (output->dma) +spin_lock_irq (&output->dma->lock); +if (output->port->class ==DDB_PORT_MOD ) +ddbridge_mod_output_stop (output); +else +ddbwritel (dev,0 ,TS_OUTPUT_CONTROL (output->nr)); +if (output->dma) { +ddbwritel (dev,0 ,DMA_BUFFER_CONTROL (output->dma->nr)); + output->dma->running =0 ; +spin_unlock_irq (&output->dma->lock); + } }static void ddb_input_stop (struct ddb_input *input) {struct ddb *dev = input->port->dev; -spin_lock_irq (&input->lock); -ddbwritel (0 ,TS_INPUT_CONTROL (input->nr)); -ddbwritel (0 ,DMA_BUFFER_CONTROL (input->nr)); - input->running =0 ; -spin_unlock_irq (&input->lock); +if (input->dma) +spin_lock_irq (&input->dma->lock); +ddbwritel (dev,0 ,TS_INPUT_CONTROL (input->nr)); +if (input->dma) { +ddbwritel (dev,0 ,DMA_BUFFER_CONTROL (input->dma->nr)); + input->dma->running =0 ; +spin_unlock_irq (&input->dma->lock); + } +// printk("input_stop %d.%d\n", dev->nr, input->nr); } -static void ddb_output_start (struct ddb_output *output) +static void ddb_input_start (struct ddb_input *input) { -struct ddb *dev = output->port->dev; +struct ddb *dev = input->port->dev; -spin_lock_irq (&output->lock); - output->cbuf =0 ; - output->coff =0 ; -ddbwritel (0 ,TS_OUTPUT_CONTROL (output->nr)); -ddbwritel (2 ,TS_OUTPUT_CONTROL (output->nr)); -ddbwritel (0 ,TS_OUTPUT_CONTROL (output->nr)); -ddbwritel (0x3c ,TS_OUTPUT_CONTROL (output->nr)); -ddbwritel ((1 <<16 ) | - (output->dma_buf_num <<11 ) | - (output->dma_buf_size >>7 ), -DMA_BUFFER_SIZE (output->nr +8 )); -ddbwritel (0 ,DMA_BUFFER_ACK (output->nr +8 )); - -ddbwritel (1 ,DMA_BASE_READ ); -ddbwritel (3 ,DMA_BUFFER_CONTROL (output->nr +8 )); -/* ddbwritel(0xbd, TS_OUTPUT_CONTROL(output->nr)); */ -ddbwritel (0x1d ,TS_OUTPUT_CONTROL (output->nr)); - output->running =1 ; -spin_unlock_irq (&output->lock); +if (input->dma) { +spin_lock_irq (&input->dma->lock); + input->dma->cbuf =0 ; + input->dma->coff =0 ; +ddbwritel (dev,0 ,DMA_BUFFER_CONTROL (input->dma->nr)); + } +ddbwritel (dev,0 ,TS_INPUT_CONTROL2 (input->nr)); +ddbwritel (dev,0 ,TS_INPUT_CONTROL (input->nr)); +ddbwritel (dev,2 ,TS_INPUT_CONTROL (input->nr)); +ddbwritel (dev,0 ,TS_INPUT_CONTROL (input->nr)); + +if (input->dma) { +ddbwritel (dev, input->dma->bufreg,DMA_BUFFER_SIZE (input->dma->nr)); +ddbwritel (dev,0 ,DMA_BUFFER_ACK (input->dma->nr)); +ddbwritel (dev,1 ,DMA_BASE_WRITE ); +ddbwritel (dev,3 ,DMA_BUFFER_CONTROL (input->dma->nr)); + } +if (dev->info->type ==DDB_OCTONET ) +ddbwritel (dev,0x01 ,TS_INPUT_CONTROL (input->nr)); +else +ddbwritel (dev,0x09 ,TS_INPUT_CONTROL (input->nr)); +if (input->dma) { + input->dma->running =1 ; +spin_unlock_irq (&input->dma->lock); + } +// printk("input_start %d.%d\n", dev->nr, input->nr); } -static void ddb_output_stop (struct ddb_output *output) +static void ddb_input_start_all (struct ddb_input *input) { -struct ddb *dev = output->port->dev; +struct ddb_input *i = input; +struct ddb_output *o; + +mutex_lock (&redirect_lock); +while (i && (o = i->redo)) { +ddb_output_start (o); +if ((i = o->port->input[0 ])) +ddb_input_start (i); + } +ddb_input_start (input); +mutex_unlock (&redirect_lock); +} -spin_lock_irq (&output->lock); -ddbwritel (0 ,TS_OUTPUT_CONTROL (output->nr)); -ddbwritel (0 ,DMA_BUFFER_CONTROL (output->nr +8 )); - output->running =0 ; -spin_unlock_irq (&output->lock); +static void ddb_input_stop_all (struct ddb_input *input) +{ +struct ddb_input *i = input; +struct ddb_output *o; + +mutex_lock (&redirect_lock); +ddb_input_stop (input); +while (i && (o = i->redo)) { +ddb_output_stop (o); +if ((i = o->port->input[0 ])) +ddb_input_stop (i); + } +mutex_unlock (&redirect_lock); }static u32 ddb_output_free (struct ddb_output *output) { -u32 idx, off, stat = output->stat; +u32 idx, off, stat = output->dma->stat;s32 diff; idx = (stat >>11 ) &0x1f ; off = (stat &0x7ff ) <<7 ; - -if (output->cbuf != idx) { -if ((((output->cbuf +1 ) % output->dma_buf_num) == idx) && - (output->dma_buf_size - output->coff <=188 )) + +if (output->dma->cbuf != idx) { +if ((((output->dma->cbuf +1 ) % output->dma->num) == idx) && + (output->dma->size - output->dma->coff <=188 ))return 0 ;return 188 ; } - diff = off - output->coff; + diff = off - output->dma->coff;if (diff <=0 || diff >188 )return 188 ;return 0 ;
@@ -443,46 +424,46 @@ static ssize_t ddb_output_write(struct ddb_output *output, const u8 *buf, size_t count) { struct ddb *dev = output->port->dev; -u32 idx, off, stat = output->stat; +u32 idx, off, stat = output->dma->stat;u32 left = count, len; idx = (stat >>11 ) &0x1f ; off = (stat &0x7ff ) <<7 ;while (left) { - len = output->dma_buf_size - output->coff; -if ((((output->cbuf +1 ) % output->dma_buf_num) == idx) && + len = output->dma->size - output->dma->coff; +if ((((output->dma->cbuf +1 ) % output->dma->num) == idx) && (off ==0 )) {if (len <=188 )break ; len -=188 ; } -if (output->cbuf == idx) { -if (off > output->coff) { -#if 1 - len = off - output->coff; +if (output->dma->cbuf == idx) { +if (off > output->dma->coff) { + len = off - output->dma->coff; len -= (len %188 );if (len <=188 ) - -#endif break ; len -=188 ; } }if (len > left) len = left; -if (copy_from_user (output->vbuf[output->cbuf] + output->coff, +if (copy_from_user (output->dma->vbuf[output->dma->cbuf] + + output->dma->coff, buf, len))return -EIO ; left -= len; buf += len; - output->coff += len; -if (output->coff == output->dma_buf_size) { - output->coff =0 ; - output->cbuf = ((output->cbuf +1 ) % output->dma_buf_num); + output->dma->coff += len; +if (output->dma->coff == output->dma->size) { + output->dma->coff =0 ; + output->dma->cbuf = ((output->dma->cbuf +1 ) % + output->dma->num); } -ddbwritel ((output->cbuf <<11 ) | (output->coff >>7 ), -DMA_BUFFER_ACK (output->nr +8 )); +ddbwritel (dev, + (output->dma->cbuf <<11 ) | (output->dma->coff >>7 ), +DMA_BUFFER_ACK (output->dma->nr)); }return count - left; }
@@ -490,139 +471,410 @@ static ssize_t ddb_output_write(struct ddb_output *output,static u32 ddb_input_avail (struct ddb_input *input) {struct ddb *dev = input->port->dev; -u32 idx, off, stat = input->stat; -u32 ctrl =ddbreadl (DMA_BUFFER_CONTROL (input->nr)); +u32 idx, off, stat = input->dma->stat; +u32 ctrl =ddbreadl (dev,DMA_BUFFER_CONTROL (input->dma->nr)); idx = (stat >>11 ) &0x1f ; off = (stat &0x7ff ) <<7 ;if (ctrl &4 ) {printk (KERN_ERR "IA %d %d %08x\n" , idx, off, ctrl); -ddbwritel (input->stat,DMA_BUFFER_ACK (input->nr)); +ddbwritel (dev, stat,DMA_BUFFER_ACK (input->dma->nr));return 0 ; } -if (input->cbuf != idx) +if (input->dma->cbuf != idx || off < input->dma->coff)return 188 ;return 0 ; } -static ssize_t ddb_input_read (struct ddb_input *input,u8 *buf,size_t count) +static size_t ddb_input_read (struct ddb_input *input,u8 *buf,size_t count) {struct ddb *dev = input->port->dev;u32 left = count; -u32 idx, free, stat = input->stat; +u32 idx, off, free, stat = input->dma->stat;int ret; idx = (stat >>11 ) &0x1f ; + off = (stat &0x7ff ) <<7 ;while (left) { -if (input->cbuf == idx) +if (input->dma->cbuf == idx)return count - left; - free = input->dma_buf_size - input->coff; + free = input->dma->size - input->dma->coff;if (free > left) free = left; - ret =copy_to_user (buf, input->vbuf[input->cbuf] + - input->coff, free); + ret =copy_to_user (buf, input->dma->vbuf[input->dma->cbuf] + + input->dma->coff, free);if (ret)return -EFAULT ; - input->coff += free; -if (input->coff == input->dma_buf_size) { - input->coff =0 ; - input->cbuf = (input->cbuf+1 ) % input->dma_buf_num; + input->dma->coff += free; +if (input->dma->coff == input->dma->size) { + input->dma->coff =0 ; + input->dma->cbuf = (input->dma->cbuf +1 ) % + input->dma->num; } left -= free; -ddbwritel ((input->cbuf <<11 ) | (input->coff >>7 ), -DMA_BUFFER_ACK (input->nr)); +ddbwritel (dev, + (input->dma->cbuf <<11 ) | (input->dma->coff >>7 ), +DMA_BUFFER_ACK (input->dma->nr)); }return count; } -/******************************************************************************/ -/******************************************************************************/ -/******************************************************************************/ +static ssize_t ts_write (struct file *file,const char *buf, +size_t count,loff_t *ppos) +{ +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb *dev = output->port->dev; +size_t left = count; +int stat; + +if (!dev->has_dma) +return -EINVAL ; +while (left) { +if (ddb_output_free (output) <188 ) { +if (file->f_flags &O_NONBLOCK ) +break ; +if (wait_event_interruptible ( + output->dma->wq, +ddb_output_free (output) >=188 ) <0 ) +break ; + } + stat =ddb_output_write (output, buf, left); +if (stat <0 ) +return stat; + buf += stat; + left -= stat; + } +return (left == count) ? -EAGAIN : (count - left); +} + +static ssize_t ts_read (struct file *file,char *buf, +size_t count,loff_t *ppos) +{ +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb_input *input = output->port->input[0 ]; +struct ddb *dev = output->port->dev; +int left, read; + +if (!dev->has_dma) +return -EINVAL ; + count -= count %188 ; + left = count; +while (left) { +if (ddb_input_avail (input) <188 ) { +if (file->f_flags &O_NONBLOCK ) +break ; +if (wait_event_interruptible ( + input->dma->wq, +ddb_input_avail (input) >=188 ) <0 ) +break ; + } + read =ddb_input_read (input, buf, left); + left -= read; + buf += read; + } +return (left == count) ? -EAGAIN : (count - left); +} -#if 0 -static struct ddb_input *fe2input (struct ddb *dev,struct dvb_frontend *fe) +static unsigned int ts_poll (struct file *file,poll_table *wait) { -int i; +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb_input *input = output->port->input[0 ]; + +unsigned int mask =0 ; + +poll_wait (file, &input->dma->wq, wait); +poll_wait (file, &output->dma->wq, wait); +if (ddb_input_avail (input) >=188 ) + mask |=POLLIN |POLLRDNORM ; +if (ddb_output_free (output) >=188 ) + mask |=POLLOUT |POLLWRNORM ; +return mask; +} + +static int ts_release (struct inode *inode,struct file *file) +{ +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb_input *input = output->port->input[0 ]; + +if ((file->f_flags &O_ACCMODE ) ==O_RDONLY ) { +if (!input) +return -EINVAL ; +ddb_input_stop (input); + }else if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) { +if (!output) +return -EINVAL ; +ddb_output_stop (output); + } +return dvb_generic_release (inode, file); +} -for (i =0 ; i < dev->info->port_num *2 ; i++) { -if (dev->input[i].fe == fe) -return &dev->input[i]; +static int ts_open (struct inode *inode,struct file *file) +{ +int err; +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb_input *input = output->port->input[0 ]; + +if ((file->f_flags &O_ACCMODE ) ==O_RDONLY ) { +if (!input) +return -EINVAL ; +if (input->redo || input->redi) +return -EBUSY ; + }else if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) { +if (!output) +return -EINVAL ; } -return NULL ; +if ((err =dvb_generic_open (inode, file)) <0 ) +return err; +if ((file->f_flags &O_ACCMODE ) ==O_RDONLY ) +ddb_input_start (input); +else if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) +ddb_output_start (output); +return err; } -#endif -static int drxk_gate_ctrl (struct dvb_frontend *fe,int enable) +static int mod_release (struct inode *inode,struct file *file) +{ +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; + +if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) { +if (!output) +return -EINVAL ; +ddb_output_stop (output); + } +return dvb_generic_release (inode, file); +} + +static int mod_open (struct inode *inode,struct file *file) +{ +int err; +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; + +if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) { +if (!output) +return -EINVAL ; + } +if ((err =dvb_generic_open (inode, file)) <0 ) +return err; +if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) +ddb_output_start (output); +return err; +} +static const struct file_operations ci_fops = { + .owner =THIS_MODULE , + .read = ts_read, + .write = ts_write, + .open = ts_open, + .release = ts_release, + .poll = ts_poll, + .mmap =0 , +}; + +static struct dvb_device dvbdev_ci = { + .priv =0 , + .readers =1 , + .writers =1 , + .users =2 , + .fops = &ci_fops, +}; + +static long mod_ioctl (struct file *file, +unsigned int cmd,unsigned long arg) +{ +return dvb_usercopy (file, cmd, arg, ddbridge_mod_do_ioctl); +} + +static const struct file_operations mod_fops = { + .owner =THIS_MODULE , + .read = ts_read, + .write = ts_write, + .open = mod_open, + .release = mod_release, + .poll = ts_poll, + .mmap =0 , + .unlocked_ioctl = mod_ioctl, +}; + +static struct dvb_device dvbdev_mod = { + .priv =0 , + .readers =1 , + .writers =1 , + .users =2 , + .fops = &mod_fops, +}; + +static int locked_gate_ctrl (struct dvb_frontend *fe,int enable) {struct ddb_input *input = fe->sec_priv;struct ddb_port *port = input->port; +struct ddb_dvb *dvb = &port->dvb[input->nr &1 ];int status;if (enable) {mutex_lock (&port->i2c_gate_lock); - status = input->gate_ctrl (fe,1 ); + status = dvb->gate_ctrl (fe,1 ); }else { - status = input->gate_ctrl (fe,0 ); + status = dvb->gate_ctrl (fe,0 );mutex_unlock (&port->i2c_gate_lock); }return status; } +#ifdef CONFIG_DVB_DRXK static int demod_attach_drxk (struct ddb_input *input) {struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ];struct dvb_frontend *fe; -struct drxk_config config; -memset (&config,0 ,sizeof (config)); - config.microcode_name ="drxk_a3.mc" ; - config.qam_demod_parameter_count =4 ; - config.adr =0x29 + (input->nr &1 ); - - fe = input->fe =dvb_attach (drxk_attach, &config, i2c); -if (!input->fe) { + fe = dvb->fe =dvb_attach (drxk_attach, + i2c,0x29 + (input->nr&1 ), + &dvb->fe2); +if (!fe) {printk (KERN_ERR "No DRXK found!\n" );return -ENODEV ; } fe->sec_priv = input; - input->gate_ctrl = fe->ops.i2c_gate_ctrl; - fe->ops.i2c_gate_ctrl = drxk_gate_ctrl; + dvb->gate_ctrl = fe->ops.i2c_gate_ctrl; + fe->ops.i2c_gate_ctrl = locked_gate_ctrl;return 0 ; } +#endif -static int tuner_attach_tda18271 (struct ddb_input *input) +struct cxd2843_cfg cxd2843_0 = { + .adr =0x6c , +}; + +struct cxd2843_cfg cxd2843_1 = { + .adr =0x6d , +}; + +static int demod_attach_cxd2843 (struct ddb_input *input) {struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ];struct dvb_frontend *fe; - -if (input->fe->ops.i2c_gate_ctrl) - input->fe->ops.i2c_gate_ctrl (input->fe,1 ); - fe =dvb_attach (tda18271c2dd_attach, input->fe, i2c,0x60 ); -if (!fe) { -printk (KERN_ERR "No TDA18271 found!\n" ); + + fe = dvb->fe =dvb_attach (cxd2843_attach, i2c, + (input->nr &1 ) ? &cxd2843_1 : &cxd2843_0); +if (!dvb->fe) { +printk (KERN_ERR "No cxd2843 found!\n" );return -ENODEV ; } -if (input->fe->ops.i2c_gate_ctrl) - input->fe->ops.i2c_gate_ctrl (input->fe,0 ); + fe->sec_priv = input; + dvb->gate_ctrl = fe->ops.i2c_gate_ctrl; + fe->ops.i2c_gate_ctrl = locked_gate_ctrl;return 0 ; } -/******************************************************************************/ -/******************************************************************************/ -/******************************************************************************/ +struct stv0367_cfg stv0367dd_0 = { + .adr =0x1f , + .xtal =27000000 , +}; -static struct stv090x_config stv0900 = { - .device =STV0900 , - .demod_mode = STV090x_DUAL, - .clk_mode = STV090x_CLK_EXT, +struct stv0367_cfg stv0367dd_1 = { + .adr =0x1e , + .xtal =27000000 , +}; - .xtal =27000000 , - .address =0x69 , +static int demod_attach_stv0367dd (struct ddb_input *input) +{ +struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; +struct dvb_frontend *fe; - .ts1_mode = STV090x_TSMODE_SERIAL_PUNCTURED, - .ts2_mode = STV090x_TSMODE_SERIAL_PUNCTURED, + fe = dvb->fe =dvb_attach (stv0367_attach, i2c, + (input->nr &1 ) ? &stv0367dd_1 : &stv0367dd_0, + &dvb->fe2); +if (!dvb->fe) { +printk (KERN_ERR "No stv0367 found!\n" ); +return -ENODEV ; + } + fe->sec_priv = input; + dvb->gate_ctrl = fe->ops.i2c_gate_ctrl; + fe->ops.i2c_gate_ctrl = locked_gate_ctrl; +return 0 ; +} + +#ifdef CONFIG_DVB_DRXK +static int tuner_attach_tda18271 (struct ddb_input *input) +{ +struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; +struct dvb_frontend *fe; + +if (dvb->fe->ops.i2c_gate_ctrl) + dvb->fe->ops.i2c_gate_ctrl (dvb->fe,1 ); + fe =dvb_attach (tda18271c2dd_attach, dvb->fe, i2c,0x60 ); +if (dvb->fe->ops.i2c_gate_ctrl) + dvb->fe->ops.i2c_gate_ctrl (dvb->fe,0 ); +if (!fe) { +printk (KERN_ERR "No TDA18271 found!\n" ); +return -ENODEV ; + } +return 0 ; +} +#endif + +static int tuner_attach_tda18212dd (struct ddb_input *input) +{ +struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; +struct dvb_frontend *fe; + + fe =dvb_attach (tda18212dd_attach, dvb->fe, i2c, + (input->nr &1 ) ?0x63 :0x60 ); +if (!fe) { +printk (KERN_ERR "No TDA18212 found!\n" ); +return -ENODEV ; + } +return 0 ; +} + +#ifdef CONFIG_DVB_TDA18212 +struct tda18212_config tda18212_0 = { + .i2c_address =0x60 , +}; + +struct tda18212_config tda18212_1 = { + .i2c_address =0x63 , +}; + +static int tuner_attach_tda18212 (struct ddb_input *input) +{ +struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; +struct dvb_frontend *fe; +struct tda18212_config *cfg; + + cfg = (input->nr &1 ) ? &tda18212_1 : &tda18212_0; + fe =dvb_attach (tda18212_attach, dvb->fe, i2c, cfg); +if (!fe) { +printk (KERN_ERR "No TDA18212 found!\n" ); +return -ENODEV ; + } +return 0 ; +} +#endif + +static struct stv090x_config stv0900 = { + .device =STV0900 , + .demod_mode = STV090x_DUAL, + .clk_mode = STV090x_CLK_EXT, + + .xtal =27000000 , + .address =0x69 , + + .ts1_mode = STV090x_TSMODE_SERIAL_PUNCTURED, + .ts2_mode = STV090x_TSMODE_SERIAL_PUNCTURED, .repeater_level = STV090x_RPTLEVEL_16,
@@ -667,15 +919,16 @@ static int demod_attach_stv0900(struct ddb_input *input, int type) {struct i2c_adapter *i2c = &input->port->i2c->adap;struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; - input->fe =dvb_attach (stv090x_attach, feconf, i2c, - (input->nr &1 ) ? STV090x_DEMODULATOR_1 - : STV090x_DEMODULATOR_0); -if (!input->fe) { + dvb->fe =dvb_attach (stv090x_attach, feconf, i2c, + (input->nr &1 ) ? STV090x_DEMODULATOR_1 + : STV090x_DEMODULATOR_0); +if (!dvb->fe) {printk (KERN_ERR "No STV0900 found!\n" );return -ENODEV ; } -if (!dvb_attach (lnbh24_attach, input->fe, i2c,0 , +if (!dvb_attach (lnbh24_attach, dvb->fe, i2c,0 ,0 , (input->nr &1 ) ? (0x09 - type) : (0x0b - type))) {printk (KERN_ERR "No LNBH24 found!\n" );
@@ -687,18 +940,19 @@ static int demod_attach_stv0900(struct ddb_input *input, int type)static int tuner_attach_stv6110 (struct ddb_input *input,int type) {struct i2c_adapter *i2c = &input->port->i2c->adap; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ];struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;struct stv6110x_config *tunerconf = (input->nr &1 ) ? &stv6110b : &stv6110a;struct stv6110x_devctl *ctl; - ctl =dvb_attach (stv6110x_attach, input->fe, tunerconf, i2c); + ctl =dvb_attach (stv6110x_attach, dvb->fe, tunerconf, i2c);if (!ctl) {printk (KERN_ERR "No STV6110X found!\n" );return -ENODEV ; }printk (KERN_INFO "attach tuner input %d adr %02x\n" , - input->nr, tunerconf->addr); + input->nr, tunerconf->addr); feconf->tuner_init = ctl->tuner_init; feconf->tuner_sleep = ctl->tuner_sleep;
@@ -716,9 +970,9 @@ static int tuner_attach_stv6110(struct ddb_input *input, int type) }static int my_dvb_dmx_ts_card_init (struct dvb_demux *dvbdemux,char *id, -int (*start_feed)(struct dvb_demux_feed *), -int (*stop_feed)(struct dvb_demux_feed *), -void *priv) +int (*start_feed)(struct dvb_demux_feed *), +int (*stop_feed)(struct dvb_demux_feed *), +void *priv) { dvbdemux->priv = priv;
@@ -734,10 +988,10 @@ static int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id, }static int my_dvb_dmxdev_ts_card_init (struct dmxdev *dmxdev, -struct dvb_demux *dvbdemux, -struct dmx_frontend *hw_frontend, -struct dmx_frontend *mem_frontend, -struct dvb_adapter *dvb_adapter) +struct dvb_demux *dvbdemux, +struct dmx_frontend *hw_frontend, +struct dmx_frontend *mem_frontend, +struct dvb_adapter *dvb_adapter) {int ret;
@@ -759,318 +1013,610 @@ static int start_feed(struct dvb_demux_feed *dvbdmxfeed) {struct dvb_demux *dvbdmx = dvbdmxfeed->demux;struct ddb_input *input = dvbdmx->priv; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; -if (!input->users) -ddb_input_start (input); +if (!dvb->users) +ddb_input_start_all (input); -return ++input->users; +return ++dvb->users; }static int stop_feed (struct dvb_demux_feed *dvbdmxfeed) {struct dvb_demux *dvbdmx = dvbdmxfeed->demux;struct ddb_input *input = dvbdmx->priv; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; -if (--input->users) -return input->users; +if (--dvb->users) +return dvb->users; -ddb_input_stop (input); +ddb_input_stop_all (input);return 0 ; } -static void dvb_input_detach (struct ddb_input *input) { -struct dvb_adapter *adap = &input->adap; -struct dvb_demux *dvbdemux = &input->demux; - -switch (input->attached) { -case 5 : -if (input->fe2) -dvb_unregister_frontend (input->fe2); -if (input->fe) { -dvb_unregister_frontend (input->fe); -dvb_frontend_detach (input->fe); - input->fe =NULL ; - } -case 4 : -dvb_net_release (&input->dvbnet); - -case 3 : +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ]; +struct dvb_demux *dvbdemux = &dvb->demux; + +switch (dvb->attached) { +case 0x31 : +if (dvb->fe2) +dvb_unregister_frontend (dvb->fe2); +if (dvb->fe) +dvb_unregister_frontend (dvb->fe); +case 0x30 : +dvb_frontend_detach (dvb->fe); + dvb->fe = dvb->fe2 =NULL ; +case 0x20 : +dvb_net_release (&dvb->dvbnet); +case 0x11 : dvbdemux->dmx.close (&dvbdemux->dmx); dvbdemux->dmx.remove_frontend (&dvbdemux->dmx, - &input->hw_frontend); + &dvb->hw_frontend); dvbdemux->dmx.remove_frontend (&dvbdemux->dmx, - &input->mem_frontend); -dvb_dmxdev_release (&input->dmxdev); + &dvb->mem_frontend); +dvb_dmxdev_release (&dvb->dmxdev); +case 0x10 : +dvb_dmx_release (&dvb->demux); +case 0x01 : +break ; + } + dvb->attached =0x00 ; +} + +static int dvb_register_adapters (struct ddb *dev) +{ +int i, ret =0 ; +struct ddb_port *port; +struct dvb_adapter *adap; + +if (adapter_alloc ==3 || dev->info->type ==DDB_MOD ) { + port = &dev->port[0 ]; + adap = port->dvb[0 ].adap; + ret =dvb_register_adapter (adap,"DDBridge" ,THIS_MODULE , + port->dev->dev, + adapter_nr); +if (ret <0 ) +return ret; + port->dvb[0 ].adap_registered =1 ; +for (i =0 ; i < dev->info->port_num; i++) { + port = &dev->port[i]; + port->dvb[0 ].adap = adap; + port->dvb[1 ].adap = adap; + } +return 0 ; + } + +for (i =0 ; i < dev->info->port_num; i++) { + port = &dev->port[i]; +switch (port->class) { +case DDB_PORT_TUNER : + adap = port->dvb[0 ].adap; + ret =dvb_register_adapter (adap,"DDBridge" , +THIS_MODULE , + port->dev->dev, + adapter_nr); +if (ret <0 ) +return ret; + port->dvb[0 ].adap_registered =1 ; + +if (adapter_alloc >0 ) { + port->dvb[1 ].adap = port->dvb[0 ].adap; +break ; + } + adap = port->dvb[1 ].adap; + ret =dvb_register_adapter (adap,"DDBridge" , +THIS_MODULE , + port->dev->dev, + adapter_nr); +if (ret <0 ) +return ret; + port->dvb[1 ].adap_registered =1 ; +break ; + +case DDB_PORT_CI : +case DDB_PORT_LOOP : + adap = port->dvb[0 ].adap; + ret =dvb_register_adapter (adap,"DDBridge" , +THIS_MODULE , + port->dev->dev, + adapter_nr); +if (ret <0 ) +return ret; + port->dvb[0 ].adap_registered =1 ; +break ; +default : +if (adapter_alloc <2 ) +break ; + adap = port->dvb[0 ].adap; + ret =dvb_register_adapter (adap,"DDBridge" , +THIS_MODULE , + port->dev->dev, + adapter_nr); +if (ret <0 ) +return ret; + port->dvb[0 ].adap_registered =1 ; +break ; + } + } +return ret; +} + +static void dvb_unregister_adapters (struct ddb *dev) +{ +int i; +struct ddb_port *port; +struct ddb_dvb *dvb; -case 2 : -dvb_dmx_release (&input->demux); +for (i =0 ; i < dev->info->port_num; i++) { + port = &dev->port[i]; -case 1 : -dvb_unregister_adapter (adap); + dvb = &port->dvb[0 ]; +if (dvb->adap_registered) +dvb_unregister_adapter (dvb->adap); + dvb->adap_registered =0 ; + + dvb = &port->dvb[1 ]; +if (dvb->adap_registered) +dvb_unregister_adapter (dvb->adap); + dvb->adap_registered =0 ; } - input->attached =0 ; }static int dvb_input_attach (struct ddb_input *input) { -int ret; +int ret =0 ; +struct ddb_dvb *dvb = &input->port->dvb[input->nr &1 ];struct ddb_port *port = input->port; -struct dvb_adapter *adap = &input->adap; -struct dvb_demux *dvbdemux = &input->demux; - - ret =dvb_register_adapter (adap,"DDBridge" ,THIS_MODULE , - &input->port->dev->pdev->dev, - adapter_nr); -if (ret <0 ) { -printk (KERN_ERR "ddbridge: Could not register adapter." -"Check if you enabled enough adapters in dvb-core!\n" ); -return ret; - } - input->attached =1 ; +struct dvb_adapter *adap = dvb->adap; +struct dvb_demux *dvbdemux = &dvb->demux; + + dvb->attached =0x01 ; ret =my_dvb_dmx_ts_card_init (dvbdemux,"SW demux" , start_feed, stop_feed, input);if (ret <0 )return ret; - input->attached =2 ; + dvb->attached =0x10 ; - ret =my_dvb_dmxdev_ts_card_init (&input->dmxdev, &input->demux, - &input->hw_frontend, - &input->mem_frontend, adap); + ret =my_dvb_dmxdev_ts_card_init (&dvb->dmxdev, + &dvb->demux, + &dvb->hw_frontend, + &dvb->mem_frontend, adap);if (ret <0 )return ret; - input->attached =3 ; + dvb->attached =0x11 ; - ret =dvb_net_init (adap, &input->dvbnet, input->dmxdev.demux); + ret =dvb_net_init (adap, &dvb->dvbnet, dvb->dmxdev.demux);if (ret <0 )return ret; - input->attached =4 ; + dvb->attached =0x20 ; - input->fe =0 ; + dvb->fe = dvb->fe2 =0 ;switch (port->type) {case DDB_TUNER_DVBS_ST :if (demod_attach_stv0900 (input,0 ) <0 )return -ENODEV ;if (tuner_attach_stv6110 (input,0 ) <0 )return -ENODEV ; -if (input->fe) { -if (dvb_register_frontend (adap, input->fe) <0 ) -return -ENODEV ; - }break ;case DDB_TUNER_DVBS_ST_AA :if (demod_attach_stv0900 (input,1 ) <0 )return -ENODEV ;if (tuner_attach_stv6110 (input,1 ) <0 )return -ENODEV ; -if (input->fe) { -if (dvb_register_frontend (adap, input->fe) <0 ) -return -ENODEV ; - }break ; +#ifdef CONFIG_DVB_DRXK case DDB_TUNER_DVBCT_TR :if (demod_attach_drxk (input) <0 )return -ENODEV ;if (tuner_attach_tda18271 (input) <0 )return -ENODEV ; -if (input->fe) { -if (dvb_register_frontend (adap, input->fe) <0 ) -return -ENODEV ; - } -if (input->fe2) { -if (dvb_register_frontend (adap, input->fe2) <0 ) -return -ENODEV ; - input->fe2->tuner_priv = input->fe->tuner_priv; -memcpy (&input->fe2->ops.tuner_ops, - &input->fe->ops.tuner_ops, -sizeof (struct dvb_tuner_ops )); - }break ; +#endif +case DDB_TUNER_DVBCT_ST : +if (demod_attach_stv0367dd (input) <0 ) +return -ENODEV ; +if (tuner_attach_tda18212dd (input) <0 ) +return -ENODEV ; +break ; +case DDB_TUNER_DVBCT2_SONY : +case DDB_TUNER_DVBC2T2_SONY : +case DDB_TUNER_ISDBT_SONY : +if (demod_attach_cxd2843 (input) <0 ) +return -ENODEV ; +if (tuner_attach_tda18212dd (input) <0 ) +return -ENODEV ; +break ; +default : +return 0 ; + } + dvb->attached =0x30 ; +if (dvb->fe) { +if (dvb_register_frontend (adap, dvb->fe) <0 ) +return -ENODEV ; + } +if (dvb->fe2) { +if (dvb_register_frontend (adap, dvb->fe2) <0 ) +return -ENODEV ; + dvb->fe2->tuner_priv = dvb->fe->tuner_priv; +memcpy (&dvb->fe2->ops.tuner_ops, + &dvb->fe->ops.tuner_ops, +sizeof (struct dvb_tuner_ops )); } - input->attached =5 ; + dvb->attached =0x31 ;return 0 ; } -/****************************************************************************/ -/****************************************************************************/ - -static ssize_t ts_write (struct file *file,const char *buf, -size_t count,loff_t *ppos) +static int port_has_encti (struct ddb_port *port) { -struct dvb_device *dvbdev = file->private_data; -struct ddb_output *output = dvbdev->priv; -size_t left = count; -int stat; +u8 val; +int ret =ddb_i2c_read_reg (&port->i2c->adap,0x20 ,0 , &val); -while (left) { -if (ddb_output_free (output) <188 ) { -if (file->f_flags &O_NONBLOCK ) -break ; -if (wait_event_interruptible ( - output->wq,ddb_output_free (output) >=188 ) <0 ) -break ; - } - stat =ddb_output_write (output, buf, left); -if (stat <0 ) -break ; - buf += stat; - left -= stat; - } -return (left == count) ? -EAGAIN : (count - left); +if (!ret) +printk ("[0x20]=0x%02x\n" , val); + +return ret ?0 :1 ; } -static ssize_t ts_read (struct file *file,char *buf, -size_t count,loff_t *ppos) +static int port_has_cxd (struct ddb_port *port) { -struct dvb_device *dvbdev = file->private_data; -struct ddb_output *output = dvbdev->priv; -struct ddb_input *input = output->port->input[0 ]; -int left, read; +u8 val; +u8 probe[4 ] = {0xe0 ,0x00 ,0x00 ,0x00 }, data[4 ]; +struct i2c_msg msgs[2 ] = {{ .addr =0x40 , .flags =0 , + .buf = probe, .len =4 }, + { .addr =0x40 , .flags =I2C_M_RD , + .buf = data, .len =4 }}; + val =i2c_transfer (&port->i2c->adap, msgs,2 ); +if (val !=2 ) +return 0 ; - count -= count %188 ; - left = count; -while (left) { -if (ddb_input_avail (input) <188 ) { -if (file->f_flags &O_NONBLOCK ) -break ; -if (wait_event_interruptible ( - input->wq,ddb_input_avail (input) >=188 ) <0 ) -break ; - } - read =ddb_input_read (input, buf, left); -if (read <0 ) -return read; - left -= read; - buf += read; - } -return (left == count) ? -EAGAIN : (count - left); +if (data[0 ] ==0x02 && data[1 ] ==0x2b && data[3 ] ==0x43 ) +return 2 ; +return 1 ; } -static unsigned int ts_poll (struct file *file,poll_table *wait) +static int port_has_mach (struct ddb_port *port,u8 *id) { -/* -struct dvb_device *dvbdev = file->private_data; -struct ddb_output *output = dvbdev->priv; -struct ddb_input *input = output->port->input[0]; -*/ -unsigned int mask =0 ; +u8 val; +u8 probe[1 ] = {0x00 }, data[4 ]; +struct i2c_msg msgs[2 ] = {{ .addr =0x10 , .flags =0 , + .buf = probe, .len =1 }, + { .addr =0x10 , .flags =I2C_M_RD , + .buf = data, .len =4 }}; + val =i2c_transfer (&port->i2c->adap, msgs,2 ); +if (val !=2 ) +return 0 ; + +if (data[0 ] !='D' || data[1 ] !='F' ) +return 0 ; -#if 0 -if (data_avail_to_read) - mask |=POLLIN |POLLRDNORM ; -if (data_avail_to_write) - mask |=POLLOUT |POLLWRNORM ; + *id = data[2 ]; +return 1 ; +} -poll_wait (file, &read_queue, wait); -poll_wait (file, &write_queue, wait); -#endif -return mask; +static int port_has_stv0900 (struct ddb_port *port) +{ +u8 val; +if (ddb_i2c_read_reg16 (&port->i2c->adap,0x69 ,0xf100 , &val) <0 ) +return 0 ; +return 1 ; } -static const struct file_operations ci_fops = { - .owner =THIS_MODULE , - .read = ts_read, - .write = ts_write, - .open = dvb_generic_open, - .release = dvb_generic_release, - .poll = ts_poll, - .mmap =0 , -}; +static int port_has_stv0900_aa (struct ddb_port *port) +{ +u8 val; +if (ddb_i2c_read_reg16 (&port->i2c->adap,0x68 ,0xf100 , &val) <0 ) +return 0 ; +return 1 ; +} -static struct dvb_device dvbdev_ci = { - .priv =0 , - .readers =-1 , - .writers =-1 , - .users =-1 , - .fops = &ci_fops, -}; +static int port_has_drxks (struct ddb_port *port) +{ +u8 val; +if (ddb_i2c_read (&port->i2c->adap,0x29 , &val) <0 ) +return 0 ; +if (ddb_i2c_read (&port->i2c->adap,0x2a , &val) <0 ) +return 0 ; +return 1 ; +} -/****************************************************************************/ -/****************************************************************************/ -/****************************************************************************/ +static int port_has_stv0367 (struct ddb_port *port) +{ +u8 val; + +if (ddb_i2c_read_reg16 (&port->i2c->adap,0x1e ,0xf000 , &val) <0 ) +return 0 ; +if (val !=0x60 ) +return 0 ; +if (ddb_i2c_read_reg16 (&port->i2c->adap,0x1f ,0xf000 , &val) <0 ) +return 0 ; +if (val !=0x60 ) +return 0 ; +return 1 ; +} -static void input_tasklet (unsigned long data) +static int init_xo2 (struct ddb_port *port) { -struct ddb_input *input = (struct ddb_input *) data; -struct ddb *dev = input->port->dev; +struct i2c_adapter *i2c =&port->i2c->adap; +u8 val, data[2 ]; +int res; + + res =ddb_i2c_read_regs (i2c,0x10 ,0x04 , data,2 ); +if (res <0 ) +return res; -spin_lock (&input->lock); -if (!input->running) { -spin_unlock (&input->lock); -return ; +if (data[0 ] !=0x01 ) { +printk (KERN_INFO "Port %d: invalid XO2\n" , port->nr); +return -1 ; } - input->stat =ddbreadl (DMA_BUFFER_CURRENT (input->nr)); -if (input->port->class ==DDB_PORT_TUNER ) { -if (4 &ddbreadl (DMA_BUFFER_CONTROL (input->nr))) -printk (KERN_ERR "Overflow input %d\n" , input->nr); -while (input->cbuf != ((input->stat >>11 ) &0x1f ) - || (4 &ddbreadl (DMA_BUFFER_CONTROL (input->nr)))) { -dvb_dmx_swfilter_packets (&input->demux, - input->vbuf[input->cbuf], - input->dma_buf_size /188 ); - - input->cbuf = (input->cbuf +1 ) % input->dma_buf_num; -ddbwritel ((input->cbuf <<11 ), -DMA_BUFFER_ACK (input->nr)); - input->stat =ddbreadl (DMA_BUFFER_CURRENT (input->nr)); - } +ddb_i2c_read_reg (i2c,0x10 ,0x08 , &val); +if (val !=0 ) { +ddb_i2c_write_reg (i2c,0x10 ,0x08 ,0x00 ); +msleep (100 ); } -if (input->port->class ==DDB_PORT_CI ) -wake_up (&input->wq); -spin_unlock (&input->lock); +/* Enable tuner power, disable pll, reset demods */ +ddb_i2c_write_reg (i2c,0x10 ,0x08 ,0x04 ); +msleep (2 ); +/* Release demod resets */ +ddb_i2c_write_reg (i2c,0x10 ,0x08 ,0x07 ); +msleep (2 ); + +/* Start XO2 PLL */ +ddb_i2c_write_reg (i2c,0x10 ,0x08 ,0x87 ); + +return 0 ; } -static void output_tasklet (unsigned long data) +static void ddb_port_probe (struct ddb_port *port) { -struct ddb_output *output = (struct ddb_output *) data; -struct ddb *dev = output->port->dev; +struct ddb *dev = port->dev; +char *modname ="NO MODULE" ; +int val; +u8 id; + + port->class =DDB_PORT_NONE ; -spin_lock (&output->lock); -if (!output->running) { -spin_unlock (&output->lock); +if (dev->info->type ==DDB_MOD ) { + modname ="MOD" ; + port->class =DDB_PORT_MOD ; +printk (KERN_INFO "Port %d: MOD\n" , port->nr);return ; } - output->stat =ddbreadl (DMA_BUFFER_CURRENT (output->nr +8 )); -wake_up (&output->wq); -spin_unlock (&output->lock); -} +if (port->nr >1 && dev->info->type ==DDB_OCTOPUS_CI ) { + modname ="CI internal" ; + port->class =DDB_PORT_CI ; + port->type =DDB_CI_INTERNAL ; + }else if ((val =port_has_cxd (port)) >0 ) { +if (val ==1 ) { + modname ="CI" ; + port->class =DDB_PORT_CI ; + port->type =DDB_CI_EXTERNAL_SONY ; +ddbwritel (dev,I2C_SPEED_400 , port->i2c->regs +I2C_TIMING ); + }else { +printk (KERN_INFO "Port %d: Uninitialized DuoFlex\n" , port->nr); +return ; + } + }else if (port_has_mach (port, &id)) { +char *xo2names[] = {"DUAL DVB-S2" ,"DUAL DVB-C/T/T2" ,"DUAL DVB-ISDBT" , +"DUAL DVB-C/C2/T/T2" ,"DUAL ATSC" ,"DUAL DVB-C/C2/T/T2" }; + +ddbwritel (dev,I2C_SPEED_400 , port->i2c->regs +I2C_TIMING ); + id >>=2 ; +if (id >5 ) { + modname ="unknown XO2 DuoFlex" ; + }else { + port->class =DDB_PORT_TUNER ; + port->type =DDB_TUNER_XO2 + id; + modname = xo2names[id]; +init_xo2 (port); + } + }else if (port_has_stv0900 (port)) { + modname ="DUAL DVB-S2" ; + port->class =DDB_PORT_TUNER ; + port->type =DDB_TUNER_DVBS_ST ; +ddbwritel (dev,I2C_SPEED_100 , port->i2c->regs +I2C_TIMING ); + }else if (port_has_stv0900_aa (port)) { + modname ="DUAL DVB-S2" ; + port->class =DDB_PORT_TUNER ; + port->type =DDB_TUNER_DVBS_ST_AA ; +ddbwritel (dev,I2C_SPEED_100 , port->i2c->regs +I2C_TIMING ); + }else if (port_has_drxks (port)) { + modname ="DUAL DVB-C/T" ; + port->class =DDB_PORT_TUNER ; + port->type =DDB_TUNER_DVBCT_TR ; +ddbwritel (dev,I2C_SPEED_400 , port->i2c->regs +I2C_TIMING ); + }else if (port_has_stv0367 (port)) { + modname ="DUAL DVB-C/T" ; + port->class =DDB_PORT_TUNER ; + port->type =DDB_TUNER_DVBCT_ST ; +ddbwritel (dev,I2C_SPEED_100 , port->i2c->regs +I2C_TIMING ); + }else if (port_has_encti (port)) { + modname ="ENCTI" ; + port->class =DDB_PORT_LOOP ; + }else if (port->nr == ts_loop) { + modname ="TS LOOP" ; + port->class =DDB_PORT_LOOP ; + } +printk (KERN_INFO "Port %d (TAB %d): %s\n" , port->nr, port->nr +1 , modname); +} -struct cxd2099_cfg cxd_cfg = { - .bitrate =62000 , - .adr =0x40 , - .polarity =1 , - .clock_mode =1 , -}; +static int wait_ci_ready (struct ddb_ci *ci) +{ +u32 count =10 ; + +ndelay (500 ); +do { +if (ddbreadl (ci->port->dev, +CI_CONTROL (ci->nr)) &CI_READY ) +break ; +usleep_range (1 ,2 ); +if ((--count) ==0 ) +return -1 ; + }while (1 ); +return 0 ; +} -static int ddb_ci_attach (struct ddb_port *port) +static int read_attribute_mem (struct dvb_ca_en50221 *ca, +int slot,int address) { -int ret; +struct ddb_ci *ci = ca->data; +u32 val, off = (address >>1 ) & (CI_BUFFER_SIZE -1 ); - ret =dvb_register_adapter (&port->output->adap, -"DDBridge" , -THIS_MODULE , - &port->dev->pdev->dev, - adapter_nr); -if (ret <0 ) -return ret; - port->en =cxd2099_attach (&cxd_cfg, port, &port->i2c->adap); -if (!port->en) { -dvb_unregister_adapter (&port->output->adap); -return -ENODEV ; +if (address >CI_BUFFER_SIZE ) +return -1 ; +ddbwritel (ci->port->dev,CI_READ_CMD | (1 <<16 ) | address, +CI_DO_READ_ATTRIBUTES (ci->nr)); +wait_ci_ready (ci); + val =0xff &ddbreadl (ci->port->dev,CI_BUFFER (ci->nr) + off); +return val; +} + +static int write_attribute_mem (struct dvb_ca_en50221 *ca,int slot, +int address,u8 value) +{ +struct ddb_ci *ci = ca->data; + +ddbwritel (ci->port->dev,CI_WRITE_CMD | (value <<16 ) | address, +CI_DO_ATTRIBUTE_RW (ci->nr)); +wait_ci_ready (ci); +return 0 ; +} + +static int read_cam_control (struct dvb_ca_en50221 *ca, +int slot,u8 address) +{ +u32 count =100 ; +struct ddb_ci *ci = ca->data; +u32 res; + +ddbwritel (ci->port->dev,CI_READ_CMD | address, +CI_DO_IO_RW (ci->nr)); +ndelay (500 ); +do { + res =ddbreadl (ci->port->dev,CI_READDATA (ci->nr)); +if (res &CI_READY ) +break ; +usleep_range (1 ,2 ); +if ((--count) ==0 ) +return -1 ; + }while (1 ); +return (0xff & res); +} + +static int write_cam_control (struct dvb_ca_en50221 *ca,int slot, +u8 address,u8 value) +{ +struct ddb_ci *ci = ca->data; + +ddbwritel (ci->port->dev,CI_WRITE_CMD | (value <<16 ) | address, +CI_DO_IO_RW (ci->nr)); +wait_ci_ready (ci); +return 0 ; +} + +static int slot_reset (struct dvb_ca_en50221 *ca,int slot) +{ +struct ddb_ci *ci = ca->data; + +ddbwritel (ci->port->dev,CI_POWER_ON , +CI_CONTROL (ci->nr)); +msleep (100 ); +ddbwritel (ci->port->dev,CI_POWER_ON |CI_RESET_CAM , +CI_CONTROL (ci->nr)); +ddbwritel (ci->port->dev,CI_ENABLE |CI_POWER_ON |CI_RESET_CAM , +CI_CONTROL (ci->nr)); +udelay (20 ); +ddbwritel (ci->port->dev,CI_ENABLE |CI_POWER_ON , +CI_CONTROL (ci->nr)); +return 0 ; +} + +static int slot_shutdown (struct dvb_ca_en50221 *ca,int slot) +{ +struct ddb_ci *ci = ca->data; + +ddbwritel (ci->port->dev,0 ,CI_CONTROL (ci->nr)); +msleep (300 ); +return 0 ; +} + +static int slot_ts_enable (struct dvb_ca_en50221 *ca,int slot) +{ +struct ddb_ci *ci = ca->data; +u32 val =ddbreadl (ci->port->dev,CI_CONTROL (ci->nr)); + +ddbwritel (ci->port->dev, val |CI_BYPASS_DISABLE , +CI_CONTROL (ci->nr)); +return 0 ; +} + +static int poll_slot_status (struct dvb_ca_en50221 *ca,int slot,int open) +{ +struct ddb_ci *ci = ca->data; +u32 val =ddbreadl (ci->port->dev,CI_CONTROL (ci->nr)); +int stat =0 ; + +if (val &CI_CAM_DETECT ) + stat |=DVB_CA_EN50221_POLL_CAM_PRESENT ; +if (val &CI_CAM_READY ) + stat |=DVB_CA_EN50221_POLL_CAM_READY ; +return stat; +} + +static struct dvb_ca_en50221 en_templ = { + .read_attribute_mem = read_attribute_mem, + .write_attribute_mem = write_attribute_mem, + .read_cam_control = read_cam_control, + .write_cam_control = write_cam_control, + .slot_reset = slot_reset, + .slot_shutdown = slot_shutdown, + .slot_ts_enable = slot_ts_enable, + .poll_slot_status = poll_slot_status, +}; + +static void ci_attach (struct ddb_port *port) +{ +struct ddb_ci *ci =0 ; + + ci =kzalloc (sizeof (*ci),GFP_KERNEL ); +if (!ci) +return ; +memcpy (&ci->en, &en_templ,sizeof (en_templ)); + ci->en.data = ci; + port->en = &ci->en; + ci->port = port; + ci->nr = port->nr -2 ; +} + +struct cxd2099_cfg cxd_cfg = { + .bitrate =72000 , + .adr =0x40 , + .polarity =1 , + .clock_mode =1 ,// 2, +}; + +static int ddb_ci_attach (struct ddb_port *port) +{ +if (port->type ==DDB_CI_EXTERNAL_SONY ) { + cxd_cfg.bitrate = ci_bitrate; + port->en =cxd2099_attach (&cxd_cfg, port, &port->i2c->adap); +if (!port->en) +return -ENODEV ; +dvb_ca_en50221_init (port->dvb[0 ].adap, + port->en,0 ,1 ); } -ddb_input_start (port->input[0 ]); -ddb_output_start (port->output); -dvb_ca_en50221_init (&port->output->adap, - port->en,0 ,1 ); - ret =dvb_register_device (&port->output->adap, &port->output->dev, - &dvbdev_ci, (void *) port->output, -DVB_DEVICE_SEC ); -return ret; +if (port->type ==DDB_CI_INTERNAL ) { +ci_attach (port); +if (!port->en) +return -ENODEV ; +dvb_ca_en50221_init (port->dvb[0 ].adap, port->en,0 ,1 ); + } +return 0 ; }static int ddb_port_attach (struct ddb_port *port)
@@ -1083,9 +1629,26 @@ static int ddb_port_attach(struct ddb_port *port)if (ret <0 )break ; ret =dvb_input_attach (port->input[1 ]); +if (ret <0 ) +break ; + port->input[0 ]->redi = port->input[0 ]; + port->input[1 ]->redi = port->input[1 ];break ;case DDB_PORT_CI : ret =ddb_ci_attach (port); +if (ret <0 ) +break ; +case DDB_PORT_LOOP : + ret =dvb_register_device (port->dvb[0 ].adap, + &port->dvb[0 ].dev, + &dvbdev_ci, (void *) port->output, +DVB_DEVICE_CI ); +break ; +case DDB_PORT_MOD : + ret =dvb_register_device (port->dvb[0 ].adap, + &port->dvb[0 ].dev, + &dvbdev_mod, (void *) port->output, +DVB_DEVICE_MOD );break ;default :break ;
@@ -1100,6 +1663,11 @@ static int ddb_ports_attach(struct ddb *dev)int i, ret =0 ;struct ddb_port *port; +if (dev->info->port_num) { + ret =dvb_register_adapters (dev); +if (ret <0 ) +return ret; + }for (i =0 ; i < dev->info->port_num; i++) { port = &dev->port[i]; ret =ddb_port_attach (port);
@@ -1116,125 +1684,210 @@ static void ddb_ports_detach(struct ddb *dev)for (i =0 ; i < dev->info->port_num; i++) { port = &dev->port[i]; +switch (port->class) {case DDB_PORT_TUNER :dvb_input_detach (port->input[0 ]);dvb_input_detach (port->input[1 ]);break ;case DDB_PORT_CI : -if (port->output->dev) -dvb_unregister_device (port->output->dev); +case DDB_PORT_LOOP : +if (port->dvb[0 ].dev) +dvb_unregister_device (port->dvb[0 ].dev);if (port->en) { -ddb_input_stop (port->input[0 ]); -ddb_output_stop (port->output);dvb_ca_en50221_release (port->en);kfree (port->en); port->en =0 ; -dvb_unregister_adapter (&port->output->adap); }break ; +case DDB_PORT_MOD : +if (port->dvb[0 ].dev) +dvb_unregister_device (port->dvb[0 ].dev); +break ; } } +dvb_unregister_adapters (dev); } -/****************************************************************************/ -/****************************************************************************/ +/* Copy input DMA pointers to output DMA and ACK. */ +static void input_write_output (struct ddb_input *input, +struct ddb_output *output) +{ +ddbwritel (output->port->dev, + input->dma->stat,DMA_BUFFER_ACK (output->dma->nr)); + output->dma->cbuf = (input->dma->stat >>11 ) &0x1f ; + output->dma->coff = (input->dma->stat &0x7ff ) <<7 ; +} -static int port_has_ci (struct ddb_port *port) +static void output_ack_input (struct ddb_output *output, +struct ddb_input *input) { -u8 val; -return i2c_read_reg (&port->i2c->adap,0x40 ,0 , &val) ?0 :1 ; +ddbwritel (input->port->dev, + output->dma->stat,DMA_BUFFER_ACK (input->dma->nr)); } -static int port_has_stv0900 (struct ddb_port *port) +static void input_write_dvb (struct ddb_input *input, +struct ddb_input *input2) { -u8 val; -if (i2c_read_reg16 (&port->i2c->adap,0x69 ,0xf100 , &val) <0 ) -return 0 ; -return 1 ; +struct ddb_dvb *dvb = &input2->port->dvb[input2->nr &1 ]; +struct ddb_dma *dma, *dma2; +struct ddb *dev = input->port->dev; +int noack =0 ; + + dma = dma2 = input->dma; +/* if there also is an output connected, do not ACK. +input_write_output will ACK. */ +if (input->redo) { + dma2 = input->redo->dma; + noack =1 ; + } +while (dma->cbuf != ((dma->stat >>11 ) &0x1f ) + || (4 & dma->ctrl)) { +if (4 & dma->ctrl) { +// printk(KERN_ERR "Overflow dma %d\n", dma->nr); +if (noack) + noack =0 ; + } +dvb_dmx_swfilter_packets (&dvb->demux, + dma2->vbuf[dma->cbuf], + dma2->size /188 ); + dma->cbuf = (dma->cbuf +1 ) % dma2->num; +if (!noack) +ddbwritel (dev, (dma->cbuf <<11 ), +DMA_BUFFER_ACK (dma->nr)); + dma->stat =ddbreadl (dev,DMA_BUFFER_CURRENT (dma->nr)); + dma->ctrl =ddbreadl (dev,DMA_BUFFER_CONTROL (dma->nr)); + } } -static int port_has_stv0900_aa (struct ddb_port *port) +static void input_work (struct work_struct *work) { -u8 val; -if (i2c_read_reg16 (&port->i2c->adap,0x68 ,0xf100 , &val) <0 ) -return 0 ; -return 1 ; + struct ddb_dma *dma = container_of(work, struct ddb_dma, work); +struct ddb_input *input = (struct ddb_input *) dma->io; +struct ddb *dev = input->port->dev; + +spin_lock (&dma->lock); +if (!dma->running) { +spin_unlock (&dma->lock); +return ; + } + dma->stat =ddbreadl (dev,DMA_BUFFER_CURRENT (dma->nr)); + dma->ctrl =ddbreadl (dev,DMA_BUFFER_CONTROL (dma->nr)); + +if (input->redi) +input_write_dvb (input, input->redi); +if (input->redo) +input_write_output (input, input->redo); +wake_up (&dma->wq); +spin_unlock (&dma->lock); } -static int port_has_drxks (struct ddb_port *port) +static void input_handler (unsigned long data) { -u8 val; -if (i2c_read (&port->i2c->adap,0x29 , &val) <0 ) -return 0 ; -if (i2c_read (&port->i2c->adap,0x2a , &val) <0 ) -return 0 ; -return 1 ; +struct ddb_input *input = (struct ddb_input *) data; +struct ddb_dma *dma = input->dma; + +/* If there is no input connected, input_tasklet() will +just copy pointers and ACK. So, there is no need to go +through the tasklet scheduler. */ +if (input->redi) +queue_work (ddb_wq, &dma->work); +else +input_work (&dma->work); } -static void ddb_port_probe (struct ddb_port *port) +/* TODO: hmm, don't really need this anymore. +The output IRQ just copies some pointers, acks and wakes. */ +static void output_work (struct work_struct *work) { -struct ddb *dev = port->dev; -char *modname ="NO MODULE" ; +} - port->class =DDB_PORT_NONE ; +static void output_handler (unsigned long data) +{ +struct ddb_output *output = (struct ddb_output *) data; +struct ddb_dma *dma = output->dma; +struct ddb *dev = output->port->dev; -if (port_has_ci (port)) { - modname ="CI" ; - port->class =DDB_PORT_CI ; -ddbwritel (I2C_SPEED_400 , port->i2c->regs +I2C_TIMING ); - }else if (port_has_stv0900 (port)) { - modname ="DUAL DVB-S2" ; - port->class =DDB_PORT_TUNER ; - port->type =DDB_TUNER_DVBS_ST ; -ddbwritel (I2C_SPEED_100 , port->i2c->regs +I2C_TIMING ); - }else if (port_has_stv0900_aa (port)) { - modname ="DUAL DVB-S2" ; - port->class =DDB_PORT_TUNER ; - port->type =DDB_TUNER_DVBS_ST_AA ; -ddbwritel (I2C_SPEED_100 , port->i2c->regs +I2C_TIMING ); - }else if (port_has_drxks (port)) { - modname ="DUAL DVB-C/T" ; - port->class =DDB_PORT_TUNER ; - port->type =DDB_TUNER_DVBCT_TR ; -ddbwritel (I2C_SPEED_400 , port->i2c->regs +I2C_TIMING ); +spin_lock (&dma->lock); +if (!dma->running) { +spin_unlock (&dma->lock); +return ; + } + dma->stat =ddbreadl (dev,DMA_BUFFER_CURRENT (dma->nr)); + dma->ctrl =ddbreadl (dev,DMA_BUFFER_CONTROL (dma->nr)); +if (output->redi) +output_ack_input (output, output->redi); +wake_up (&dma->wq); +spin_unlock (&dma->lock); +} + +static void ddb_dma_init (struct ddb_dma *dma,int nr,void *io,int out) +{ + dma->io = io; + dma->nr = nr; +spin_lock_init (&dma->lock); +init_waitqueue_head (&dma->wq); +if (out) { +INIT_WORK (&dma->work, output_work); + dma->num =OUTPUT_DMA_BUFS ; + dma->size =OUTPUT_DMA_SIZE ; + dma->div =OUTPUT_DMA_IRQ_DIV ; + }else { +INIT_WORK (&dma->work, input_work); + dma->num =INPUT_DMA_BUFS ; + dma->size =INPUT_DMA_SIZE ; + dma->div =INPUT_DMA_IRQ_DIV ; } -printk (KERN_INFO "Port %d (TAB %d): %s\n" , - port->nr, port->nr+1 , modname); } -static void ddb_input_init (struct ddb_port *port,int nr) +static void ddb_input_init (struct ddb_port *port,int nr,int pnr,int dma_nr) {struct ddb *dev = port->dev;struct ddb_input *input = &dev->input[nr]; +if (dev->has_dma) { + dev->handler[dma_nr +8 ] = input_handler; + dev->handler_data[dma_nr +8 ] = (unsigned long ) input; + } + port->input[pnr] = input; input->nr = nr; input->port = port; - input->dma_buf_num =INPUT_DMA_BUFS ; - input->dma_buf_size =INPUT_DMA_SIZE ; -ddbwritel (0 ,TS_INPUT_CONTROL (nr)); -ddbwritel (2 ,TS_INPUT_CONTROL (nr)); -ddbwritel (0 ,TS_INPUT_CONTROL (nr)); -ddbwritel (0 ,DMA_BUFFER_ACK (nr)); -tasklet_init (&input->tasklet, input_tasklet, (unsigned long ) input); -spin_lock_init (&input->lock); -init_waitqueue_head (&input->wq); +if (dev->has_dma) { + input->dma = &dev->dma[dma_nr]; +ddb_dma_init (input->dma, dma_nr, (void *) input,0 ); + } +ddbwritel (dev,0 ,TS_INPUT_CONTROL (nr)); +ddbwritel (dev,2 ,TS_INPUT_CONTROL (nr)); +ddbwritel (dev,0 ,TS_INPUT_CONTROL (nr)); +if (dev->has_dma) +ddbwritel (dev,0 ,DMA_BUFFER_ACK (input->dma->nr)); } -static void ddb_output_init (struct ddb_port *port,int nr) +static void ddb_output_init (struct ddb_port *port,int nr,int dma_nr) {struct ddb *dev = port->dev;struct ddb_output *output = &dev->output[nr]; + +if (dev->has_dma) { + dev->handler[dma_nr +8 ] = output_handler; + dev->handler_data[dma_nr +8 ] = (unsigned long ) output; + } + port->output = output; output->nr = nr; output->port = port; - output->dma_buf_num =OUTPUT_DMA_BUFS ; - output->dma_buf_size =OUTPUT_DMA_SIZE ; - -ddbwritel (0 ,TS_OUTPUT_CONTROL (nr)); -ddbwritel (2 ,TS_OUTPUT_CONTROL (nr)); -ddbwritel (0 ,TS_OUTPUT_CONTROL (nr)); -tasklet_init (&output->tasklet, output_tasklet, (unsigned long ) output); -init_waitqueue_head (&output->wq); +if (dev->has_dma) { + output->dma = &dev->dma[dma_nr]; +ddb_dma_init (output->dma, dma_nr, (void *) output,1 ); + } +if (output->port->class ==DDB_PORT_MOD ) { +// ddbwritel(dev, 0, CHANNEL_CONTROL(output->nr)); + }else { +ddbwritel (dev,0 ,TS_OUTPUT_CONTROL (nr)); +ddbwritel (dev,2 ,TS_OUTPUT_CONTROL (nr)); +ddbwritel (dev,0 ,TS_OUTPUT_CONTROL (nr)); + } +if (dev->has_dma) +ddbwritel (dev,0 ,DMA_BUFFER_ACK (output->dma->nr)); }static void ddb_ports_init (struct ddb *dev)
@@ -1247,15 +1900,31 @@ static void ddb_ports_init(struct ddb *dev) port->dev = dev; port->nr = i; port->i2c = &dev->i2c[i]; - port->input[0 ] = &dev->input[2 * i]; - port->input[1 ] = &dev->input[2 * i +1 ]; - port->output = &dev->output[i]; - + port->gap =4 ; + port->obr = ci_bitrate;mutex_init (&port->i2c_gate_lock);ddb_port_probe (port); -ddb_input_init (port,2 * i); -ddb_input_init (port,2 * i +1 ); -ddb_output_init (port, i); + port->dvb[0 ].adap = &dev->adap[2 * i]; + port->dvb[1 ].adap = &dev->adap[2 * i +1 ]; + +if ((dev->info->type ==DDB_OCTOPUS_CI ) || + (dev->info->type ==DDB_OCTONET ) || + (dev->info->type ==DDB_OCTOPUS )) { +if (i >=2 && dev->info->type ==DDB_OCTOPUS_CI ) { +ddb_input_init (port,2 + i,0 ,2 + i); +ddb_input_init (port,4 + i,1 ,4 + i); + }else { +ddb_input_init (port,2 * i,0 ,2 * i); +ddb_input_init (port,2 * i +1 ,1 ,2 * i +1 ); + } +ddb_output_init (port, i, i +8 ); + } +if (dev->info->type ==DDB_MOD ) { +ddb_output_init (port, i, i); + dev->handler[i +18 ] = ddbridge_mod_rate_handler; + dev->handler_data[i +18 ] = + (unsigned long ) &dev->output[i]; + } } }
@@ -1266,101 +1935,130 @@ static void ddb_ports_release(struct ddb *dev)for (i =0 ; i < dev->info->port_num; i++) { port = &dev->port[i]; - port->dev = dev; -tasklet_kill (&port->input[0 ]->tasklet); -tasklet_kill (&port->input[1 ]->tasklet); -tasklet_kill (&port->output->tasklet); +if (port->input[0 ]) +cancel_work_sync (&port->input[0 ]->dma->work); +if (port->input[1 ]) +cancel_work_sync (&port->input[1 ]->dma->work); +if (port->output) +cancel_work_sync (&port->output->dma->work); } } -/****************************************************************************/ -/****************************************************************************/ -/****************************************************************************/ +#define IRQ_HANDLE (_nr) if ((s & (1UL << _nr)) && dev->handler[_nr]) \ + dev->handler[_nr](dev->handler_data[_nr]); + +static void irq_handle_msg (struct ddb *dev,u32 s) +{ + dev->i2c_irq++; +IRQ_HANDLE (0 ); +IRQ_HANDLE (1 ); +IRQ_HANDLE (2 ); +IRQ_HANDLE (3 ); +} + +static void irq_handle_io (struct ddb *dev,u32 s) +{ + dev->ts_irq++; +IRQ_HANDLE (8 ); +IRQ_HANDLE (9 ); +IRQ_HANDLE (10 ); +IRQ_HANDLE (11 ); +IRQ_HANDLE (12 ); +IRQ_HANDLE (13 ); +IRQ_HANDLE (14 ); +IRQ_HANDLE (15 ); +IRQ_HANDLE (16 ); +IRQ_HANDLE (17 ); +IRQ_HANDLE (18 ); +IRQ_HANDLE (19 ); +if (dev->info->type !=DDB_MOD ) +return ; +IRQ_HANDLE (20 ); +IRQ_HANDLE (21 ); +IRQ_HANDLE (22 ); +IRQ_HANDLE (23 ); +IRQ_HANDLE (24 ); +IRQ_HANDLE (25 ); +IRQ_HANDLE (26 ); +IRQ_HANDLE (27 ); +} + +static irqreturn_t irq_handler0 (int irq,void *dev_id) +{ +struct ddb *dev = (struct ddb *) dev_id; +u32 s =ddbreadl (dev,INTERRUPT_STATUS ); + +do { +if (s &0x80000000 ) +return IRQ_NONE ; +if (!(s &0xfff00 )) +return IRQ_NONE ; +ddbwritel (dev, s,INTERRUPT_ACK ); +irq_handle_io (dev, s); + }while ((s =ddbreadl (dev,INTERRUPT_STATUS ))); + +return IRQ_HANDLED ; +} -static void irq_handle_i2c (struct ddb *dev,int n) +static irqreturn_t irq_handler1 (int irq,void *dev_id) { -struct ddb_i2c *i2c = &dev->i2c[n]; +struct ddb *dev = (struct ddb *) dev_id; +u32 s =ddbreadl (dev,INTERRUPT_STATUS ); - i2c->done =1 ; -wake_up (&i2c->wq); +do { +if (s &0x80000000 ) +return IRQ_NONE ; +if (!(s &0x0000f )) +return IRQ_NONE ; +ddbwritel (dev, s,INTERRUPT_ACK ); +irq_handle_msg (dev, s); + }while ((s =ddbreadl (dev,INTERRUPT_STATUS ))); + +return IRQ_HANDLED ; }static irqreturn_t irq_handler (int irq,void *dev_id) {struct ddb *dev = (struct ddb *) dev_id; -u32 s =ddbreadl (INTERRUPT_STATUS ); +u32 s =ddbreadl (dev,INTERRUPT_STATUS ); +int ret =IRQ_HANDLED ;if (!s)return IRQ_NONE ; -do { -ddbwritel (s,INTERRUPT_ACK ); - -if (s &0x00000001 ) -irq_handle_i2c (dev,0 ); -if (s &0x00000002 ) -irq_handle_i2c (dev,1 ); -if (s &0x00000004 ) -irq_handle_i2c (dev,2 ); -if (s &0x00000008 ) -irq_handle_i2c (dev,3 ); - -if (s &0x00000100 ) -tasklet_schedule (&dev->input[0 ].tasklet); -if (s &0x00000200 ) -tasklet_schedule (&dev->input[1 ].tasklet); -if (s &0x00000400 ) -tasklet_schedule (&dev->input[2 ].tasklet); -if (s &0x00000800 ) -tasklet_schedule (&dev->input[3 ].tasklet); -if (s &0x00001000 ) -tasklet_schedule (&dev->input[4 ].tasklet); -if (s &0x00002000 ) -tasklet_schedule (&dev->input[5 ].tasklet); -if (s &0x00004000 ) -tasklet_schedule (&dev->input[6 ].tasklet); -if (s &0x00008000 ) -tasklet_schedule (&dev->input[7 ].tasklet); - -if (s &0x00010000 ) -tasklet_schedule (&dev->output[0 ].tasklet); -if (s &0x00020000 ) -tasklet_schedule (&dev->output[1 ].tasklet); -if (s &0x00040000 ) -tasklet_schedule (&dev->output[2 ].tasklet); -if (s &0x00080000 ) -tasklet_schedule (&dev->output[3 ].tasklet); - -/* if (s & 0x000f0000) printk(KERN_DEBUG "%08x\n", istat); */ - }while ((s =ddbreadl (INTERRUPT_STATUS ))); - -return IRQ_HANDLED ; +if (s &0x80000000 ) +return IRQ_NONE ; +ddbwritel (dev, s,INTERRUPT_ACK ); + +if (s &0x0000000f ) +irq_handle_msg (dev, s); +if (s &0x0fffff00 ) +irq_handle_io (dev, s); + }while ((s =ddbreadl (dev,INTERRUPT_STATUS ))); + +return ret; } -/******************************************************************************/ -/******************************************************************************/ -/******************************************************************************/ -static int flashio (struct ddb *dev,u8 *wbuf,u32 wlen,u8 *rbuf,u32 rlen) {u32 data, shift;if (wlen >4 ) -ddbwritel (1 ,SPI_CONTROL ); +ddbwritel (dev,1 ,SPI_CONTROL );while (wlen >4 ) {/* FIXME: check for big-endian */ data =swab32 (*(u32 *)wbuf); wbuf +=4 ; wlen -=4 ; -ddbwritel (data,SPI_DATA ); -while (ddbreadl (SPI_CONTROL ) &0x0004 ) +ddbwritel (dev, data,SPI_DATA ); +while (ddbreadl (dev,SPI_CONTROL ) &0x0004 ) ; }if (rlen) -ddbwritel (0x0001 | ((wlen << (8 +3 )) &0x1f00 ),SPI_CONTROL ); +ddbwritel (dev,0x0001 | ((wlen << (8 +3 )) &0x1f00 ),SPI_CONTROL );else -ddbwritel (0x0003 | ((wlen << (8 +3 )) &0x1f00 ),SPI_CONTROL ); +ddbwritel (dev,0x0003 | ((wlen << (8 +3 )) &0x1f00 ),SPI_CONTROL ); data =0 ; shift = ((4 - wlen) *8 );
@@ -1372,33 +2070,33 @@ static int flashio(struct ddb *dev, u8 *wbuf, u32 wlen, u8 *rbuf, u32 rlen) }if (shift) data <<= shift; -ddbwritel (data,SPI_DATA ); -while (ddbreadl (SPI_CONTROL ) &0x0004 ) +ddbwritel (dev, data,SPI_DATA ); +while (ddbreadl (dev,SPI_CONTROL ) &0x0004 ) ;if (!rlen) { -ddbwritel (0 ,SPI_CONTROL ); +ddbwritel (dev,0 ,SPI_CONTROL );return 0 ; }if (rlen >4 ) -ddbwritel (1 ,SPI_CONTROL ); +ddbwritel (dev,1 ,SPI_CONTROL );while (rlen >4 ) { -ddbwritel (0xffffffff ,SPI_DATA ); -while (ddbreadl (SPI_CONTROL ) &0x0004 ) +ddbwritel (dev,0xffffffff ,SPI_DATA ); +while (ddbreadl (dev,SPI_CONTROL ) &0x0004 ) ; - data =ddbreadl (SPI_DATA ); + data =ddbreadl (dev,SPI_DATA ); *(u32 *) rbuf =swab32 (data); rbuf +=4 ; rlen -=4 ; } -ddbwritel (0x0003 | ((rlen << (8 +3 )) &0x1F00 ),SPI_CONTROL ); -ddbwritel (0xffffffff ,SPI_DATA ); -while (ddbreadl (SPI_CONTROL ) &0x0004 ) +ddbwritel (dev,0x0003 | ((rlen << (8 +3 )) &0x1F00 ),SPI_CONTROL ); +ddbwritel (dev,0xffffffff ,SPI_DATA ); +while (ddbreadl (dev,SPI_CONTROL ) &0x0004 ) ; - data =ddbreadl (SPI_DATA ); -ddbwritel (0 ,SPI_CONTROL ); + data =ddbreadl (dev,SPI_DATA ); +ddbwritel (dev,0 ,SPI_CONTROL );if (rlen <4 ) data <<= ((4 - rlen) *8 );
@@ -1412,6 +2110,33 @@ static int flashio(struct ddb *dev, u8 *wbuf, u32 wlen, u8 *rbuf, u32 rlen)return 0 ; } +int ddbridge_flashread (struct ddb *dev,u8 *buf,u32 addr,u32 len) +{ +u8 cmd[4 ] = {0x03 , (addr >>16 ) &0xff , + (addr >>8 ) &0xff , addr &0xff }; + +return flashio (dev, cmd,4 , buf, len); +} + +static int mdio_write (struct ddb *dev,u8 adr,u8 reg,u16 val) +{ +ddbwritel (dev, adr,MDIO_ADR ); +ddbwritel (dev, reg,MDIO_REG ); +ddbwritel (dev, val,MDIO_VAL ); +ddbwritel (dev,0x03 ,MDIO_CTRL ); +while (ddbreadl (dev,MDIO_CTRL ) &0x02 ); +return 0 ; +} + +static u16 mdio_read (struct ddb *dev,u8 adr,u8 reg) +{ +ddbwritel (dev, adr,MDIO_ADR ); +ddbwritel (dev, reg,MDIO_REG ); +ddbwritel (dev,0x07 ,MDIO_CTRL ); +while (ddbreadl (dev,MDIO_CTRL ) &0x02 ); +return ddbreadl (dev,MDIO_VAL ); +} +#define DDB_MAGIC 'd'struct ddb_flashio {
@@ -1421,19 +2146,69 @@ struct ddb_flashio {__u32 read_len; }; -#define IOCTL_DDB_FLASHIO _IOWR(DDB_MAGIC, 0x00, struct ddb_flashio) +struct ddb_gpio { +__u32 mask; +__u32 data; +}; + +struct ddb_id { +__u16 vendor; +__u16 device; +__u16 subvendor; +__u16 subdevice; +__u32 hw; +__u32 regmap; +}; + +struct ddb_reg { +__u32 reg; +__u32 val; +}; + +struct ddb_mem { +__u32 off; +__u8 *buf; +__u32 len; +}; + +struct ddb_mdio { +__u8 adr; +__u8 reg; +__u16 val; +}; + +#define IOCTL_DDB_FLASHIO _IOWR(DDB_MAGIC, 0x00, struct ddb_flashio) +#define IOCTL_DDB_GPIO_IN _IOWR(DDB_MAGIC, 0x01, struct ddb_gpio) +#define IOCTL_DDB_GPIO_OUT _IOWR(DDB_MAGIC, 0x02, struct ddb_gpio) +#define IOCTL_DDB_ID _IOR(DDB_MAGIC, 0x03, struct ddb_id) +#define IOCTL_DDB_READ_REG _IOWR(DDB_MAGIC, 0x04, struct ddb_reg) +#define IOCTL_DDB_WRITE_REG _IOW(DDB_MAGIC, 0x05, struct ddb_reg) +#define IOCTL_DDB_READ_MEM _IOWR(DDB_MAGIC, 0x06, struct ddb_mem) +#define IOCTL_DDB_WRITE_MEM _IOR(DDB_MAGIC, 0x07, struct ddb_mem) +#define IOCTL_DDB_READ_MDIO _IOWR(DDB_MAGIC, 0x08, struct ddb_mdio) +#define IOCTL_DDB_WRITE_MDIO _IOR(DDB_MAGIC, 0x09, struct ddb_mdio)#define DDB_NAME "ddbridge"static u32 ddb_num; -static struct ddb *ddbs[32 ]; -static struct class *ddb_class;static int ddb_major; +static DEFINE_MUTEX (ddb_mutex); + +static int ddb_release (struct inode *inode,struct file *file) +{ +struct ddb *dev = file->private_data; + + dev->ddb_dev_users--; +return 0 ; +}static int ddb_open (struct inode *inode,struct file *file) {struct ddb *dev = ddbs[iminor (inode)]; +if (dev->ddb_dev_users) +return -EBUSY ; + dev->ddb_dev_users++; file->private_data = dev;return 0 ; }
@@ -1470,6 +2245,103 @@ static long ddb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)return -EFAULT ;break ; } +case IOCTL_DDB_GPIO_OUT : + { +struct ddb_gpio gpio; +if (copy_from_user (&gpio, parg,sizeof (gpio))) +return -EFAULT ; +ddbwritel (dev, gpio.mask,GPIO_DIRECTION ); +ddbwritel (dev, gpio.data,GPIO_OUTPUT ); +break ; + } +case IOCTL_DDB_ID : + { +struct ddb_id ddbid; + + ddbid.vendor = dev->id->vendor; + ddbid.device = dev->id->device; + ddbid.subvendor = dev->id->subvendor; + ddbid.subdevice = dev->id->subdevice; + ddbid.hw =ddbreadl (dev,0 ); + ddbid.regmap =ddbreadl (dev,4 ); +if (copy_to_user (parg, &ddbid,sizeof (ddbid))) +return -EFAULT ; +break ; + } +case IOCTL_DDB_READ_REG : + { +struct ddb_reg reg; + +if (copy_from_user (®, parg,sizeof (reg))) +return -EFAULT ; +if (reg.reg >= dev->regs_len) +return -EINVAL ; + reg.val =ddbreadl (dev, reg.reg); +if (copy_to_user (parg, ®,sizeof (reg))) +return -EFAULT ; +break ; + } +case IOCTL_DDB_WRITE_REG : + { +struct ddb_reg reg; + +if (copy_from_user (®, parg,sizeof (reg))) +return -EFAULT ; +if (reg.reg >= dev->regs_len) +return -EINVAL ; +ddbwritel (dev, reg.val, reg.reg); +break ; + } +case IOCTL_DDB_READ_MDIO : + { +struct ddb_mdio mdio; + +if (copy_from_user (&mdio, parg,sizeof (mdio))) +return -EFAULT ; + mdio.val =mdio_read (dev, mdio.adr, mdio.reg); +if (copy_to_user (parg, &mdio,sizeof (mdio))) +return -EFAULT ; +break ; + } +case IOCTL_DDB_WRITE_MDIO : + { +struct ddb_mdio mdio; + +if (copy_from_user (&mdio, parg,sizeof (mdio))) +return -EFAULT ; +mdio_write (dev, mdio.adr, mdio.reg, mdio.val); +break ; + } +case IOCTL_DDB_READ_MEM : + { +struct ddb_mem mem; +u8 *buf = &dev->iobuf[0 ]; + +if (copy_from_user (&mem, parg,sizeof (mem))) +return -EFAULT ; +if ((mem.len + mem.off > dev->regs_len) || + mem.len >1024 ) +return -EINVAL ; +ddbcpyfrom (dev, buf, mem.off, mem.len); +if (copy_to_user (mem.buf, buf, mem.len)) +return -EFAULT ; +break ; + } +case IOCTL_DDB_WRITE_MEM : + { +struct ddb_mem mem; +u8 *buf = &dev->iobuf[0 ]; + +if (copy_from_user (&mem, parg,sizeof (mem))) +return -EFAULT ; +if ((mem.len + mem.off > dev->regs_len) || + mem.len >1024 ) +return -EINVAL ; +if (copy_from_user (buf, mem.buf, mem.len)) +return -EFAULT ; +ddbcpyto (dev, mem.off, buf, mem.len); +break ; + }default :return -ENOTTY ; }
@@ -1479,61 +2351,425 @@ static long ddb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)static const struct file_operations ddb_fops = { .unlocked_ioctl = ddb_ioctl, .open = ddb_open, + .release = ddb_release, }; +#if (LINUX_VERSION_CODE <KERNEL_VERSION (3 ,4 ,0 )) +static char *ddb_devnode(struct device *device, mode_t *mode) +#else static char *ddb_devnode(struct device *device, umode_t *mode) +#endif {struct ddb *dev =dev_get_drvdata (device);return kasprintf (GFP_KERNEL ,"ddbridge/card%d" , dev->nr); } +#define __ATTR_MRO (_name, _show) { \ + .attr = { .name = __stringify(_name), .mode = 0444 }, \ + .show = _show, \ +} + +#define __ATTR_MWO (_name, _store) { \ + .attr = { .name = __stringify(_name), .mode = 0222 }, \ + .store = _store, \ +} + +static ssize_t ports_show (struct device *device,struct device_attribute *attr,char *buf) +{ +struct ddb *dev =dev_get_drvdata (device); + +return sprintf (buf,"%d\n" , dev->info->port_num); +} + +static ssize_t ts_irq_show (struct device *device,struct device_attribute *attr,char *buf) +{ +struct ddb *dev =dev_get_drvdata (device); + +return sprintf (buf,"%d\n" , dev->ts_irq); +} + +static ssize_t i2c_irq_show (struct device *device,struct device_attribute *attr,char *buf) +{ +struct ddb *dev =dev_get_drvdata (device); + +return sprintf (buf,"%d\n" , dev->i2c_irq); +}
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
1.8.4.2
Part of the diff is not shown here. View the raw message.
PATCH 11/12 ddbridge: Update ddbridge header for 0.9.10 changes
In reply to Maik BroemmeUpdated ddbridge header for 0.9.10 changes.
--- drivers/media/pci/ddbridge/ddbridge.h | 408 ++++++++++++++++++++++++++++------ 1 file changed, 343 insertions(+), 65 deletions(-)
drivers/media/pci/ddbridge/ddbridge.h +343 -65
@@ -1,38 +1,69 @@/* -* ddbridge.h: Digital Devices PCIe bridge driver +* ddbridge.h: Digital Devices PCIe bridge driver * -* Copyright (C) 2010-2011 Digital Devices GmbH +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> * -* This program is free software; you can redistribute it and/or -* modify it under the terms of the GNU General Public License -* version 2 only, as published by the Free Software Foundation. +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. * +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. * -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* -* You should have received a copy of the GNU General Public License -* along with this program; if not, write to the Free Software -* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -* 02110-1301, USA -* Or, point your browser to http://www.gnu.org/copyleft/gpl.html +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA */ #ifndef _DDBRIDGE_H_#define _DDBRIDGE_H_ +#include <linux/version.h> + +#if (LINUX_VERSION_CODE >=KERNEL_VERSION (3 ,8 ,0 )) +#define __devexit +#define __devinit +#endif + +#include <linux/module.h> +#include <linux/init.h> +#include <linux/interrupt.h> +#include <linux/delay.h> +#include <linux/slab.h> +#include <linux/poll.h> +#include <linux/io.h> +#include <linux/pci.h> +#include <linux/pci_ids.h> +#include <linux/timer.h> +#include <linux/i2c.h> +#include <linux/swab.h> +#include <linux/vmalloc.h> +#include <linux/workqueue.h> +#include <linux/kthread.h> +#include <linux/platform_device.h> +#include <linux/clk.h> +#include <linux/spi/spi.h> +#include <linux/gpio.h> +#include <linux/completion.h> +#include <linux/types.h> #include <linux/sched.h> #include <linux/interrupt.h> #include <linux/i2c.h> #include <linux/mutex.h> #include <asm/dma.h> -#include <linux/dvb/frontend.h> +#include <asm/io.h> +#include <asm/irq.h> +#include <asm/uaccess.h> +#include <linux/dvb/ca.h> #include <linux/socket.h> +#include <linux/device.h> +#include <linux/io.h> #include "dmxdev.h" #include "dvbdev.h"
@@ -44,51 +75,83 @@#include "cxd2099.h" #define DDB_MAX_I2C 4 -#define DDB_MAX_PORT 4 +#define DDB_MAX_PORT 10#define DDB_MAX_INPUT 8 -#define DDB_MAX_OUTPUT 4 +#define DDB_MAX_OUTPUT 10 + +struct ddb_regset { +uint32_t base; +uint32_t num; +uint32_t size; +}; + +struct ddb_regmap { +struct ddb_regset i2c; +struct ddb_regset i2c_buf; +struct ddb_regset dma; +struct ddb_regset dma_buf; +struct ddb_regset input; +struct ddb_regset output; +struct ddb_regset channel; +struct ddb_regset ci; +struct ddb_regset pid_filter; +};struct ddb_info {int type;#define DDB_NONE 0#define DDB_OCTOPUS 1 +#define DDB_OCTOPUS_CI 2 +#define DDB_MOD 3 +#define DDB_OCTONET 4char *name;int port_num; -u32 port_type[DDB_MAX_PORT ]; +int i2c_num; +int led_num; +int fan_num; +int temp_num; +int temp_bus; +struct ddb_regmap regmap; }; -/* DMA_SIZE MUST be divisible by 188 and 128 !!! */ +/* DMA_SIZE MUST be smaller than 256k and +MUST be divisible by 188 and 128 !!! */ + +#define DMA_MAX_BUFS 32/* hardware table limit */ -#define INPUT_DMA_MAX_BUFS 32/* hardware table limit */ #define INPUT_DMA_BUFS 8#define INPUT_DMA_SIZE (128*47*21) +#define INPUT_DMA_IRQ_DIV 1 -#define OUTPUT_DMA_MAX_BUFS 32#define OUTPUT_DMA_BUFS 8#define OUTPUT_DMA_SIZE (128*47*21) +#define OUTPUT_DMA_IRQ_DIV 1struct ddb ;struct ddb_port ; -struct ddb_input { -struct ddb_port *port; +struct ddb_dma { +void *io;u32 nr; -int attached; - -dma_addr_t pbuf[INPUT_DMA_MAX_BUFS ]; -u8 *vbuf[INPUT_DMA_MAX_BUFS ]; -u32 dma_buf_num; -u32 dma_buf_size; - -struct tasklet_struct tasklet; +dma_addr_t pbuf[DMA_MAX_BUFS ]; +u8 *vbuf[DMA_MAX_BUFS ]; +u32 num; +u32 size; +u32 div; +u32 bufreg; +struct work_struct work;spinlock_t lock;wait_queue_head_t wq;int running;u32 stat; +u32 ctrl;u32 cbuf;u32 coff; +}; -struct dvb_adapter adap; +struct ddb_dvb { +struct dvb_adapter *adap; +int adap_registered;struct dvb_device *dev;struct dvb_frontend *fe;struct dvb_frontend *fe2;
@@ -99,37 +162,35 @@ struct ddb_input {struct dmx_frontend mem_frontend;int users;int (*gate_ctrl)(struct dvb_frontend *,int ); +int attached; }; -struct ddb_output { +struct ddb_ci { +struct dvb_ca_en50221 en;struct ddb_port *port;u32 nr; -dma_addr_t pbuf[OUTPUT_DMA_MAX_BUFS ]; -u8 *vbuf[OUTPUT_DMA_MAX_BUFS ]; -u32 dma_buf_num; -u32 dma_buf_size; -struct tasklet_struct tasklet; -spinlock_t lock; -wait_queue_head_t wq; -int running; -u32 stat; -u32 cbuf; -u32 coff; +struct mutex lock; +}; -struct dvb_adapter adap; -struct dvb_device *dev; +struct ddb_io { +struct ddb_port *port; +u32 nr; +struct ddb_dma *dma; +struct ddb_io *redo; +struct ddb_io *redi; }; +#define ddb_output ddb_io +#define ddb_input ddb_io +struct ddb_i2c {struct ddb *dev;u32 nr;struct i2c_adapter adap; -struct i2c_adapter adap2;u32 regs;u32 rbuf;u32 wbuf; -int done; -wait_queue_head_t wq; +struct completion completion; };struct ddb_port {
@@ -141,45 +202,262 @@ struct ddb_port {#define DDB_PORT_NONE 0#define DDB_PORT_CI 1#define DDB_PORT_TUNER 2 +#define DDB_PORT_LOOP 3 +#define DDB_PORT_MOD 4u32 type;#define DDB_TUNER_NONE 0#define DDB_TUNER_DVBS_ST 1#define DDB_TUNER_DVBS_ST_AA 2 -#define DDB_TUNER_DVBCT_TR 16 -#define DDB_TUNER_DVBCT_ST 17 +#define DDB_TUNER_DVBCT_TR 3 +#define DDB_TUNER_DVBCT_ST 4 +#define DDB_CI_INTERNAL 5 +#define DDB_CI_EXTERNAL_SONY 6 +#define DDB_TUNER_XO2 16 +#define DDB_TUNER_DVBS 16 +#define DDB_TUNER_DVBCT2_SONY 17 +#define DDB_TUNER_ISDBT_SONY 18 +#define DDB_TUNER_DVBC2T2_SONY 19 +#define DDB_TUNER_ATSC_ST 20 +#define DDB_TUNER_DVBC2T2_ST 21 +u32 adr;struct ddb_input *input[2 ];struct ddb_output *output;struct dvb_ca_en50221 *en; +struct ddb_dvb dvb[2 ]; +u32 gap; +u32 obr; +}; + +struct mod_base { +u32 frequency; + +u32 flat_start; +u32 flat_end; +}; + +struct mod_state { +u32 modulation; + +u32 do_handle; + +u32 rate_inc; +u32 Control; +u32 State; +u32 StateCounter; +s32 LastPCRAdjust; +s32 PCRAdjustSum; +s32 InPacketsSum; +s32 OutPacketsSum; +s64 PCRIncrement; +s64 PCRDecrement; +s32 PCRRunningCorr; +u32 OutOverflowPacketCount; +u32 InOverflowPacketCount; +u32 LastOutPacketCount; +u32 LastInPacketCount; +u64 LastOutPackets; +u64 LastInPackets; +u32 MinInputPackets; +}; + +#define CM_STARTUP_DELAY 2 +#define CM_AVERAGE 20 +#define CM_GAIN 10 + +#define HW_LSB_SHIFT 12 +#define HW_LSB_MASK 0x1000 + +#define CM_IDLE 0 +#define CM_STARTUP 1 +#define CM_ADJUST 2 + +#define TS_CAPTURE_LEN (21*188) + +/* net streaming hardware block */ +#define DDB_NS_MAX 15 + +struct ddb_ns { +struct ddb_input *input; +int nr; +int fe; +u32 rtcp_udplen; +u32 rtcp_len; +u32 ts_offset; +u32 udplen; +u8 p[512 ]; };struct ddb {struct pci_dev *pdev; +struct platform_device *pfdev; +struct device *dev; +const struct pci_device_id *id; +struct ddb_info *info; +int msi; +struct workqueue_struct *wq; +u32 has_dma; +u32 has_ns; + +struct ddb_regmap regmap;unsigned char *regs; +u32 regs_len;struct ddb_port port[DDB_MAX_PORT ];struct ddb_i2c i2c[DDB_MAX_I2C ];struct ddb_input input[DDB_MAX_INPUT ];struct ddb_output output[DDB_MAX_OUTPUT ]; +struct dvb_adapter adap[DDB_MAX_INPUT ]; +struct ddb_dma dma[DDB_MAX_INPUT +DDB_MAX_OUTPUT ]; + +void (*handler[32 ])(unsigned long ); +unsigned long handler_data[32 ];struct device *ddb_dev; -int nr; +u32 ddb_dev_users; +u32 nr;u8 iobuf[1028 ]; -struct ddb_info *info; -int msi; +u8 leds; +u32 ts_irq; +u32 i2c_irq; + +u32 hwid; +u32 regmapid; +u32 mac; +u32 devid; + +int ns_num; +struct ddb_ns ns[DDB_NS_MAX ]; +struct mutex mutex; + +struct dvb_device *nsd_dev; +u8 tsbuf[TS_CAPTURE_LEN ]; + +struct mod_base mod_base; +struct mod_state mod[10 ]; +}; + +static inline void ddbwriteb (struct ddb *dev,u32 val,u32 adr) +{ +writeb (val, (char *) (dev->regs+(adr))); +} + +static inline void ddbwritel (struct ddb *dev,u32 val,u32 adr) +{ +writel (val, (char *) (dev->regs+(adr))); +} + +static inline void ddbwritew (struct ddb *dev,u16 val,u32 adr) +{ +writew (val, (char *) (dev->regs+(adr))); +} + +static inline u32 ddbreadl (struct ddb *dev,u32 adr) +{ +return readl ((char *) (dev->regs+(adr))); +} + +static inline u32 ddbreadb (struct ddb *dev,u32 adr) +{ +return readb ((char *) (dev->regs+(adr))); +} + +#define ddbcpyto (_dev, _adr, _src, _count) \ + memcpy_toio((char *) (_dev->regs + (_adr)), (_src), (_count)) + +#define ddbcpyfrom (_dev, _dst, _adr, _count) \ + memcpy_fromio((_dst), (char *) (_dev->regs + (_adr)), (_count)) + +#define ddbmemset (_dev, _adr, _val, _count) \ + memset_io((char *) (_dev->regs + (_adr)), (_val), (_count)) + +#define dd_uint8 u8 +#define dd_uint16 u16 +#define dd_int16 s16 +#define dd_uint32 u32 +#define dd_int32 s32 +#define dd_uint64 u64 +#define dd_int64 s64 + +#define DDMOD_FLASH_START 0x1000 + +struct DDMOD_FLASH_DS { +dd_uint32 Symbolrate;/* kSymbols/s */ +dd_uint32 DACFrequency;/* kHz */ +dd_uint16 FrequencyResolution;/* kHz */ +dd_uint16 IQTableLength; +dd_uint16 FrequencyFactor; +dd_int16 PhaseCorr;/* TBD */ +dd_uint32 Control2; +dd_uint16 PostScaleI; +dd_uint16 PostScaleQ; +dd_uint16 PreScale; +dd_int16 EQTap[11 ]; +dd_uint16 FlatStart; +dd_uint16 FlatEnd; +dd_uint32 FlashOffsetPrecalculatedIQTables;/* 0 = none */ +dd_uint8 Reserved[28 ]; + +}; + +struct DDMOD_FLASH { +dd_uint32 Magic; +dd_uint16 Version; +dd_uint16 DataSets; + +dd_uint16 VCORefFrequency;/* MHz */ +dd_uint16 VCO1Frequency;/* MHz */ +dd_uint16 VCO2Frequency;/* MHz */ + +dd_uint16 DACAux1;/* TBD */ +dd_uint16 DACAux2;/* TBD */ + +dd_uint8 Reserved1[238 ]; + +struct DDMOD_FLASH_DS DataSet[1 ]; +}; + +#define DDMOD_FLASH_MAGIC 0x5F564d5F + +struct dvb_mod_params { +__u32 base_frequency; +__u32 attenuator; }; -/****************************************************************************/ +struct dvb_mod_channel_params { +enum fe_modulation modulation; +__u32 rate_increment; +}; + +#define DVB_MOD_SET _IOW('o', 208, struct dvb_mod_params) +#define DVB_MOD_CHANNEL_SET _IOW('o', 209, struct dvb_mod_channel_params) + +/* DDBridge flash functions (ddbridge-core.c) */ +int ddbridge_flashread (struct ddb *dev,u8 *buf,u32 addr,u32 len); -#define ddbwritel (_val, _adr) writel((_val), \ - (char *) (dev->regs+(_adr))) -#define ddbreadl (_adr) readl((char *) (dev->regs+(_adr))) -#define ddbcpyto (_adr, _src, _count) memcpy_toio((char *) \ - (dev->regs+(_adr)), (_src), (_count)) -#define ddbcpyfrom (_dst, _adr, _count) memcpy_fromio((_dst), (char *) \ - (dev->regs+(_adr)), (_count)) +/* DDBridge DVB-C modulator functions (ddbridge-mod.c) */ +int ddbridge_mod_do_ioctl (struct file *file,unsigned int cmd,void *parg); +int ddbridge_mod_init (struct ddb *dev); +void ddbridge_mod_output_stop (struct ddb_output *output); +void ddbridge_mod_output_start (struct ddb_output *output); +void ddbridge_mod_rate_handler (unsigned long data); -/****************************************************************************/ +/* DDBrigde I2C functions (ddbridge-i2c.c) */ +int ddb_i2c_write (struct i2c_adapter *adap,u8 adr,u8 *data,int len); +int ddb_i2c_read (struct i2c_adapter *adapter,u8 adr,u8 *val); +int ddb_i2c_read_regs (struct i2c_adapter *adapter, +u8 adr,u8 reg,u8 *val,u8 len); +int ddb_i2c_read_regs16 (struct i2c_adapter *adapter, +u8 adr,u16 reg,u8 *val,u8 len); +int ddb_i2c_read_reg (struct i2c_adapter *adapter,u8 adr,u8 reg,u8 *val); +int ddb_i2c_read_reg16 (struct i2c_adapter *adapter,u8 adr, +u16 reg,u8 *val); +int ddb_i2c_write_reg16 (struct i2c_adapter *adap,u8 adr, +u16 reg,u8 val); +int ddb_i2c_write_reg (struct i2c_adapter *adap,u8 adr, +u8 reg,u8 val); +void ddb_i2c_release (struct ddb *dev); +int ddb_i2c_init (struct ddb *dev);#endif
Signature · 1 line
1.8.4.2
PATCH 12/12 ddbridge: Kconfig and Makefile fixes to build latest ddbridge
In reply to Maik BroemmeFixed Kconfig and Makefile to build latest version off ddbridge. It adds support for the following devices:
- Octopus DVB adapter
- Octopus V3 DVB adapter
- Octopus LE DVB adapter
- Octopus OEM
- Octopus Mini
- Cine S2 V6 DVB adapter
- Cine S2 V6.5 DVB adapter
- Octopus CI
- Octopus CI single
- DVBCT V6.1 DVB adapter
- DVB-C modulator
- SaTiX-S2 V3 DVB adapter
--- drivers/media/pci/ddbridge/Kconfig | 21 +++++++++++++++------ drivers/media/pci/ddbridge/Makefile | 2 +- 2 files changed, 16 insertions(+), 7 deletions(-)
drivers/media/pci/ddbridge/Kconfig +15 -6
@@ -6,13 +6,22 @@ config DVB_DDBRIDGE select DVB_STV090x if MEDIA_SUBDRV_AUTOSELECT select DVB_DRXK if MEDIA_SUBDRV_AUTOSELECT select DVB_TDA18271C2DD if MEDIA_SUBDRV_AUTOSELECT + select DVB_STV0367DD if MEDIA_SUBDRV_AUTOSELECT + select DVB_TDA18212DD if MEDIA_SUBDRV_AUTOSELECT + select DVB_CXD2843 if MEDIA_SUBDRV_AUTOSELECT ---help--- Support for cards with the Digital Devices PCI express bridge: - - Octopus PCIe Bridge - - Octopus mini PCIe Bridge - - Octopus LE - - DuoFlex S2 Octopus - - DuoFlex CT Octopus - - cineS2(v6) + - Octopus DVB adapter + - Octopus V3 DVB adapter + - Octopus LE DVB adapter + - Octopus OEM + - Octopus Mini + - Cine S2 V6 DVB adapter + - Cine S2 V6.5 DVB adapter + - Octopus CI + - Octopus CI single + - DVBCT V6.1 DVB adapter + - DVB-C modulator + - SaTiX-S2 V3 DVB adapter Say Y if you own such a card and want to use it.
drivers/media/pci/ddbridge/Makefile +1 -1
@@ -2,7 +2,7 @@ # Makefile for the ddbridge device driver # -ddbridge-objs := ddbridge-core.o +ddbridge-objs := ddbridge-core.o ddbridge-i2c.o ddbridge-mod.o obj-$(CONFIG_DVB_DDBRIDGE) += ddbridge.o
Signature · 1 line
1.8.4.2
Re: [PATCH 01/12] dvb-frontends: Support for DVB-C2 to DVB frontends
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:24:25 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 13 lines
Added support for DVB-C2 to DVB frontends. It will be required by cxd2843 and tda18212dd (Digital Devices) frontends.
Signed-off-by Maik Broemme <[email protected]>--- include/uapi/linux/dvb/frontend.h | 1 + 1 file changed, 1 insertion(+)include/uapi/linux/dvb/frontend.h +0
-0
include/uapi/linux/dvb/frontend.h typedef enum fe_delivery_system { · line 416
Quoted 7 lines
include/uapi/linux/dvb/frontend.h +1
-0@@ -410,6 +410,7 @@ typedef enum fe_delivery_system {SYS_DVBT2 ,SYS_TURBO ,SYS_DVBC_ANNEX_C , +SYS_DVBC2 , } fe_delivery_system_t;/* backward compatibility */
Please update also the documentation, at Documentation/DocBook/media/dvb.
Doesn't DVB-C2 provide any newer property? If so, please add it there as well, and at frontend.h.
Regards,
Maur
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 02/12] tda18271c2dd: Fix description of NXP TDA18271C2 silicon tuner
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:25:23 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 16 lines
Added (DD) to NXP TDA18271C2 silicon tuner as this tuner was specifically added for Digital Devices ddbridge driver.
Signed-off-by Maik Broemme <[email protected]>--- drivers/media/dvb-frontends/Kconfig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)drivers/media/dvb-frontends/Kconfig +0
-0@@ -48,11 +48,11 @@ config DVB_DRXK Say Y when you want to support this frontend. config DVB_TDA18271C2DD
drivers/media/dvb-frontends/Kconfig config DVB_DRXK · line 58
Quoted 10 lines
drivers/media/dvb-frontends/Kconfig +2
-2- tristate "NXP TDA18271C2 silicon tuner" + tristate "NXP TDA18271C2 silicon tuner (DD)" depends on DVB_CORE && I2C default m if !MEDIA_SUBDRV_AUTOSELECT help - NXP TDA18271 silicon tuner. + NXP TDA18271 silicon tuner (Digital Devices driver). Say Y when you want to support this tuner.
The better is to use the other tda18271 driver. This one was added as a temporary alternative, as the more complete one were lacking some features, and were not working with DRX-K. Well, those got fixed already, and we now want to get rid of this duplicated driver.
Regards,
Mauro
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 03/12] stv0367dd: Support for STV 0367 DVB-C/T (DD) demodulator
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:28:50 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 3 lines
Added support for the STV 0367 DVB-C/T demodulator used by recent Digital Devices hardware. This will allow update of ddbridge driver to support newer devices like DVBCT V6.1 DVB adapter.
We have already a driver for stv0367. Please re-use it, adding there the missing features (if any).
Regards,
Mauro
Quoted 5,882 lines
Signed-off-by Maik Broemme <[email protected]>--- drivers/media/dvb-frontends/Kconfig | 9 + drivers/media/dvb-frontends/Makefile | 1 + drivers/media/dvb-frontends/stv0367dd.c | 2329 +++++++++++++++++ drivers/media/dvb-frontends/stv0367dd.h | 48 + drivers/media/dvb-frontends/stv0367dd_regs.h | 3442 ++++++++++++++++++++++++++ 5 files changed, 5829 insertions(+) create mode 100644 drivers/media/dvb-frontends/stv0367dd.c create mode 100644 drivers/media/dvb-frontends/stv0367dd.h create mode 100644 drivers/media/dvb-frontends/stv0367dd_regs.hdrivers/media/dvb-frontends/Kconfig +9
-0@@ -56,6 +56,15 @@ config DVB_TDA18271C2DD Say Y when you want to support this tuner. +config DVB_STV0367DD + tristate "STV 0367 (DD)" + depends on DVB_CORE && I2C + default m if DVB_FE_CUSTOMISE + help + STV 0367 DVB-C/T demodulator (Digital Devices driver). + + Say Y when you want to support this frontend. + comment "DVB-S (satellite) frontends" depends on DVB_COREdrivers/media/dvb-frontends/Makefile +1
-0@@ -97,6 +97,7 @@ obj-$(CONFIG_DVB_STV0367) += stv0367.o obj-$(CONFIG_DVB_CXD2820R) += cxd2820r.o obj-$(CONFIG_DVB_DRXK) += drxk.o obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o +obj-$(CONFIG_DVB_STV0367DD) += stv0367dd.o obj-$(CONFIG_DVB_IT913X_FE) += it913x-fe.o obj-$(CONFIG_DVB_A8293) += a8293.o obj-$(CONFIG_DVB_TDA10071) += tda10071.odrivers/media/dvb-frontends/stv0367dd.c new file +2329
-0@@ -0,0 +1,2329 @@ +/* +* stv0367dd.c: STV0367 DVB-C/T demodulator driver +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/init.h> +#include <linux/delay.h> +#include <linux/firmware.h> +#include <linux/i2c.h> +#include <linux/version.h> +#include <asm/div64.h> + +#include "dvb_frontend.h" +#include "stv0367dd.h" +#include "stv0367dd_regs.h" + +enum omode {OM_NONE ,OM_DVBT ,OM_DVBC ,OM_QAM_ITU_C }; +enum {QAM_MOD_QAM4 =0 , +QAM_MOD_QAM16 , +QAM_MOD_QAM32 , +QAM_MOD_QAM64 , +QAM_MOD_QAM128 , +QAM_MOD_QAM256 , +QAM_MOD_QAM512 , +QAM_MOD_QAM1024 +}; + +enum {QAM_SPECT_NORMAL ,QAM_SPECT_INVERTED }; + +enum { +QAM_FEC_A =1 ,/* J83 Annex A */ +QAM_FEC_B = (1 <<1 ),/* J83 Annex B */ +QAM_FEC_C = (1 <<2 )/* J83 Annex C */ +}; + +enum EDemodState { Off, QAMSet, OFDMSet, QAMStarted, OFDMStarted }; + +struct stv_state { +#ifdef USE_API3 +struct dvb_frontend c_frontend; +struct dvb_frontend t_frontend; +#else +struct dvb_frontend frontend; +#endif +fe_modulation_t modulation; +u32 symbol_rate; +u32 bandwidth; +struct device *dev; + +struct i2c_adapter *i2c; +u8 adr; +void *priv; + +struct mutex mutex; +struct mutex ctlock; + +u32 master_clock; +u32 adc_clock; +u8 ID; +u8 I2CRPT; +u32 omode; +u8 qam_inversion; + +s32 IF; + +s32 m_FECTimeOut; +s32 m_DemodTimeOut; +s32 m_SignalTimeOut; +s32 m_DemodLockTime; +s32 m_FFTTimeOut; +s32 m_TSTimeOut; + +bool m_bFirstTimeLock; + +u8 m_Save_QAM_AGC_CTL; + +enum EDemodState demod_state; + +u8 m_OFDM_FFTMode;// 0 = 2k, 1 = 8k, 2 = 4k +u8 m_OFDM_Modulation;// +u8 m_OFDM_FEC;// +u8 m_OFDM_Guard; + +u32 ucblocks; +u32 ber; +}; + +struct init_table { +u16 adr; +u8 data; +}; + +struct init_table base_init[] = { + {R367_IOCFG0 ,0x80 }, + {R367_DAC0R ,0x00 }, + {R367_IOCFG1 ,0x00 }, + {R367_DAC1R ,0x00 }, + {R367_IOCFG2 ,0x00 }, + {R367_SDFR ,0x00 }, + {R367_AUX_CLK ,0x00 }, + {R367_FREESYS1 ,0x00 }, + {R367_FREESYS2 ,0x00 }, + {R367_FREESYS3 ,0x00 }, + {R367_GPIO_CFG ,0x55 }, + {R367_GPIO_CMD ,0x01 }, + {R367_TSTRES ,0x00 }, + {R367_ANACTRL ,0x00 }, + {R367_TSTBUS ,0x00 }, + {R367_RF_AGC2 ,0x20 }, + {R367_ANADIGCTRL ,0x0b }, + {R367_PLLMDIV ,0x01 }, + {R367_PLLNDIV ,0x08 }, + {R367_PLLSETUP ,0x18 }, + {R367_DUAL_AD12 ,0x04 }, + {R367_TSTBIST ,0x00 }, + {0x0000 ,0x00 } +}; + +struct init_table qam_init[] = { + {R367_QAM_CTRL_1 ,0x06 },// Orginal 0x04 + {R367_QAM_CTRL_2 ,0x03 }, + {R367_QAM_IT_STATUS1 ,0x2b }, + {R367_QAM_IT_STATUS2 ,0x08 }, + {R367_QAM_IT_EN1 ,0x00 }, + {R367_QAM_IT_EN2 ,0x00 }, + {R367_QAM_CTRL_STATUS ,0x04 }, + {R367_QAM_TEST_CTL ,0x00 }, + {R367_QAM_AGC_CTL ,0x73 }, + {R367_QAM_AGC_IF_CFG ,0x50 }, + {R367_QAM_AGC_RF_CFG ,0x02 },// RF Freeze + {R367_QAM_AGC_PWM_CFG ,0x03 }, + {R367_QAM_AGC_PWR_REF_L ,0x5a }, + {R367_QAM_AGC_PWR_REF_H ,0x00 }, + {R367_QAM_AGC_RF_TH_L ,0xff }, + {R367_QAM_AGC_RF_TH_H ,0x07 }, + {R367_QAM_AGC_IF_LTH_L ,0x00 }, + {R367_QAM_AGC_IF_LTH_H ,0x08 }, + {R367_QAM_AGC_IF_HTH_L ,0xff }, + {R367_QAM_AGC_IF_HTH_H ,0x07 }, + {R367_QAM_AGC_PWR_RD_L ,0xa0 }, + {R367_QAM_AGC_PWR_RD_M ,0xe9 }, + {R367_QAM_AGC_PWR_RD_H ,0x03 }, + {R367_QAM_AGC_PWM_IFCMD_L ,0xe4 }, + {R367_QAM_AGC_PWM_IFCMD_H ,0x00 }, + {R367_QAM_AGC_PWM_RFCMD_L ,0xff }, + {R367_QAM_AGC_PWM_RFCMD_H ,0x07 }, + {R367_QAM_IQDEM_CFG ,0x01 }, + {R367_QAM_MIX_NCO_LL ,0x22 }, + {R367_QAM_MIX_NCO_HL ,0x96 }, + {R367_QAM_MIX_NCO_HH ,0x55 }, + {R367_QAM_SRC_NCO_LL ,0xff }, + {R367_QAM_SRC_NCO_LH ,0x0c }, + {R367_QAM_SRC_NCO_HL ,0xf5 }, + {R367_QAM_SRC_NCO_HH ,0x20 }, + {R367_QAM_IQDEM_GAIN_SRC_L ,0x06 }, + {R367_QAM_IQDEM_GAIN_SRC_H ,0x01 }, + {R367_QAM_IQDEM_DCRM_CFG_LL ,0xfe }, + {R367_QAM_IQDEM_DCRM_CFG_LH ,0xff }, + {R367_QAM_IQDEM_DCRM_CFG_HL ,0x0f }, + {R367_QAM_IQDEM_DCRM_CFG_HH ,0x00 }, + {R367_QAM_IQDEM_ADJ_COEFF0 ,0x34 }, + {R367_QAM_IQDEM_ADJ_COEFF1 ,0xae }, + {R367_QAM_IQDEM_ADJ_COEFF2 ,0x46 }, + {R367_QAM_IQDEM_ADJ_COEFF3 ,0x77 }, + {R367_QAM_IQDEM_ADJ_COEFF4 ,0x96 }, + {R367_QAM_IQDEM_ADJ_COEFF5 ,0x69 }, + {R367_QAM_IQDEM_ADJ_COEFF6 ,0xc7 }, + {R367_QAM_IQDEM_ADJ_COEFF7 ,0x01 }, + {R367_QAM_IQDEM_ADJ_EN ,0x04 }, + {R367_QAM_IQDEM_ADJ_AGC_REF ,0x94 }, + {R367_QAM_ALLPASSFILT1 ,0xc9 }, + {R367_QAM_ALLPASSFILT2 ,0x2d }, + {R367_QAM_ALLPASSFILT3 ,0xa3 }, + {R367_QAM_ALLPASSFILT4 ,0xfb }, + {R367_QAM_ALLPASSFILT5 ,0xf6 }, + {R367_QAM_ALLPASSFILT6 ,0x45 }, + {R367_QAM_ALLPASSFILT7 ,0x6f }, + {R367_QAM_ALLPASSFILT8 ,0x7e }, + {R367_QAM_ALLPASSFILT9 ,0x05 }, + {R367_QAM_ALLPASSFILT10 ,0x0a }, + {R367_QAM_ALLPASSFILT11 ,0x51 }, + {R367_QAM_TRL_AGC_CFG ,0x20 }, + {R367_QAM_TRL_LPF_CFG ,0x28 }, + {R367_QAM_TRL_LPF_ACQ_GAIN ,0x44 }, + {R367_QAM_TRL_LPF_TRK_GAIN ,0x22 }, + {R367_QAM_TRL_LPF_OUT_GAIN ,0x03 }, + {R367_QAM_TRL_LOCKDET_LTH ,0x04 }, + {R367_QAM_TRL_LOCKDET_HTH ,0x11 }, + {R367_QAM_TRL_LOCKDET_TRGVAL ,0x20 }, + {R367_QAM_IQ_QAM ,0x01 }, + {R367_QAM_FSM_STATE ,0xa0 }, + {R367_QAM_FSM_CTL ,0x08 }, + {R367_QAM_FSM_STS ,0x0c }, + {R367_QAM_FSM_SNR0_HTH ,0x00 }, + {R367_QAM_FSM_SNR1_HTH ,0x00 }, + {R367_QAM_FSM_SNR2_HTH ,0x00 }, + {R367_QAM_FSM_SNR0_LTH ,0x00 }, + {R367_QAM_FSM_SNR1_LTH ,0x00 }, + {R367_QAM_FSM_EQA1_HTH ,0x00 }, + {R367_QAM_FSM_TEMPO ,0x32 }, + {R367_QAM_FSM_CONFIG ,0x03 }, + {R367_QAM_EQU_I_TESTTAP_L ,0x11 }, + {R367_QAM_EQU_I_TESTTAP_M ,0x00 }, + {R367_QAM_EQU_I_TESTTAP_H ,0x00 }, + {R367_QAM_EQU_TESTAP_CFG ,0x00 }, + {R367_QAM_EQU_Q_TESTTAP_L ,0xff }, + {R367_QAM_EQU_Q_TESTTAP_M ,0x00 }, + {R367_QAM_EQU_Q_TESTTAP_H ,0x00 }, + {R367_QAM_EQU_TAP_CTRL ,0x00 }, + {R367_QAM_EQU_CTR_CRL_CONTROL_L ,0x11 }, + {R367_QAM_EQU_CTR_CRL_CONTROL_H ,0x05 }, + {R367_QAM_EQU_CTR_HIPOW_L ,0x00 }, + {R367_QAM_EQU_CTR_HIPOW_H ,0x00 }, + {R367_QAM_EQU_I_EQU_LO ,0xef }, + {R367_QAM_EQU_I_EQU_HI ,0x00 }, + {R367_QAM_EQU_Q_EQU_LO ,0xee }, + {R367_QAM_EQU_Q_EQU_HI ,0x00 }, + {R367_QAM_EQU_MAPPER ,0xc5 }, + {R367_QAM_EQU_SWEEP_RATE ,0x80 }, + {R367_QAM_EQU_SNR_LO ,0x64 }, + {R367_QAM_EQU_SNR_HI ,0x03 }, + {R367_QAM_EQU_GAMMA_LO ,0x00 }, + {R367_QAM_EQU_GAMMA_HI ,0x00 }, + {R367_QAM_EQU_ERR_GAIN ,0x36 }, + {R367_QAM_EQU_RADIUS ,0xaa }, + {R367_QAM_EQU_FFE_MAINTAP ,0x00 }, + {R367_QAM_EQU_FFE_LEAKAGE ,0x63 }, + {R367_QAM_EQU_FFE_MAINTAP_POS ,0xdf }, + {R367_QAM_EQU_GAIN_WIDE ,0x88 }, + {R367_QAM_EQU_GAIN_NARROW ,0x41 }, + {R367_QAM_EQU_CTR_LPF_GAIN ,0xd1 }, + {R367_QAM_EQU_CRL_LPF_GAIN ,0xa7 }, + {R367_QAM_EQU_GLOBAL_GAIN ,0x06 }, + {R367_QAM_EQU_CRL_LD_SEN ,0x85 }, + {R367_QAM_EQU_CRL_LD_VAL ,0xe2 }, + {R367_QAM_EQU_CRL_TFR ,0x20 }, + {R367_QAM_EQU_CRL_BISTH_LO ,0x00 }, + {R367_QAM_EQU_CRL_BISTH_HI ,0x00 }, + {R367_QAM_EQU_SWEEP_RANGE_LO ,0x00 }, + {R367_QAM_EQU_SWEEP_RANGE_HI ,0x00 }, + {R367_QAM_EQU_CRL_LIMITER ,0x40 }, + {R367_QAM_EQU_MODULUS_MAP ,0x90 }, + {R367_QAM_EQU_PNT_GAIN ,0xa7 }, + {R367_QAM_FEC_AC_CTR_0 ,0x16 }, + {R367_QAM_FEC_AC_CTR_1 ,0x0b }, + {R367_QAM_FEC_AC_CTR_2 ,0x88 }, + {R367_QAM_FEC_AC_CTR_3 ,0x02 }, + {R367_QAM_FEC_STATUS ,0x12 }, + {R367_QAM_RS_COUNTER_0 ,0x7d }, + {R367_QAM_RS_COUNTER_1 ,0xd0 }, + {R367_QAM_RS_COUNTER_2 ,0x19 }, + {R367_QAM_RS_COUNTER_3 ,0x0b }, + {R367_QAM_RS_COUNTER_4 ,0xa3 }, + {R367_QAM_RS_COUNTER_5 ,0x00 }, + {R367_QAM_BERT_0 ,0x01 }, + {R367_QAM_BERT_1 ,0x25 }, + {R367_QAM_BERT_2 ,0x41 }, + {R367_QAM_BERT_3 ,0x39 }, + {R367_QAM_OUTFORMAT_0 ,0xc2 }, + {R367_QAM_OUTFORMAT_1 ,0x22 }, + {R367_QAM_SMOOTHER_2 ,0x28 }, + {R367_QAM_TSMF_CTRL_0 ,0x01 }, + {R367_QAM_TSMF_CTRL_1 ,0xc6 }, + {R367_QAM_TSMF_CTRL_3 ,0x43 }, + {R367_QAM_TS_ON_ID_0 ,0x00 }, + {R367_QAM_TS_ON_ID_1 ,0x00 }, + {R367_QAM_TS_ON_ID_2 ,0x00 }, + {R367_QAM_TS_ON_ID_3 ,0x00 }, + {R367_QAM_RE_STATUS_0 ,0x00 }, + {R367_QAM_RE_STATUS_1 ,0x00 }, + {R367_QAM_RE_STATUS_2 ,0x00 }, + {R367_QAM_RE_STATUS_3 ,0x00 }, + {R367_QAM_TS_STATUS_0 ,0x00 }, + {R367_QAM_TS_STATUS_1 ,0x00 }, + {R367_QAM_TS_STATUS_2 ,0xa0 }, + {R367_QAM_TS_STATUS_3 ,0x00 }, + {R367_QAM_T_O_ID_0 ,0x00 }, + {R367_QAM_T_O_ID_1 ,0x00 }, + {R367_QAM_T_O_ID_2 ,0x00 }, + {R367_QAM_T_O_ID_3 ,0x00 }, + {0x0000 ,0x00 }// EOT +}; + +struct init_table ofdm_init[] = { +//{R367_OFDM_ID ,0x60}, +//{R367_OFDM_I2CRPT ,0x22}, +//{R367_OFDM_TOPCTRL ,0x02}, +//{R367_OFDM_IOCFG0 ,0x40}, +//{R367_OFDM_DAC0R ,0x00}, +//{R367_OFDM_IOCFG1 ,0x00}, +//{R367_OFDM_DAC1R ,0x00}, +//{R367_OFDM_IOCFG2 ,0x62}, +//{R367_OFDM_SDFR ,0x00}, +//{R367_OFDM_STATUS ,0xf8}, +//{R367_OFDM_AUX_CLK ,0x0a}, +//{R367_OFDM_FREESYS1 ,0x00}, +//{R367_OFDM_FREESYS2 ,0x00}, +//{R367_OFDM_FREESYS3 ,0x00}, +//{R367_OFDM_GPIO_CFG ,0x55}, +//{R367_OFDM_GPIO_CMD ,0x00}, + {R367_OFDM_AGC2MAX ,0xff }, + {R367_OFDM_AGC2MIN ,0x00 }, + {R367_OFDM_AGC1MAX ,0xff }, + {R367_OFDM_AGC1MIN ,0x00 }, + {R367_OFDM_AGCR ,0xbc }, + {R367_OFDM_AGC2TH ,0x00 }, +//{R367_OFDM_AGC12C ,0x01}, //Note: This defines AGC pins, also needed for QAM + {R367_OFDM_AGCCTRL1 ,0x85 }, + {R367_OFDM_AGCCTRL2 ,0x1f }, + {R367_OFDM_AGC1VAL1 ,0x00 }, + {R367_OFDM_AGC1VAL2 ,0x00 }, + {R367_OFDM_AGC2VAL1 ,0x6f }, + {R367_OFDM_AGC2VAL2 ,0x05 }, + {R367_OFDM_AGC2PGA ,0x00 }, + {R367_OFDM_OVF_RATE1 ,0x00 }, + {R367_OFDM_OVF_RATE2 ,0x00 }, + {R367_OFDM_GAIN_SRC1 ,0x2b }, + {R367_OFDM_GAIN_SRC2 ,0x04 }, + {R367_OFDM_INC_DEROT1 ,0x55 }, + {R367_OFDM_INC_DEROT2 ,0x55 }, + {R367_OFDM_PPM_CPAMP_DIR ,0x2c }, + {R367_OFDM_PPM_CPAMP_INV ,0x00 }, + {R367_OFDM_FREESTFE_1 ,0x00 }, + {R367_OFDM_FREESTFE_2 ,0x1c }, + {R367_OFDM_DCOFFSET ,0x00 }, + {R367_OFDM_EN_PROCESS ,0x05 }, + {R367_OFDM_SDI_SMOOTHER ,0x80 }, + {R367_OFDM_FE_LOOP_OPEN ,0x1c }, + {R367_OFDM_FREQOFF1 ,0x00 }, + {R367_OFDM_FREQOFF2 ,0x00 }, + {R367_OFDM_FREQOFF3 ,0x00 }, + {R367_OFDM_TIMOFF1 ,0x00 }, + {R367_OFDM_TIMOFF2 ,0x00 }, + {R367_OFDM_EPQ ,0x02 }, + {R367_OFDM_EPQAUTO ,0x01 }, + {R367_OFDM_SYR_UPDATE ,0xf5 }, + {R367_OFDM_CHPFREE ,0x00 }, + {R367_OFDM_PPM_STATE_MAC ,0x23 }, + {R367_OFDM_INR_THRESHOLD ,0xff }, + {R367_OFDM_EPQ_TPS_ID_CELL ,0xf9 }, + {R367_OFDM_EPQ_CFG ,0x00 }, + {R367_OFDM_EPQ_STATUS ,0x01 }, + {R367_OFDM_AUTORELOCK ,0x81 }, + {R367_OFDM_BER_THR_VMSB ,0x00 }, + {R367_OFDM_BER_THR_MSB ,0x00 }, + {R367_OFDM_BER_THR_LSB ,0x00 }, + {R367_OFDM_CCD ,0x83 }, + {R367_OFDM_SPECTR_CFG ,0x00 }, + {R367_OFDM_CHC_DUMMY ,0x18 }, + {R367_OFDM_INC_CTL ,0x88 }, + {R367_OFDM_INCTHRES_COR1 ,0xb4 }, + {R367_OFDM_INCTHRES_COR2 ,0x96 }, + {R367_OFDM_INCTHRES_DET1 ,0x0e }, + {R367_OFDM_INCTHRES_DET2 ,0x11 }, + {R367_OFDM_IIR_CELLNB ,0x8d }, + {R367_OFDM_IIRCX_COEFF1_MSB ,0x00 }, + {R367_OFDM_IIRCX_COEFF1_LSB ,0x00 }, + {R367_OFDM_IIRCX_COEFF2_MSB ,0x09 }, + {R367_OFDM_IIRCX_COEFF2_LSB ,0x18 }, + {R367_OFDM_IIRCX_COEFF3_MSB ,0x14 }, + {R367_OFDM_IIRCX_COEFF3_LSB ,0x9c }, + {R367_OFDM_IIRCX_COEFF4_MSB ,0x00 }, + {R367_OFDM_IIRCX_COEFF4_LSB ,0x00 }, + {R367_OFDM_IIRCX_COEFF5_MSB ,0x36 }, + {R367_OFDM_IIRCX_COEFF5_LSB ,0x42 }, + {R367_OFDM_FEPATH_CFG ,0x00 }, + {R367_OFDM_PMC1_FUNC ,0x65 }, + {R367_OFDM_PMC1_FOR ,0x00 }, + {R367_OFDM_PMC2_FUNC ,0x00 }, + {R367_OFDM_STATUS_ERR_DA ,0xe0 }, + {R367_OFDM_DIG_AGC_R ,0xfe }, + {R367_OFDM_COMAGC_TARMSB ,0x0b }, + {R367_OFDM_COM_AGC_TAR_ENMODE ,0x41 }, + {R367_OFDM_COM_AGC_CFG ,0x3e }, + {R367_OFDM_COM_AGC_GAIN1 ,0x39 }, + {R367_OFDM_AUT_AGC_TARGETMSB ,0x0b }, + {R367_OFDM_LOCK_DET_MSB ,0x01 }, + {R367_OFDM_AGCTAR_LOCK_LSBS ,0x40 }, + {R367_OFDM_AUT_GAIN_EN ,0xf4 }, + {R367_OFDM_AUT_CFG ,0xf0 }, + {R367_OFDM_LOCKN ,0x23 }, + {R367_OFDM_INT_X_3 ,0x00 }, + {R367_OFDM_INT_X_2 ,0x03 }, + {R367_OFDM_INT_X_1 ,0x8d }, + {R367_OFDM_INT_X_0 ,0xa0 }, + {R367_OFDM_MIN_ERRX_MSB ,0x00 }, + {R367_OFDM_COR_CTL ,0x00 }, + {R367_OFDM_COR_STAT ,0xf6 }, + {R367_OFDM_COR_INTEN ,0x00 }, + {R367_OFDM_COR_INTSTAT ,0x3f }, + {R367_OFDM_COR_MODEGUARD ,0x03 }, + {R367_OFDM_AGC_CTL ,0x08 }, + {R367_OFDM_AGC_MANUAL1 ,0x00 }, + {R367_OFDM_AGC_MANUAL2 ,0x00 }, + {R367_OFDM_AGC_TARG ,0x16 }, + {R367_OFDM_AGC_GAIN1 ,0x53 }, + {R367_OFDM_AGC_GAIN2 ,0x1d }, + {R367_OFDM_RESERVED_1 ,0x00 }, + {R367_OFDM_RESERVED_2 ,0x00 }, + {R367_OFDM_RESERVED_3 ,0x00 }, + {R367_OFDM_CAS_CTL ,0x44 }, + {R367_OFDM_CAS_FREQ ,0xb3 }, + {R367_OFDM_CAS_DAGCGAIN ,0x12 }, + {R367_OFDM_SYR_CTL ,0x04 }, + {R367_OFDM_SYR_STAT ,0x10 }, + {R367_OFDM_SYR_NCO1 ,0x00 }, + {R367_OFDM_SYR_NCO2 ,0x00 }, + {R367_OFDM_SYR_OFFSET1 ,0x00 }, + {R367_OFDM_SYR_OFFSET2 ,0x00 }, + {R367_OFDM_FFT_CTL ,0x00 }, + {R367_OFDM_SCR_CTL ,0x70 }, + {R367_OFDM_PPM_CTL1 ,0xf8 }, + {R367_OFDM_TRL_CTL ,0xac }, + {R367_OFDM_TRL_NOMRATE1 ,0x1e }, + {R367_OFDM_TRL_NOMRATE2 ,0x58 }, + {R367_OFDM_TRL_TIME1 ,0x1d }, + {R367_OFDM_TRL_TIME2 ,0xfc }, + {R367_OFDM_CRL_CTL ,0x24 }, + {R367_OFDM_CRL_FREQ1 ,0xad }, + {R367_OFDM_CRL_FREQ2 ,0x9d }, + {R367_OFDM_CRL_FREQ3 ,0xff }, + {R367_OFDM_CHC_CTL ,0x01 }, + {R367_OFDM_CHC_SNR ,0xf0 }, + {R367_OFDM_BDI_CTL ,0x00 }, + {R367_OFDM_DMP_CTL ,0x00 }, + {R367_OFDM_TPS_RCVD1 ,0x30 }, + {R367_OFDM_TPS_RCVD2 ,0x02 }, + {R367_OFDM_TPS_RCVD3 ,0x01 }, + {R367_OFDM_TPS_RCVD4 ,0x00 }, + {R367_OFDM_TPS_ID_CELL1 ,0x00 }, + {R367_OFDM_TPS_ID_CELL2 ,0x00 }, + {R367_OFDM_TPS_RCVD5_SET1 ,0x02 }, + {R367_OFDM_TPS_SET2 ,0x02 }, + {R367_OFDM_TPS_SET3 ,0x01 }, + {R367_OFDM_TPS_CTL ,0x00 }, + {R367_OFDM_CTL_FFTOSNUM ,0x34 }, + {R367_OFDM_TESTSELECT ,0x09 }, + {R367_OFDM_MSC_REV ,0x0a }, + {R367_OFDM_PIR_CTL ,0x00 }, + {R367_OFDM_SNR_CARRIER1 ,0xa1 }, + {R367_OFDM_SNR_CARRIER2 ,0x9a }, + {R367_OFDM_PPM_CPAMP ,0x2c }, + {R367_OFDM_TSM_AP0 ,0x00 }, + {R367_OFDM_TSM_AP1 ,0x00 }, + {R367_OFDM_TSM_AP2 ,0x00 }, + {R367_OFDM_TSM_AP3 ,0x00 }, + {R367_OFDM_TSM_AP4 ,0x00 }, + {R367_OFDM_TSM_AP5 ,0x00 }, + {R367_OFDM_TSM_AP6 ,0x00 }, + {R367_OFDM_TSM_AP7 ,0x00 }, +//{R367_OFDM_TSTRES ,0x00}, +//{R367_OFDM_ANACTRL ,0x0D},/*caution PLL stopped, to be restarted at init!!!*/ +//{R367_OFDM_TSTBUS ,0x00}, +//{R367_OFDM_TSTRATE ,0x00}, + {R367_OFDM_CONSTMODE ,0x01 }, + {R367_OFDM_CONSTCARR1 ,0x00 }, + {R367_OFDM_CONSTCARR2 ,0x00 }, + {R367_OFDM_ICONSTEL ,0x0a }, + {R367_OFDM_QCONSTEL ,0x15 }, + {R367_OFDM_TSTBISTRES0 ,0x00 }, + {R367_OFDM_TSTBISTRES1 ,0x00 }, + {R367_OFDM_TSTBISTRES2 ,0x28 }, + {R367_OFDM_TSTBISTRES3 ,0x00 }, +//{R367_OFDM_RF_AGC1 ,0xff}, +//{R367_OFDM_RF_AGC2 ,0x83}, +//{R367_OFDM_ANADIGCTRL ,0x19}, +//{R367_OFDM_PLLMDIV ,0x0c}, +//{R367_OFDM_PLLNDIV ,0x55}, +//{R367_OFDM_PLLSETUP ,0x18}, +//{R367_OFDM_DUAL_AD12 ,0x00}, +//{R367_OFDM_TSTBIST ,0x00}, +//{R367_OFDM_PAD_COMP_CTRL ,0x00}, +//{R367_OFDM_PAD_COMP_WR ,0x00}, +//{R367_OFDM_PAD_COMP_RD ,0xe0}, + {R367_OFDM_SYR_TARGET_FFTADJT_MSB ,0x00 }, + {R367_OFDM_SYR_TARGET_FFTADJT_LSB ,0x00 }, + {R367_OFDM_SYR_TARGET_CHCADJT_MSB ,0x00 }, + {R367_OFDM_SYR_TARGET_CHCADJT_LSB ,0x00 }, + {R367_OFDM_SYR_FLAG ,0x00 }, + {R367_OFDM_CRL_TARGET1 ,0x00 }, + {R367_OFDM_CRL_TARGET2 ,0x00 }, + {R367_OFDM_CRL_TARGET3 ,0x00 }, + {R367_OFDM_CRL_TARGET4 ,0x00 }, + {R367_OFDM_CRL_FLAG ,0x00 }, + {R367_OFDM_TRL_TARGET1 ,0x00 }, + {R367_OFDM_TRL_TARGET2 ,0x00 }, + {R367_OFDM_TRL_CHC ,0x00 }, + {R367_OFDM_CHC_SNR_TARG ,0x00 }, + {R367_OFDM_TOP_TRACK ,0x00 }, + {R367_OFDM_TRACKER_FREE1 ,0x00 }, + {R367_OFDM_ERROR_CRL1 ,0x00 }, + {R367_OFDM_ERROR_CRL2 ,0x00 }, + {R367_OFDM_ERROR_CRL3 ,0x00 }, + {R367_OFDM_ERROR_CRL4 ,0x00 }, + {R367_OFDM_DEC_NCO1 ,0x2c }, + {R367_OFDM_DEC_NCO2 ,0x0f }, + {R367_OFDM_DEC_NCO3 ,0x20 }, + {R367_OFDM_SNR ,0xf1 }, + {R367_OFDM_SYR_FFTADJ1 ,0x00 }, + {R367_OFDM_SYR_FFTADJ2 ,0x00 }, + {R367_OFDM_SYR_CHCADJ1 ,0x00 }, + {R367_OFDM_SYR_CHCADJ2 ,0x00 }, + {R367_OFDM_SYR_OFF ,0x00 }, + {R367_OFDM_PPM_OFFSET1 ,0x00 }, + {R367_OFDM_PPM_OFFSET2 ,0x03 }, + {R367_OFDM_TRACKER_FREE2 ,0x00 }, + {R367_OFDM_DEBG_LT10 ,0x00 }, + {R367_OFDM_DEBG_LT11 ,0x00 }, + {R367_OFDM_DEBG_LT12 ,0x00 }, + {R367_OFDM_DEBG_LT13 ,0x00 }, + {R367_OFDM_DEBG_LT14 ,0x00 }, + {R367_OFDM_DEBG_LT15 ,0x00 }, + {R367_OFDM_DEBG_LT16 ,0x00 }, + {R367_OFDM_DEBG_LT17 ,0x00 }, + {R367_OFDM_DEBG_LT18 ,0x00 }, + {R367_OFDM_DEBG_LT19 ,0x00 }, + {R367_OFDM_DEBG_LT1A ,0x00 }, + {R367_OFDM_DEBG_LT1B ,0x00 }, + {R367_OFDM_DEBG_LT1C ,0x00 }, + {R367_OFDM_DEBG_LT1D ,0x00 }, + {R367_OFDM_DEBG_LT1E ,0x00 }, + {R367_OFDM_DEBG_LT1F ,0x00 }, + {R367_OFDM_RCCFGH ,0x00 }, + {R367_OFDM_RCCFGM ,0x00 }, + {R367_OFDM_RCCFGL ,0x00 }, + {R367_OFDM_RCINSDELH ,0x00 }, + {R367_OFDM_RCINSDELM ,0x00 }, + {R367_OFDM_RCINSDELL ,0x00 }, + {R367_OFDM_RCSTATUS ,0x00 }, + {R367_OFDM_RCSPEED ,0x6f }, + {R367_OFDM_RCDEBUGM ,0xe7 }, + {R367_OFDM_RCDEBUGL ,0x9b }, + {R367_OFDM_RCOBSCFG ,0x00 }, + {R367_OFDM_RCOBSM ,0x00 }, + {R367_OFDM_RCOBSL ,0x00 }, + {R367_OFDM_RCFECSPY ,0x00 }, + {R367_OFDM_RCFSPYCFG ,0x00 }, + {R367_OFDM_RCFSPYDATA ,0x00 }, + {R367_OFDM_RCFSPYOUT ,0x00 }, + {R367_OFDM_RCFSTATUS ,0x00 }, + {R367_OFDM_RCFGOODPACK ,0x00 }, + {R367_OFDM_RCFPACKCNT ,0x00 }, + {R367_OFDM_RCFSPYMISC ,0x00 }, + {R367_OFDM_RCFBERCPT4 ,0x00 }, + {R367_OFDM_RCFBERCPT3 ,0x00 }, + {R367_OFDM_RCFBERCPT2 ,0x00 }, + {R367_OFDM_RCFBERCPT1 ,0x00 }, + {R367_OFDM_RCFBERCPT0 ,0x00 }, + {R367_OFDM_RCFBERERR2 ,0x00 }, + {R367_OFDM_RCFBERERR1 ,0x00 }, + {R367_OFDM_RCFBERERR0 ,0x00 }, + {R367_OFDM_RCFSTATESM ,0x00 }, + {R367_OFDM_RCFSTATESL ,0x00 }, + {R367_OFDM_RCFSPYBER ,0x00 }, + {R367_OFDM_RCFSPYDISTM ,0x00 }, + {R367_OFDM_RCFSPYDISTL ,0x00 }, + {R367_OFDM_RCFSPYOBS7 ,0x00 }, + {R367_OFDM_RCFSPYOBS6 ,0x00 }, + {R367_OFDM_RCFSPYOBS5 ,0x00 }, + {R367_OFDM_RCFSPYOBS4 ,0x00 }, + {R367_OFDM_RCFSPYOBS3 ,0x00 }, + {R367_OFDM_RCFSPYOBS2 ,0x00 }, + {R367_OFDM_RCFSPYOBS1 ,0x00 }, + {R367_OFDM_RCFSPYOBS0 ,0x00 }, +//{R367_OFDM_TSGENERAL ,0x00}, +//{R367_OFDM_RC1SPEED ,0x6f}, +//{R367_OFDM_TSGSTATUS ,0x18}, + {R367_OFDM_FECM ,0x01 }, + {R367_OFDM_VTH12 ,0xff }, + {R367_OFDM_VTH23 ,0xa1 }, + {R367_OFDM_VTH34 ,0x64 }, + {R367_OFDM_VTH56 ,0x40 }, + {R367_OFDM_VTH67 ,0x00 }, + {R367_OFDM_VTH78 ,0x2c }, + {R367_OFDM_VITCURPUN ,0x12 }, + {R367_OFDM_VERROR ,0x01 }, + {R367_OFDM_PRVIT ,0x3f }, + {R367_OFDM_VAVSRVIT ,0x00 }, + {R367_OFDM_VSTATUSVIT ,0xbd }, + {R367_OFDM_VTHINUSE ,0xa1 }, + {R367_OFDM_KDIV12 ,0x20 }, + {R367_OFDM_KDIV23 ,0x40 }, + {R367_OFDM_KDIV34 ,0x20 }, + {R367_OFDM_KDIV56 ,0x30 }, + {R367_OFDM_KDIV67 ,0x00 }, + {R367_OFDM_KDIV78 ,0x30 }, + {R367_OFDM_SIGPOWER ,0x54 }, + {R367_OFDM_DEMAPVIT ,0x40 }, + {R367_OFDM_VITSCALE ,0x00 }, + {R367_OFDM_FFEC1PRG ,0x00 }, + {R367_OFDM_FVITCURPUN ,0x12 }, + {R367_OFDM_FVERROR ,0x01 }, + {R367_OFDM_FVSTATUSVIT ,0xbd }, + {R367_OFDM_DEBUG_LT1 ,0x00 }, + {R367_OFDM_DEBUG_LT2 ,0x00 }, + {R367_OFDM_DEBUG_LT3 ,0x00 }, + {R367_OFDM_TSTSFMET ,0x00 }, + {R367_OFDM_SELOUT ,0x00 }, + {R367_OFDM_TSYNC ,0x00 }, + {R367_OFDM_TSTERR ,0x00 }, + {R367_OFDM_TSFSYNC ,0x00 }, + {R367_OFDM_TSTSFERR ,0x00 }, + {R367_OFDM_TSTTSSF1 ,0x01 }, + {R367_OFDM_TSTTSSF2 ,0x1f }, + {R367_OFDM_TSTTSSF3 ,0x00 }, + {R367_OFDM_TSTTS1 ,0x00 }, + {R367_OFDM_TSTTS2 ,0x1f }, + {R367_OFDM_TSTTS3 ,0x01 }, + {R367_OFDM_TSTTS4 ,0x00 }, + {R367_OFDM_TSTTSRC ,0x00 }, + {R367_OFDM_TSTTSRS ,0x00 }, + {R367_OFDM_TSSTATEM ,0xb0 }, + {R367_OFDM_TSSTATEL ,0x40 }, + {R367_OFDM_TSCFGH ,0x80 }, + {R367_OFDM_TSCFGM ,0x00 }, + {R367_OFDM_TSCFGL ,0x20 }, + {R367_OFDM_TSSYNC ,0x00 }, + {R367_OFDM_TSINSDELH ,0x00 }, + {R367_OFDM_TSINSDELM ,0x00 }, + {R367_OFDM_TSINSDELL ,0x00 }, + {R367_OFDM_TSDIVN ,0x03 }, + {R367_OFDM_TSDIVPM ,0x00 }, + {R367_OFDM_TSDIVPL ,0x00 }, + {R367_OFDM_TSDIVQM ,0x00 }, + {R367_OFDM_TSDIVQL ,0x00 }, + {R367_OFDM_TSDILSTKM ,0x00 }, + {R367_OFDM_TSDILSTKL ,0x00 }, + {R367_OFDM_TSSPEED ,0x6f }, + {R367_OFDM_TSSTATUS ,0x81 }, + {R367_OFDM_TSSTATUS2 ,0x6a }, + {R367_OFDM_TSBITRATEM ,0x0f }, + {R367_OFDM_TSBITRATEL ,0xc6 }, + {R367_OFDM_TSPACKLENM ,0x00 }, + {R367_OFDM_TSPACKLENL ,0xfc }, + {R367_OFDM_TSBLOCLENM ,0x0a }, + {R367_OFDM_TSBLOCLENL ,0x80 }, + {R367_OFDM_TSDLYH ,0x90 }, + {R367_OFDM_TSDLYM ,0x68 }, + {R367_OFDM_TSDLYL ,0x01 }, + {R367_OFDM_TSNPDAV ,0x00 }, + {R367_OFDM_TSBUFSTATH ,0x00 }, + {R367_OFDM_TSBUFSTATM ,0x00 }, + {R367_OFDM_TSBUFSTATL ,0x00 }, + {R367_OFDM_TSDEBUGM ,0xcf }, + {R367_OFDM_TSDEBUGL ,0x1e }, + {R367_OFDM_TSDLYSETH ,0x00 }, + {R367_OFDM_TSDLYSETM ,0x68 }, + {R367_OFDM_TSDLYSETL ,0x00 }, + {R367_OFDM_TSOBSCFG ,0x00 }, + {R367_OFDM_TSOBSM ,0x47 }, + {R367_OFDM_TSOBSL ,0x1f }, + {R367_OFDM_ERRCTRL1 ,0x95 }, + {R367_OFDM_ERRCNT1H ,0x80 }, + {R367_OFDM_ERRCNT1M ,0x00 }, + {R367_OFDM_ERRCNT1L ,0x00 }, + {R367_OFDM_ERRCTRL2 ,0x95 }, + {R367_OFDM_ERRCNT2H ,0x00 }, + {R367_OFDM_ERRCNT2M ,0x00 }, + {R367_OFDM_ERRCNT2L ,0x00 }, + {R367_OFDM_FECSPY ,0x88 }, + {R367_OFDM_FSPYCFG ,0x2c }, + {R367_OFDM_FSPYDATA ,0x3a }, + {R367_OFDM_FSPYOUT ,0x06 }, + {R367_OFDM_FSTATUS ,0x61 }, + {R367_OFDM_FGOODPACK ,0xff }, + {R367_OFDM_FPACKCNT ,0xff }, + {R367_OFDM_FSPYMISC ,0x66 }, + {R367_OFDM_FBERCPT4 ,0x00 }, + {R367_OFDM_FBERCPT3 ,0x00 }, + {R367_OFDM_FBERCPT2 ,0x36 }, + {R367_OFDM_FBERCPT1 ,0x36 }, + {R367_OFDM_FBERCPT0 ,0x14 }, + {R367_OFDM_FBERERR2 ,0x00 }, + {R367_OFDM_FBERERR1 ,0x03 }, + {R367_OFDM_FBERERR0 ,0x28 }, + {R367_OFDM_FSTATESM ,0x00 }, + {R367_OFDM_FSTATESL ,0x02 }, + {R367_OFDM_FSPYBER ,0x00 }, + {R367_OFDM_FSPYDISTM ,0x01 }, + {R367_OFDM_FSPYDISTL ,0x9f }, + {R367_OFDM_FSPYOBS7 ,0xc9 }, + {R367_OFDM_FSPYOBS6 ,0x99 }, + {R367_OFDM_FSPYOBS5 ,0x08 }, + {R367_OFDM_FSPYOBS4 ,0xec }, + {R367_OFDM_FSPYOBS3 ,0x01 }, + {R367_OFDM_FSPYOBS2 ,0x0f }, + {R367_OFDM_FSPYOBS1 ,0xf5 }, + {R367_OFDM_FSPYOBS0 ,0x08 }, + {R367_OFDM_SFDEMAP ,0x40 }, + {R367_OFDM_SFERROR ,0x00 }, + {R367_OFDM_SFAVSR ,0x30 }, + {R367_OFDM_SFECSTATUS ,0xcc }, + {R367_OFDM_SFKDIV12 ,0x20 }, + {R367_OFDM_SFKDIV23 ,0x40 }, + {R367_OFDM_SFKDIV34 ,0x20 }, + {R367_OFDM_SFKDIV56 ,0x20 }, + {R367_OFDM_SFKDIV67 ,0x00 }, + {R367_OFDM_SFKDIV78 ,0x20 }, + {R367_OFDM_SFDILSTKM ,0x00 }, + {R367_OFDM_SFDILSTKL ,0x00 }, + {R367_OFDM_SFSTATUS ,0xb5 }, + {R367_OFDM_SFDLYH ,0x90 }, + {R367_OFDM_SFDLYM ,0x60 }, + {R367_OFDM_SFDLYL ,0x01 }, + {R367_OFDM_SFDLYSETH ,0xc0 }, + {R367_OFDM_SFDLYSETM ,0x60 }, + {R367_OFDM_SFDLYSETL ,0x00 }, + {R367_OFDM_SFOBSCFG ,0x00 }, + {R367_OFDM_SFOBSM ,0x47 }, + {R367_OFDM_SFOBSL ,0x05 }, + {R367_OFDM_SFECINFO ,0x40 }, + {R367_OFDM_SFERRCTRL ,0x74 }, + {R367_OFDM_SFERRCNTH ,0x80 }, + {R367_OFDM_SFERRCNTM ,0x00 }, + {R367_OFDM_SFERRCNTL ,0x00 }, + {R367_OFDM_SYMBRATEM ,0x2f }, + {R367_OFDM_SYMBRATEL ,0x50 }, + {R367_OFDM_SYMBSTATUS ,0x7f }, + {R367_OFDM_SYMBCFG ,0x00 }, + {R367_OFDM_SYMBFIFOM ,0xf4 }, + {R367_OFDM_SYMBFIFOL ,0x0d }, + {R367_OFDM_SYMBOFFSM ,0xf0 }, + {R367_OFDM_SYMBOFFSL ,0x2d }, +//{R367_OFDM_DEBUG_LT4 ,0x00}, +//{R367_OFDM_DEBUG_LT5 ,0x00}, +//{R367_OFDM_DEBUG_LT6 ,0x00}, +//{R367_OFDM_DEBUG_LT7 ,0x00}, +//{R367_OFDM_DEBUG_LT8 ,0x00}, +//{R367_OFDM_DEBUG_LT9 ,0x00}, + {0x0000 ,0x00 }// EOT +}; + +static inline u32 MulDiv32 (u32 a,u32 b,u32 c) +{ +u64 tmp64; + + tmp64 = (u64 )a * (u64 )b; +do_div (tmp64, c); + +return (u32 ) tmp64; +} + +static int i2c_write (struct i2c_adapter *adap,u8 adr,u8 *data,int len) +{ +struct i2c_msg msg = + {.addr = adr, .flags =0 , .buf = data, .len = len}; + +if (i2c_transfer (adap, &msg,1 ) !=1 ) { +printk ("stv0367: i2c_write error\n" ); +return -1 ; + } +return 0 ; +} + +#if 0 +static int i2c_read (struct i2c_adapter *adap, +u8 adr,u8 *msg,int len,u8 *answ,int alen) +{ +struct i2c_msg msgs[2 ] = { { .addr = adr, .flags =0 , + .buf = msg, .len = len}, + { .addr = adr, .flags =I2C_M_RD , + .buf = answ, .len = alen } }; +if (i2c_transfer (adap, msgs,2 ) !=2 ) { +printk ("stv0367: i2c_read error\n" ); +return -1 ; + } +return 0 ; +} +#endif + +static int writereg (struct stv_state *state,u16 reg,u8 dat) +{ +u8 mm[3 ] = { (reg >>8 ), reg &0xff , dat }; + +return i2c_write (state->i2c, state->adr, mm,3 ); +} + +static int readreg (struct stv_state *state,u16 reg,u8 *val) +{ +u8 msg[2 ] = {reg >>8 , reg &0xff }; +struct i2c_msg msgs[2 ] = {{.addr = state->adr, .flags =0 , + .buf = msg, .len =2 }, + {.addr = state->adr, .flags =I2C_M_RD , + .buf = val, .len =1 }}; +return (i2c_transfer (state->i2c, msgs,2 ) ==2 ) ?0 :-1 ; +} + +static int readregs (struct stv_state *state,u16 reg,u8 *val,int count) +{ +u8 msg[2 ] = {reg >>8 , reg &0xff }; +struct i2c_msg msgs[2 ] = {{.addr = state->adr, .flags =0 , + .buf = msg, .len =2 }, + {.addr = state->adr, .flags =I2C_M_RD , + .buf = val, .len = count}}; +return (i2c_transfer (state->i2c, msgs,2 ) ==2 ) ?0 :-1 ; +} + +static int write_init_table (struct stv_state *state,struct init_table *tab) +{ +while (1 ) { +if (!tab->adr) +break ; +if (writereg (state, tab->adr, tab->data) <0 ) +return -1 ; + tab++; + } +return 0 ; +} + +static int qam_set_modulation (struct stv_state *state) +{ +int stat =0 ; + +switch (state->modulation) { +case QAM_16 : +writereg (state,R367_QAM_EQU_MAPPER ,state->qam_inversion |QAM_MOD_QAM16 ); +writereg (state,R367_QAM_AGC_PWR_REF_L ,0x64 );/* Set analog AGC reference */ +writereg (state,R367_QAM_IQDEM_ADJ_AGC_REF ,0x00 );/* Set digital AGC reference */ +writereg (state,R367_QAM_FSM_STATE ,0x90 ); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xc1 ); +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa7 ); +writereg (state,R367_QAM_EQU_CRL_LD_SEN ,0x95 ); +writereg (state,R367_QAM_EQU_CRL_LIMITER ,0x40 ); +writereg (state,R367_QAM_EQU_PNT_GAIN ,0x8a ); +break ; +case QAM_32 : +writereg (state,R367_QAM_EQU_MAPPER ,state->qam_inversion |QAM_MOD_QAM32 ); +writereg (state,R367_QAM_AGC_PWR_REF_L ,0x6e );/* Set analog AGC reference */ +writereg (state,R367_QAM_IQDEM_ADJ_AGC_REF ,0x00 );/* Set digital AGC reference */ +writereg (state,R367_QAM_FSM_STATE ,0xb0 ); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xc1 ); +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xb7 ); +writereg (state,R367_QAM_EQU_CRL_LD_SEN ,0x9d ); +writereg (state,R367_QAM_EQU_CRL_LIMITER ,0x7f ); +writereg (state,R367_QAM_EQU_PNT_GAIN ,0xa7 ); +break ; +case QAM_64 : +writereg (state,R367_QAM_EQU_MAPPER ,state->qam_inversion |QAM_MOD_QAM64 ); +writereg (state,R367_QAM_AGC_PWR_REF_L ,0x5a );/* Set analog AGC reference */ +writereg (state,R367_QAM_IQDEM_ADJ_AGC_REF ,0x82 );/* Set digital AGC reference */ +if (state->symbol_rate>4500000 ) + { +writereg (state,R367_QAM_FSM_STATE ,0xb0 ); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xc1 ); +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa5 ); + } +else if (state->symbol_rate>2500000 )// 25000000 + { +writereg (state,R367_QAM_FSM_STATE ,0xa0 ); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xc1 ); +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa6 ); + } +else + { +writereg (state,R367_QAM_FSM_STATE ,0xa0 ); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xd1 ); +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa7 ); + } +writereg (state,R367_QAM_EQU_CRL_LD_SEN ,0x95 ); +writereg (state,R367_QAM_EQU_CRL_LIMITER ,0x40 ); +writereg (state,R367_QAM_EQU_PNT_GAIN ,0x99 ); +break ; +case QAM_128 : +writereg (state,R367_QAM_EQU_MAPPER ,state->qam_inversion |QAM_MOD_QAM128 ); +writereg (state,R367_QAM_AGC_PWR_REF_L ,0x76 );/* Set analog AGC reference */ +writereg (state,R367_QAM_IQDEM_ADJ_AGC_REF ,0x00 );/* Set digital AGC reference */ +writereg (state,R367_QAM_FSM_STATE ,0x90 ); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xb1 ); +if (state->symbol_rate>4500000 )// 45000000 + { +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa7 ); + } +else if (state->symbol_rate>2500000 )// 25000000 + { +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa6 ); + } +else + { +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0x97 ); + } +writereg (state,R367_QAM_EQU_CRL_LD_SEN ,0x8e ); +writereg (state,R367_QAM_EQU_CRL_LIMITER ,0x7f ); +writereg (state,R367_QAM_EQU_PNT_GAIN ,0xa7 ); +break ; +case QAM_256 : +writereg (state,R367_QAM_EQU_MAPPER ,state->qam_inversion |QAM_MOD_QAM256 ); +writereg (state,R367_QAM_AGC_PWR_REF_L ,0x5a );/* Set analog AGC reference */ +writereg (state,R367_QAM_IQDEM_ADJ_AGC_REF ,0x94 );/* Set digital AGC reference */ +writereg (state,R367_QAM_FSM_STATE ,0xa0 ); +if (state->symbol_rate>4500000 )// 45000000 + { +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xc1 ); + } +else if (state->symbol_rate>2500000 )// 25000000 + { +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xc1 ); + } +else + { +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,0xd1 ); + } +writereg (state,R367_QAM_EQU_CRL_LPF_GAIN ,0xa7 ); +writereg (state,R367_QAM_EQU_CRL_LD_SEN ,0x85 ); +writereg (state,R367_QAM_EQU_CRL_LIMITER ,0x40 ); +writereg (state,R367_QAM_EQU_PNT_GAIN ,0xa7 ); +break ; +default : + stat = -EINVAL ; +break ; + } +return stat; +} + + +static int QAM_SetSymbolRate (struct stv_state *state) +{ +int status =0 ; +u32 sr = state->symbol_rate; +u32 Corr =0 ; +u32 Temp, Temp1, AdpClk; + +switch (state->modulation) { +default : +case QAM_16 : Corr =1032 ;break ; +case QAM_32 : Corr =954 ;break ; +case QAM_64 : Corr =983 ;break ; +case QAM_128 : Corr =957 ;break ; +case QAM_256 : Corr =948 ;break ; + } + +// Transfer ration + Temp = (256 *sr) / state->adc_clock; +writereg (state,R367_QAM_EQU_CRL_TFR ,(Temp)); + +/* Symbol rate and SRC gain calculation */ + AdpClk = (state->master_clock) /2000 ;/* TRL works at half the system clock */ + + Temp = state->symbol_rate; + Temp1 = sr; + +if (sr <2097152 )/* 2097152 = 2^21 */ + { + Temp = ((((sr *2048 ) / AdpClk) *16384 ) /125 ) *8 ; + Temp1 = (((((sr *2048 ) /439 ) *256 ) / AdpClk ) * Corr *9 ) /10000000 ; + } +else if (sr <4194304 )/* 4194304 = 2**22 */ + { + Temp = ((((sr *1024 ) / AdpClk) *16384 ) /125 ) *16 ; + Temp1 = (((((sr *1024 ) /439 ) *256 ) / AdpClk ) * Corr *9 ) /5000000 ; + } +else if (sr <8388608 )/* 8388608 = 2**23 */ + { + Temp = ((((sr *512 ) / AdpClk) *16384 ) /125 ) *32 ; + Temp1 = (((((sr *512 ) /439 ) *256 ) / AdpClk ) * Corr *9 ) /2500000 ; + } +else + { + Temp = ((((sr *256 ) / AdpClk) *16384 ) /125 ) *64 ; + Temp1 = (((((sr *256 ) /439 ) *256 ) / AdpClk ) * Corr *9 ) /1250000 ; + } + +///* Filters' coefficients are calculated and written into registers only if the filters are enabled */ +//if (ChipGetField(hChip,F367qam_ADJ_EN)) // Is disabled from init! +//{ +// FE_367qam_SetIirAdjacentcoefficient(hChip, MasterClk_Hz, SymbolRate); +//} +///* AllPass filter is never used on this IC */ +//ChipSetField(hChip,F367qam_ALLPASSFILT_EN,0); // should be disabled from init! + +writereg (state,R367_QAM_SRC_NCO_LL ,(Temp)); +writereg (state,R367_QAM_SRC_NCO_LH ,(Temp>>8 )); +writereg (state,R367_QAM_SRC_NCO_HL ,(Temp>>16 )); +writereg (state,R367_QAM_SRC_NCO_HH ,(Temp>>24 )); + +writereg (state,R367_QAM_IQDEM_GAIN_SRC_L ,(Temp1)); +writereg (state,R367_QAM_IQDEM_GAIN_SRC_H ,(Temp1>>8 )); +return status; +} + + +static int QAM_SetDerotFrequency (struct stv_state *state,u32 DerotFrequency) +{ +int status =0 ; +u32 Sampled_IF; + +do { +//if (DerotFrequency < 1000000) +// DerotFrequency = state->adc_clock/4; /* ZIF operation */ +if (DerotFrequency > state->adc_clock) + DerotFrequency = DerotFrequency - state->adc_clock;// User Alias + + Sampled_IF = ((32768 * (DerotFrequency/1000 )) / (state->adc_clock/1000 )) *256 ; +if (Sampled_IF >8388607 ) + Sampled_IF =8388607 ; + +writereg (state,R367_QAM_MIX_NCO_LL , (Sampled_IF)); +writereg (state,R367_QAM_MIX_NCO_HL , (Sampled_IF>>8 )); +writereg (state,R367_QAM_MIX_NCO_HH , (Sampled_IF>>16 )); + }while (0 ); + +return status; +} + + + +static int QAM_Start (struct stv_state *state,s32 offsetFreq,s32 IntermediateFrequency) +{ +int status =0 ; +u32 AGCTimeOut =25 ; +u32 TRLTimeOut =100000000 / state->symbol_rate; +u32 CRLSymbols =0 ; +u32 EQLTimeOut =100 ; +u32 SearchRange = state->symbol_rate /25 ; +u32 CRLTimeOut; +u8 Temp; + +if ( state->demod_state != QAMSet ) { +writereg (state,R367_DEBUG_LT4 ,0x00 ); +writereg (state,R367_DEBUG_LT5 ,0x01 ); +writereg (state,R367_DEBUG_LT6 ,0x06 );// R367_QAM_CTRL_1 +writereg (state,R367_DEBUG_LT7 ,0x03 );// R367_QAM_CTRL_2 +writereg (state,R367_DEBUG_LT8 ,0x00 ); +writereg (state,R367_DEBUG_LT9 ,0x00 ); + +// Tuner Setup +writereg (state,R367_ANADIGCTRL ,0x8B );/* Buffer Q disabled, I Enabled, signed ADC */ +writereg (state,R367_DUAL_AD12 ,0x04 );/* ADCQ disabled */ + +// Clock setup +writereg (state,R367_ANACTRL ,0x0D );/* PLL bypassed and disabled */ +writereg (state,R367_TOPCTRL ,0x10 );// Set QAM + +writereg (state,R367_PLLMDIV ,27 );/* IC runs at 58 MHz with a 27 MHz crystal */ +writereg (state,R367_PLLNDIV ,232 ); +writereg (state,R367_PLLSETUP ,0x18 );/* ADC clock is equal to system clock */ + +msleep (50 ); +writereg (state,R367_ANACTRL ,0x00 );/* PLL enabled and used */ + + state->master_clock =58000000 ; + state->adc_clock =58000000 ; + + state->demod_state = QAMSet; + } + + state->m_bFirstTimeLock = true; + state->m_DemodLockTime =-1 ; + +qam_set_modulation (state); +QAM_SetSymbolRate (state); + +// Will make problems on low symbol rates ( < 2500000 ) + +switch (state->modulation) { +default : +case QAM_16 : CRLSymbols =150000 ;break ; +case QAM_32 : CRLSymbols =250000 ;break ; +case QAM_64 : CRLSymbols =200000 ;break ; +case QAM_128 : CRLSymbols =250000 ;break ; +case QAM_256 : CRLSymbols =250000 ;break ; + } + + CRLTimeOut = (25 * CRLSymbols * (SearchRange/1000 )) / (state->symbol_rate/1000 ); + CRLTimeOut = (1000 * CRLTimeOut) / state->symbol_rate; +if ( CRLTimeOut <50 ) CRLTimeOut =50 ; + + state->m_FECTimeOut =20 ; + state->m_DemodTimeOut = AGCTimeOut + TRLTimeOut + CRLTimeOut + EQLTimeOut; + state->m_SignalTimeOut = AGCTimeOut + TRLTimeOut; + +// QAM_AGC_ACCUMRSTSEL = 0; +readreg (state,R367_QAM_AGC_CTL ,&state->m_Save_QAM_AGC_CTL); +writereg (state,R367_QAM_AGC_CTL ,state->m_Save_QAM_AGC_CTL & ~0x0F ); + +// QAM_MODULUSMAP_EN = 0 +readreg (state,R367_QAM_EQU_PNT_GAIN ,&Temp); +writereg (state,R367_QAM_EQU_PNT_GAIN ,Temp & ~0x40 ); + +// QAM_SWEEP_EN = 0 +readreg (state,R367_QAM_EQU_CTR_LPF_GAIN ,&Temp); +writereg (state,R367_QAM_EQU_CTR_LPF_GAIN ,Temp & ~0x08 ); + +QAM_SetDerotFrequency (state, IntermediateFrequency); + +// Release TRL +writereg (state,R367_QAM_CTRL_1 ,0x00 ); + + state->IF = IntermediateFrequency; + state->demod_state = QAMStarted; + +return status; +} + +static int OFDM_Start (struct stv_state *state,s32 offsetFreq,s32 IntermediateFrequency) +{ +int status =0 ; +u8 GAIN_SRC1 ; +u32 Derot; +u8 SYR_CTL ; +u8 tmp1; +u8 tmp2; + +if ( state->demod_state != OFDMSet ) { +// QAM Disable +writereg (state,R367_DEBUG_LT4 ,0x00 ); +writereg (state,R367_DEBUG_LT5 ,0x00 ); +writereg (state,R367_DEBUG_LT6 ,0x00 );// R367_QAM_CTRL_1 +writereg (state,R367_DEBUG_LT7 ,0x00 );// R367_QAM_CTRL_2 +writereg (state,R367_DEBUG_LT8 ,0x00 ); +writereg (state,R367_DEBUG_LT9 ,0x00 ); + +// Tuner Setup +writereg (state,R367_ANADIGCTRL ,0x89 );/* Buffer Q disabled, I Enabled, unsigned ADC */ +writereg (state,R367_DUAL_AD12 ,0x04 );/* ADCQ disabled */ + +// Clock setup +writereg (state,R367_ANACTRL ,0x0D );/* PLL bypassed and disabled */ +writereg (state,R367_TOPCTRL ,0x00 );// Set OFDM + +writereg (state,R367_PLLMDIV ,1 );/* IC runs at 54 MHz with a 27 MHz crystal */ +writereg (state,R367_PLLNDIV ,8 ); +writereg (state,R367_PLLSETUP ,0x18 );/* ADC clock is equal to system clock */ + +msleep (50 ); +writereg (state,R367_ANACTRL ,0x00 );/* PLL enabled and used */ + + state->master_clock =54000000 ; + state->adc_clock =54000000 ; + + state->demod_state = OFDMSet; + } + + state->m_bFirstTimeLock = true; + state->m_DemodLockTime =-1 ; + +// Set inversion in GAIN_SRC1 (fixed from init) +// is in GAIN_SRC1, see below + +GAIN_SRC1 =0xA0 ; +// Bandwidth + +// Fixed values for 54 MHz +switch (state->bandwidth) { +case 0 : +case 8000000 : +// Normrate = 44384; +writereg (state,R367_OFDM_TRL_CTL ,0x14 ); +writereg (state,R367_OFDM_TRL_NOMRATE1 ,0xB0 ); +writereg (state,R367_OFDM_TRL_NOMRATE2 ,0x56 ); +// Gain SRC = 2774 +writereg (state,R367_OFDM_GAIN_SRC1 ,0x0A |GAIN_SRC1 ); +writereg (state,R367_OFDM_GAIN_SRC2 ,0xD6 ); +break ; +case 7000000 : +// Normrate = 38836; +writereg (state,R367_OFDM_TRL_CTL ,0x14 ); +writereg (state,R367_OFDM_TRL_NOMRATE1 ,0xDA ); +writereg (state,R367_OFDM_TRL_NOMRATE2 ,0x4B ); +// Gain SRC = 2427 +writereg (state,R367_OFDM_GAIN_SRC1 ,0x09 |GAIN_SRC1 ); +writereg (state,R367_OFDM_GAIN_SRC2 ,0x7B ); +break ; +case 6000000 : +// Normrate = 33288; +writereg (state,R367_OFDM_TRL_CTL ,0x14 ); +writereg (state,R367_OFDM_TRL_NOMRATE1 ,0x04 ); +writereg (state,R367_OFDM_TRL_NOMRATE2 ,0x41 ); +// Gain SRC = 2080 +writereg (state,R367_OFDM_GAIN_SRC1 ,0x08 |GAIN_SRC1 ); +writereg (state,R367_OFDM_GAIN_SRC2 ,0x20 ); +break ; +default : +return -EINVAL ; +break ; + } + + Derot = ((IntermediateFrequency /1000 ) *65536 ) / (state->master_clock /1000 ); + +writereg (state,R367_OFDM_INC_DEROT1 ,(Derot>>8 )); +writereg (state,R367_OFDM_INC_DEROT2 ,(Derot)); + +readreg (state,R367_OFDM_SYR_CTL ,&SYR_CTL ); +SYR_CTL &= ~0x78 ; +writereg (state,R367_OFDM_SYR_CTL ,SYR_CTL );// EchoPos = 0 + + +writereg (state,R367_OFDM_COR_MODEGUARD ,0x03 );// Force = 0, Mode = 0, Guard = 3 +SYR_CTL &=0x01 ; +writereg (state,R367_OFDM_SYR_CTL ,SYR_CTL );// SYR_TR_DIS = 0 + +msleep (5 ); + +writereg (state,R367_OFDM_COR_CTL ,0x20 );// Start core + +// -- Begin M.V. +// Reset FEC and Read Solomon +readreg (state,R367_OFDM_SFDLYSETH ,&tmp1); +readreg (state,R367_TSGENERAL ,&tmp2); +writereg (state,R367_OFDM_SFDLYSETH ,tmp1 |0x08 ); +writereg (state,R367_TSGENERAL ,tmp2 |0x01 ); +// -- End M.V. + + state->m_SignalTimeOut =200 ; + state->IF = IntermediateFrequency; + state->demod_state = OFDMStarted; + state->m_DemodTimeOut =0 ; + state->m_FECTimeOut =0 ; + state->m_TSTimeOut =0 ; + +return status; +} + +#if 0 +static int Stop (struct stv_state *state) +{ +int status =0 ; + +switch (state->demod_state) + { +case QAMStarted: + status =writereg (state,R367_QAM_CTRL_1 ,0x06 ); + state->demod_state = QAMSet; +break ; +case OFDMStarted: + status =writereg (state,R367_OFDM_COR_CTL ,0x00 ); + state->demod_state = OFDMSet; +break ; +default : +break ; + } +return status; +} +#endif + +static s32 Log10x100 (u32 x) +{ +static u32 LookupTable[100 ] = { +101157945 ,103514217 ,105925373 ,108392691 ,110917482 , +113501082 ,116144861 ,118850223 ,121618600 ,124451461 ,// 800.5 - 809.5 +127350308 ,130316678 ,133352143 ,136458314 ,139636836 , +142889396 ,146217717 ,149623566 ,153108746 ,156675107 ,// 810.5 - 819.5 +160324539 ,164058977 ,167880402 ,171790839 ,175792361 , +179887092 ,184077200 ,188364909 ,192752491 ,197242274 ,// 820.5 - 829.5 +201836636 ,206538016 ,211348904 ,216271852 ,221309471 , +226464431 ,231739465 ,237137371 ,242661010 ,248313311 ,// 830.5 - 839.5 +254097271 ,260015956 ,266072506 ,272270131 ,278612117 , +285101827 ,291742701 ,298538262 ,305492111 ,312607937 ,// 840.5 - 849.5 +319889511 ,327340695 ,334965439 ,342767787 ,350751874 , +358921935 ,367282300 ,375837404 ,384591782 ,393550075 ,// 850.5 - 859.5 +402717034 ,412097519 ,421696503 ,431519077 ,441570447 , +451855944 ,462381021 ,473151259 ,484172368 ,495450191 ,// 860.5 - 869.5 +506990708 ,518800039 ,530884444 ,543250331 ,555904257 , +568852931 ,582103218 ,595662144 ,609536897 ,623734835 ,// 870.5 - 879.5 +638263486 ,653130553 ,668343918 ,683911647 ,699841996 , +716143410 ,732824533 ,749894209 ,767361489 ,785235635 ,// 880.5 - 889.5 +803526122 ,822242650 ,841395142 ,860993752 ,881048873 , +901571138 ,922571427 ,944060876 ,966050879 ,988553095 ,// 890.5 - 899.5 + }; +s32 y; +int i; + +if (x ==0 ) +return 0 ; + y =800 ; +if (x >=1000000000 ) { + x /=10 ; + y +=100 ; + } + +while (x <100000000 ) { + x *=10 ; + y -=100 ; + } + i =0 ; +while (i <100 && x > LookupTable[i]) + i +=1 ; + y += i; +return y; +} + +static int QAM_GetSignalToNoise (struct stv_state *state,s32 *pSignalToNoise) +{ +u32 RegValAvg =0 ; +u8 RegVal[2 ]; +int status =0 , i; + + *pSignalToNoise =0 ; +for (i =0 ; i <10 ; i +=1 ) { +readregs (state,R367_QAM_EQU_SNR_LO , RegVal,2 ); + RegValAvg += RegVal[0 ] +256 * RegVal[1 ]; + } +if (RegValAvg !=0 ) { +s32 Power =1 ; +switch (state->modulation) { +case QAM_16 : + Power =20480 ; +break ; +case QAM_32 : + Power =23040 ; +break ; +case QAM_64 : + Power =21504 ; +break ; +case QAM_128 : + Power =23616 ; +break ; +case QAM_256 : + Power =21760 ; +break ; +default : +break ; + } + *pSignalToNoise =Log10x100 ((Power *320 ) / RegValAvg); + }else { + *pSignalToNoise =380 ; + } +return status; +} + +static int OFDM_GetSignalToNoise (struct stv_state *state,s32 *pSignalToNoise) +{ +u8 CHC_SNR =0 ; + +int status =readreg (state,R367_OFDM_CHC_SNR , &CHC_SNR ); +if (status >=0 ) { +// Note: very unclear documentation on this. +// Datasheet states snr = CHC_SNR/4 dB -> way to high values! +// Software snr = ( 1000 * CHC_SNR ) / 8 / 32 / 10; -> to low values +// Comment in SW states this should be ( 1000 * CHC_SNR ) / 4 / 32 / 10; for the 367 +// 361/362 Datasheet: snr = CHC_SNR/8 dB -> this looks best + *pSignalToNoise = ( (s32 )CHC_SNR *10 ) /8 ; + } +//printk("SNR %d\n", *pSignalToNoise); +return status; +} + +#if 0 +static int DVBC_GetQuality (struct stv_state *state,s32 SignalToNoise,s32 *pQuality) +{ + *pQuality =100 ; +return 0 ; +}; + +static int DVBT_GetQuality (struct stv_state *state,s32 SignalToNoise,s32 *pQuality) +{ +static s32 QE_SN [] = { +51 ,// QPSK 1/2 +69 ,// QPSK 2/3 +79 ,// QPSK 3/4 +89 ,// QPSK 5/6 +97 ,// QPSK 7/8 +108 ,// 16-QAM 1/2 +131 ,// 16-QAM 2/3 +146 ,// 16-QAM 3/4 +156 ,// 16-QAM 5/6 +160 ,// 16-QAM 7/8 +165 ,// 64-QAM 1/2 +187 ,// 64-QAM 2/3 +202 ,// 64-QAM 3/4 +216 ,// 64-QAM 5/6 +225 ,// 64-QAM 7/8 + }; +u8 TPS_Received[2 ]; +int Constellation; +int CodeRate; +s32 SignalToNoiseRel, BERQuality; + + *pQuality =0 ; +readregs (state,R367_OFDM_TPS_RCVD2 , TPS_Received,sizeof (TPS_Received)); + Constellation = TPS_Received[0 ] &0x03 ; + CodeRate = TPS_Received[1 ] &0x07 ; + +if ( Constellation >2 || CodeRate >5 ) +return -1 ; + SignalToNoiseRel = SignalToNoise -QE_SN [Constellation *5 + CodeRate]; + BERQuality =100 ; + +if ( SignalToNoiseRel <-70 ) + *pQuality =0 ; +else if ( SignalToNoiseRel <30 ) { + *pQuality = ((SignalToNoiseRel +70 ) * BERQuality)/100 ; + }else + *pQuality = BERQuality; +return 0 ; +}; + +static s32 DVBCQuality (struct stv_state *state,s32 SignalToNoise) +{ +s32 SignalToNoiseRel =0 ; +s32 Quality =0 ; +s32 BERQuality =100 ; + +switch (state->modulation) { +case QAM_16 : SignalToNoiseRel = SignalToNoise -200 ;break ; +case QAM_32 : SignalToNoiseRel = SignalToNoise -230 ;break ;// Not in NorDig +case QAM_64 : SignalToNoiseRel = SignalToNoise -260 ;break ; +case QAM_128 : SignalToNoiseRel = SignalToNoise -290 ;break ; +case QAM_256 : SignalToNoiseRel = SignalToNoise -320 ;break ; + } + +if ( SignalToNoiseRel <-70 ) Quality =0 ; +else if ( SignalToNoiseRel <30 ) + { + Quality = ((SignalToNoiseRel +70 ) * BERQuality)/100 ; + } +else + Quality = BERQuality; + +return Quality; +} + +static int GetQuality (struct stv_state *state,s32 SignalToNoise,s32 *pQuality) +{ + *pQuality =0 ; +switch (state->demod_state) + { +case QAMStarted: + *pQuality =DVBCQuality (state, SignalToNoise); +break ; +case OFDMStarted: +return DVBT_GetQuality (state, SignalToNoise, pQuality); + } +return 0 ; +}; +#endif + +static int attach_init (struct stv_state *state) +{ +int stat =0 ; + + stat =readreg (state,R367_ID , &state->ID); +if ( stat <0 || state->ID !=0x60 ) +return -ENODEV ; +printk ("stv0367 found\n" ); + +writereg (state,R367_TOPCTRL ,0x10 ); +write_init_table (state, base_init); +write_init_table (state, qam_init); + +writereg (state,R367_TOPCTRL ,0x00 ); +write_init_table (state, ofdm_init); + +writereg (state,R367_OFDM_GAIN_SRC1 ,0x2A ); +writereg (state,R367_OFDM_GAIN_SRC2 ,0xD6 ); +writereg (state,R367_OFDM_INC_DEROT1 ,0x55 ); +writereg (state,R367_OFDM_INC_DEROT2 ,0x55 ); +writereg (state,R367_OFDM_TRL_CTL ,0x14 ); +writereg (state,R367_OFDM_TRL_NOMRATE1 ,0xAE ); +writereg (state,R367_OFDM_TRL_NOMRATE2 ,0x56 ); +writereg (state,R367_OFDM_FEPATH_CFG ,0x0 ); + +// OFDM TS Setup + +writereg (state,R367_OFDM_TSCFGH ,0x70 ); +writereg (state,R367_OFDM_TSCFGM ,0xC0 ); +writereg (state,R367_OFDM_TSCFGL ,0x20 ); +writereg (state,R367_OFDM_TSSPEED ,0x40 );// Fixed at 54 MHz +//writereg(state, R367_TSTBUS, 0x80); // Invert CLK + +writereg (state,R367_OFDM_TSCFGH ,0x71 ); +writereg (state,R367_OFDM_TSCFGH ,0x70 ); + +writereg (state,R367_TOPCTRL ,0x10 ); + +// Also needed for QAM +writereg (state,R367_OFDM_AGC12C ,0x01 );// AGC Pin setup + +writereg (state,R367_OFDM_AGCCTRL1 ,0x8A );// + +// QAM TS setup, note exact format also depends on descrambler settings +writereg (state,R367_QAM_OUTFORMAT_0 ,0x85 );// Inverted Clock, Swap, serial +// writereg(state, R367_QAM_OUTFORMAT_1, 0x00); // + +// Clock setup +writereg (state,R367_ANACTRL ,0x0D );/* PLL bypassed and disabled */ + +if ( state->master_clock ==58000000 ) { +writereg (state,R367_PLLMDIV ,27 );/* IC runs at 58 MHz with a 27 MHz crystal */ +writereg (state,R367_PLLNDIV ,232 ); + }else { +writereg (state,R367_PLLMDIV ,1 );/* IC runs at 54 MHz with a 27 MHz crystal */ +writereg (state,R367_PLLNDIV ,8 ); + } +writereg (state,R367_PLLSETUP ,0x18 );/* ADC clock is equal to system clock */ + +// Tuner setup +writereg (state,R367_ANADIGCTRL ,0x8b );/* Buffer Q disabled, I Enabled, signed ADC */ +writereg (state,R367_DUAL_AD12 ,0x04 );/* ADCQ disabled */ + +writereg (state,R367_QAM_FSM_SNR2_HTH ,0x23 );/* Improves the C/N lock limit */ +writereg (state,R367_QAM_IQ_QAM ,0x01 );/* ZIF/IF Automatic mode */ +writereg (state,R367_QAM_EQU_FFE_LEAKAGE ,0x83 );/* Improving burst noise performances */ +writereg (state,R367_QAM_IQDEM_ADJ_EN ,0x05 );/* Improving ACI performances */ + +writereg (state,R367_ANACTRL ,0x00 );/* PLL enabled and used */ + +writereg (state,R367_I2CRPT , state->I2CRPT); + state->demod_state = QAMSet; +return stat; +} + +#ifdef USE_API3 +static void c_release(struct dvb_frontend* fe) +#else +static void release(struct dvb_frontend* fe) +#endif +{ + struct stv_state *state=fe->demodulator_priv; + printk("%s\n", __FUNCTION__); + kfree(state); +} + +#ifdef USE_API3 +static int c_init (struct dvb_frontend *fe) +{ + struct stv_state *state=fe->demodulator_priv; + + if (mutex_trylock(&state->ctlock)==0) + return -EBUSY; + state->omode = OM_DVBC; + return 0; +} + +static int c_sleep(struct dvb_frontend* fe) +{ + struct stv_state *state=fe->demodulator_priv; + + mutex_unlock(&state->ctlock); + return 0; +} +#endif + +static int gate_ctrl(struct dvb_frontend *fe, int enable) +{ + struct stv_state *state = fe->demodulator_priv; + u8 i2crpt = state->I2CRPT & ~0x80; + + if (enable) + i2crpt |= 0x80; + if (writereg(state, R367_I2CRPT, i2crpt) < 0) + return -1; + state->I2CRPT = i2crpt; + return 0; +} + +#if 0 +static int c_track(struct dvb_frontend *fe, struct dvb_frontend_parameters *p) +{ + return DVBFE_ALGO_SEARCH_AGAIN; +} +#endif + +#if 0 +int (*set_property)(struct dvb_frontend* fe, struct dtv_property* tvp); +int (*get_property)(struct dvb_frontend* fe, struct dtv_property* tvp); +#endif + +static int ofdm_lock(struct stv_state *state) +{ + int status = 0; + u8 OFDM_Status; + s32 DemodTimeOut = 10; + s32 FECTimeOut = 0; + s32 TSTimeOut = 0; + u8 CPAMPMin = 255; + u8 CPAMPValue; + u8 SYR_STAT; + u8 FFTMode; + u8 TSStatus; + + msleep(state->m_SignalTimeOut); + readreg(state, R367_OFDM_STATUS,&OFDM_Status); + + if (!(OFDM_Status & 0x40)) + return -1; + //printk("lock 1\n"); + + readreg(state, R367_OFDM_SYR_STAT,&SYR_STAT); + FFTMode = (SYR_STAT & 0x0C) >> 2; + + switch(FFTMode) + { + case 0: // 2K + DemodTimeOut = 10; + FECTimeOut = 150; + TSTimeOut = 125; + CPAMPMin = 20; + break; + case 1: // 8K + DemodTimeOut = 55; + FECTimeOut = 600; + TSTimeOut = 500; + CPAMPMin = 80; + break; + case 2: // 4K + DemodTimeOut = 40; + FECTimeOut = 300; + TSTimeOut = 250; + CPAMPMin = 30; + break; + } + state->m_OFDM_FFTMode = FFTMode; + readreg(state, R367_OFDM_PPM_CPAMP_DIR,&CPAMPValue); + msleep(DemodTimeOut); + { + // Release FEC and Read Solomon Reset + u8 tmp1; + u8 tmp2; + readreg(state, R367_OFDM_SFDLYSETH,&tmp1); + readreg(state, R367_TSGENERAL,&tmp2); + writereg(state, R367_OFDM_SFDLYSETH,tmp1 & ~0x08); + writereg(state, R367_TSGENERAL,tmp2 & ~0x01); + } + msleep(FECTimeOut); + if( (OFDM_Status & 0x98) != 0x98 ) + ;//return -1; + //printk("lock 2\n"); + + { + u8 Guard = (SYR_STAT & 0x03); + if(Guard < 2) + { + u8 tmp; + readreg(state, R367_OFDM_SYR_CTL,&tmp); + writereg(state, R367_OFDM_SYR_CTL,tmp & ~0x04); // Clear AUTO_LE_EN + readreg(state, R367_OFDM_SYR_UPDATE,&tmp); + writereg(state, R367_OFDM_SYR_UPDATE,tmp & ~0x10); // Clear SYR_FILTER + } else { + u8 tmp; + readreg(state, R367_OFDM_SYR_CTL,&tmp); + writereg(state, R367_OFDM_SYR_CTL,tmp | 0x04); // Set AUTO_LE_EN + readreg(state, R367_OFDM_SYR_UPDATE,&tmp); + writereg(state, R367_OFDM_SYR_UPDATE,tmp | 0x10); // Set SYR_FILTER + } + + // apply Sfec workaround if 8K 64QAM CR!=1/2 + if( FFTMode == 1) + { + u8 tmp[2]; + readregs(state, R367_OFDM_TPS_RCVD2, tmp, 2); + if( ((tmp[0] & 0x03) == 0x02) && (( tmp[1] & 0x07 ) != 0) ) + { + writereg(state, R367_OFDM_SFDLYSETH,0xc0); + writereg(state, R367_OFDM_SFDLYSETM,0x60); + writereg(state, R367_OFDM_SFDLYSETL,0x00); + } + else + { + writereg(state, R367_OFDM_SFDLYSETH,0x00); + } + } + } + msleep(TSTimeOut); + readreg(state, R367_OFDM_TSSTATUS,&TSStatus); + if( (TSStatus & 0x80) != 0x80 ) + return -1; + //printk("lock 3\n"); + return status; +} + + +#ifdef USE_API3 +static int set_parameters(struct dvb_frontend *fe, + struct dvb_frontend_parameters *p) +{ + int stat; + struct stv_state *state = fe->demodulator_priv; + u32 OF = 0; + u32 IF; + + if (fe->ops.tuner_ops.set_params) + fe->ops.tuner_ops.set_params(fe, p); + + switch (state->omode) { + case OM_DVBC: + case OM_QAM_ITU_C: + state->modulation = p->u.qam.modulation; + state->symbol_rate = p->u.qam.symbol_rate; + break; + case OM_DVBT: + switch (p->u.ofdm.bandwidth) { + case BANDWIDTH_AUTO: + case BANDWIDTH_8_MHZ: + state->bandwidth = 8000000; + break; + case BANDWIDTH_7_MHZ: + state->bandwidth = 7000000; + break; + case BANDWIDTH_6_MHZ: + state->bandwidth = 6000000; + break; + default: + return -EINVAL; + } + break; + default: + return -EINVAL; + } +#else +static int set_parameters(struct dvb_frontend *fe) +{ + int stat; + struct stv_state *state = fe->demodulator_priv; + u32 OF = 0; + u32 IF; + + switch (fe->dtv_property_cache.delivery_system) { + case SYS_DVBC_ANNEX_A: + state->omode = OM_DVBC; + /* symbol rate 0 might cause an oops */ + if (fe->dtv_property_cache.symbol_rate == 0) { + printk(KERN_ERR "stv0367dd: Invalid symbol rate\n"); + return -EINVAL; + } + break; + case SYS_DVBT: + state->omode = OM_DVBT; + break; + default: + return -EINVAL; + } + if (fe->ops.tuner_ops.set_params) + fe->ops.tuner_ops.set_params(fe); + state->modulation = fe->dtv_property_cache.modulation; + state->symbol_rate = fe->dtv_property_cache.symbol_rate; + state->bandwidth = fe->dtv_property_cache.bandwidth_hz; +#endif + fe->ops.tuner_ops.get_if_frequency(fe, &IF); + //fe->ops.tuner_ops.get_frequency(fe, &IF); + + switch(state->omode) { + case OM_DVBT: + stat = OFDM_Start(state, OF, IF); + ofdm_lock(state); + break; + case OM_DVBC: + case OM_QAM_ITU_C: + stat = QAM_Start(state, OF, IF); + break; + default: + stat = -EINVAL; + } + //printk("%s IF=%d OF=%d done\n", __FUNCTION__, IF, OF); + return stat; +} + +#if 0 +static int c_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *p) +{ + //struct stv_state *state = fe->demodulator_priv; + //printk("%s\n", __FUNCTION__); + return 0; +} + +static int OFDM_GetLockStatus(struct stv_state *state, LOCK_STATUS* pLockStatus, s32 Time) +{ + int status = STATUS_SUCCESS; + u8 OFDM_Status; + s32 DemodTimeOut = 0; + s32 FECTimeOut = 0; + s32 TSTimeOut = 0; + u8 CPAMPMin = 255; + u8 CPAMPValue; + bool SYRLock; + u8 SYR_STAT; + u8 FFTMode; + u8 TSStatus; + + readreg(state, R367_OFDM_STATUS,&OFDM_Status); + + SYRLock = (OFDM_Status & 0x40) != 0; + + if( Time > m_SignalTimeOut && !SYRLock ) + { + *pLockStatus = NEVER_LOCK; + break; + } + + if( !SYRLock ) break; + + *pLockStatus = SIGNAL_PRESENT; + + // Check Mode + + readreg(state, R367_OFDM_SYR_STAT,&SYR_STAT); + FFTMode = (SYR_STAT & 0x0C) >> 2; + + switch(FFTMode) + { + case 0: // 2K + DemodTimeOut = 10; + FECTimeOut = 150; + TSTimeOut = 125; + CPAMPMin = 20; + break; + case 1: // 8K + DemodTimeOut = 55; + FECTimeOut = 600; + TSTimeOut = 500; + CPAMPMin = 80; + break; + case 2: // 4K + DemodTimeOut = 40; + FECTimeOut = 300; + TSTimeOut = 250; + CPAMPMin = 30; + break; + } + + m_OFDM_FFTMode = FFTMode; + + if( m_DemodTimeOut == 0 && m_bFirstTimeLock ) + { + m_DemodTimeOut = Time + DemodTimeOut; + //break; + } + + readreg(state, R367_OFDM_PPM_CPAMP_DIR,&CPAMPValue); + + if( Time <= m_DemodTimeOut && CPAMPValue < CPAMPMin ) + { + break; + } + + if( CPAMPValue < CPAMPMin && m_bFirstTimeLock ) + { + // initiate retry + *pLockStatus = NEVER_LOCK; + break; + } + + if( CPAMPValue < CPAMPMin ) break; + + *pLockStatus = DEMOD_LOCK; + + if( m_FECTimeOut == 0 && m_bFirstTimeLock ) + { + // Release FEC and Read Solomon Reset + u8 tmp1; + u8 tmp2; + readreg(state, R367_OFDM_SFDLYSETH,&tmp1); + readreg(state, R367_TSGENERAL,&tmp2); + writereg(state, R367_OFDM_SFDLYSETH,tmp1 & ~0x08); + writereg(state, R367_TSGENERAL,tmp2 & ~0x01); + + m_FECTimeOut = Time + FECTimeOut; + } + + // Wait for TSP_LOCK, LK, PRF + if( (OFDM_Status & 0x98) != 0x98 ) + { + if( Time > m_FECTimeOut ) *pLockStatus = NEVER_LOCK; + break; + } + + if( m_bFirstTimeLock && m_TSTimeOut == 0) + { + u8 Guard = (SYR_STAT & 0x03); + if(Guard < 2) + { + u8 tmp; + readreg(state, R367_OFDM_SYR_CTL,&tmp); + writereg(state, R367_OFDM_SYR_CTL,tmp & ~0x04); // Clear AUTO_LE_EN + readreg(state, R367_OFDM_SYR_UPDATE,&tmp); + writereg(state, R367_OFDM_SYR_UPDATE,tmp & ~0x10); // Clear SYR_FILTER + } else { + u8 tmp; + readreg(state, R367_OFDM_SYR_CTL,&tmp); + writereg(state, R367_OFDM_SYR_CTL,tmp | 0x04); // Set AUTO_LE_EN + readreg(state, R367_OFDM_SYR_UPDATE,&tmp); + writereg(state, R367_OFDM_SYR_UPDATE,tmp | 0x10); // Set SYR_FILTER + } + + // apply Sfec workaround if 8K 64QAM CR!=1/2 + if( FFTMode == 1) + { + u8 tmp[2]; + readreg(state, R367_OFDM_TPS_RCVD2,tmp,2); + if( ((tmp[0] & 0x03) == 0x02) && (( tmp[1] & 0x07 ) != 0) ) + { + writereg(state, R367_OFDM_SFDLYSETH,0xc0); + writereg(state, R367_OFDM_SFDLYSETM,0x60); + writereg(state, R367_OFDM_SFDLYSETL,0x00); + } + else + { + writereg(state, R367_OFDM_SFDLYSETH,0x00); + } + } + + m_TSTimeOut = Time + TSTimeOut; + } + readreg(state, R367_OFDM_TSSTATUS,&TSStatus); + if( (TSStatus & 0x80) != 0x80 ) + { + if( Time > m_TSTimeOut ) *pLockStatus = NEVER_LOCK; + break; + } + *pLockStatus = MPEG_LOCK; + m_bFirstTimeLock = false; + return status; +} + +#endif + +static int read_status(struct dvb_frontend *fe, fe_status_t *status) +{ + struct stv_state *state = fe->demodulator_priv; + *status=0; + + switch(state->demod_state) { + case QAMStarted: + { + u8 FEC_Lock; + u8 QAM_Lock; + + readreg(state, R367_QAM_FSM_STS, &QAM_Lock); + QAM_Lock &= 0x0F; + if (QAM_Lock >10) + *status|=0x07; + readreg(state, R367_QAM_FEC_STATUS,&FEC_Lock); + if (FEC_Lock&2) + *status|=0x1f; + if (state->m_bFirstTimeLock) { + state->m_bFirstTimeLock = false; + // QAM_AGC_ACCUMRSTSEL to Tracking; + writereg(state, R367_QAM_AGC_CTL, state->m_Save_QAM_AGC_CTL); + } + break; + } + case OFDMStarted: + { + u8 OFDM_Status; + u8 TSStatus; + + readreg(state, R367_OFDM_TSSTATUS, &TSStatus); + + readreg(state, R367_OFDM_STATUS, &OFDM_Status); + if (OFDM_Status & 0x40) + *status |= FE_HAS_SIGNAL; + + if ((OFDM_Status & 0x98) == 0x98) + *status|=0x0f; + + if (TSStatus & 0x80) + *status |= 0x1f; + break; + } + default: + break; + } + return 0; +} + +static int read_ber_ter(struct dvb_frontend *fe, u32 *ber) +{ + struct stv_state *state = fe->demodulator_priv; + u32 err; + u8 cnth, cntm, cntl; + +#if 1 + readreg(state, R367_OFDM_SFERRCNTH, &cnth); + + if (cnth & 0x80) { + *ber = state->ber; + return 0; + } + + readreg(state, R367_OFDM_SFERRCNTM, &cntm); + readreg(state, R367_OFDM_SFERRCNTL, &cntl); + + err = ((cnth & 0x7f) << 16) | (cntm << 8) | cntl; + +#if 0 + { + u64 err64; + err64 = (u64) err; + err64 *= 1000000000ULL; + err64 >>= 21; + err = err64; + } +#endif +#else + readreg(state, R367_OFDM_ERRCNT1HM, &cnth); + +#endif + *ber = state->ber = err; + return 0; +} + +static int read_ber_cab(struct dvb_frontend *fe, u32 *ber) +{ + struct stv_state *state = fe->demodulator_priv; + u32 err; + u8 cntm, cntl, ctrl; + + readreg(state, R367_QAM_BERT_1, &ctrl); + if (!(ctrl & 0x20)) { + readreg(state, R367_QAM_BERT_2, &cntl); + readreg(state, R367_QAM_BERT_3, &cntm); + err = (cntm << 8) | cntl; + //printk("err %04x\n", err); + state->ber = err; + writereg(state, R367_QAM_BERT_1, 0x27); + } + *ber = (u32) state->ber; + return 0; +} + +static int read_ber(struct dvb_frontend *fe, u32 *ber) +{ + struct stv_state *state = fe->demodulator_priv; + + if (state->demod_state == QAMStarted) + return read_ber_cab(fe, ber); + if (state->demod_state == OFDMStarted) + return read_ber_ter(fe, ber); + *ber = 0; + return 0; +} + +static int read_signal_strength(struct dvb_frontend *fe, u16 *strength) +{ + if (fe->ops.tuner_ops.get_rf_strength) + fe->ops.tuner_ops.get_rf_strength(fe, strength); + else + *strength = 0; + return 0; +} + +static int read_snr(struct dvb_frontend *fe, u16 *snr) +{ + struct stv_state *state = fe->demodulator_priv; + s32 snr2 = 0; + + switch(state->demod_state) { + case QAMStarted: + QAM_GetSignalToNoise(state, &snr2); + break; + case OFDMStarted: + OFDM_GetSignalToNoise(state, &snr2); + break; + default: + break; + } + *snr = snr2&0xffff; + return 0; +} + +static int read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) +{ + struct stv_state *state = fe->demodulator_priv; + u8 errl, errm, errh; + u8 val; + + switch(state->demod_state) { + case QAMStarted: + readreg(state, R367_QAM_RS_COUNTER_4, &errl); + readreg(state, R367_QAM_RS_COUNTER_5, &errm); + *ucblocks = (errm << 8) | errl; + break; + case OFDMStarted: + readreg(state, R367_OFDM_SFERRCNTH, &val); + if ((val & 0x80) == 0) { + readreg(state, R367_OFDM_ERRCNT1H, &errh); + readreg(state, R367_OFDM_ERRCNT1M, &errl); + readreg(state, R367_OFDM_ERRCNT1L, &errm); + state->ucblocks = (errh <<16) | (errm << 8) | errl; + } + *ucblocks = state->ucblocks; + break; + default: + *ucblocks = 0; + break; + } + return 0; +} + +static int c_get_tune_settings(struct dvb_frontend *fe, + struct dvb_frontend_tune_settings *sets) +{ + sets->min_delay_ms=3000; + sets->max_drift=0; + sets->step_size=0; + return 0; +} + +#ifndef USE_API3 +static int get_tune_settings(struct dvb_frontend *fe, + struct dvb_frontend_tune_settings *sets) +{ + switch (fe->dtv_property_cache.delivery_system) { + case SYS_DVBC_ANNEX_A: + case SYS_DVBC_ANNEX_C: + return c_get_tune_settings(fe, sets); + default: + /* DVB-T: Use info.frequency_stepsize. */ + return -EINVAL; + } +} +#endif + +#ifdef USE_API3 +static void t_release(struct dvb_frontend* fe) +{ + //struct stv_state *state=fe->demodulator_priv; + //printk("%s\n", __FUNCTION__); + //kfree(state); +} + +static int t_init (struct dvb_frontend *fe) +{ + struct stv_state *state=fe->demodulator_priv; + if (mutex_trylock(&state->ctlock)==0) + return -EBUSY; + state->omode = OM_DVBT; + return 0; +} + +static int t_sleep(struct dvb_frontend* fe) +{ + struct stv_state *state=fe->demodulator_priv; + mutex_unlock(&state->ctlock); + return 0; +} +#endif + +#if 0 +static int t_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *p) +{ + //struct stv_state *state = fe->demodulator_priv; + //printk("%s\n", __FUNCTION__); + return 0; +} + +static enum dvbfe_algo algo(struct dvb_frontend *fe) +{ + return DVBFE_ALGO_CUSTOM; +} +#endif + +#ifdef USE_API3 +static struct dvb_frontend_ops c_ops = { + .info = { + .name = "STV0367 DVB-C", + .type = FE_QAM, + .frequency_stepsize = 62500, + .frequency_min = 47000000, + .frequency_max = 862000000, + .symbol_rate_min = 870000, + .symbol_rate_max = 11700000, + .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 | + FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_FEC_AUTO + }, + .release = c_release, + .init = c_init, + .sleep = c_sleep, + .i2c_gate_ctrl = gate_ctrl, + + .get_tune_settings = c_get_tune_settings, + + .read_status = read_status, + .read_ber = read_ber, + .read_signal_strength = read_signal_strength, + .read_snr = read_snr, + .read_ucblocks = read_ucblocks, + +#if 1 + .set_frontend = set_parameters, +#else + .get_frontend_algo = algo, + .search = search, +#endif +}; + +static struct dvb_frontend_ops t_ops = { + .info = { + .name = "STV0367 DVB-T", + .type = FE_OFDM, + .frequency_min = 47125000, + .frequency_max = 865000000, + .frequency_stepsize = 166667, + .frequency_tolerance = 0, + .caps = 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_QAM_16 | FE_CAN_QAM_64 | + FE_CAN_QAM_AUTO | + FE_CAN_TRANSMISSION_MODE_AUTO | + FE_CAN_GUARD_INTERVAL_AUTO | + FE_CAN_HIERARCHY_AUTO | FE_CAN_RECOVER | + FE_CAN_MUTE_TS + }, + .release = t_release, + .init = t_init, + .sleep = t_sleep, + .i2c_gate_ctrl = gate_ctrl, + + .set_frontend = set_parameters, + + .read_status = read_status, + .read_ber = read_ber, + .read_signal_strength = read_signal_strength, + .read_snr = read_snr, + .read_ucblocks = read_ucblocks, +}; + +#else + +static struct dvb_frontend_ops common_ops = { + .delsys = { SYS_DVBC_ANNEX_A, SYS_DVBT }, + .info = { + .name = "STV0367 DVB-C DVB-T", + .frequency_stepsize = 166667, /* DVB-T only */ + .frequency_min = 47000000, /* DVB-T: 47125000 */ + .frequency_max = 865000000, /* DVB-C: 862000000 */ + .symbol_rate_min = 870000, + .symbol_rate_max = 11700000, + .caps = /* DVB-C */ + FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 | + FE_CAN_QAM_128 | FE_CAN_QAM_256 | + FE_CAN_FEC_AUTO | + /* DVB-T */ + FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_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_TRANSMISSION_MODE_AUTO | + FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO | + FE_CAN_RECOVER | FE_CAN_MUTE_TS + }, + .release = release, + .i2c_gate_ctrl = gate_ctrl, + + .get_tune_settings = get_tune_settings, + + .set_frontend = set_parameters, + + .read_status = read_status, + .read_ber = read_ber, + .read_signal_strength = read_signal_strength, + .read_snr = read_snr, + .read_ucblocks = read_ucblocks, +}; +#endif + + +static void init_state(struct stv_state *state, struct stv0367_cfg *cfg) +{ + u32 ulENARPTLEVEL = 5; + u32 ulQAMInversion = 2; + state->omode = OM_NONE; + state->adr = cfg->adr; + + mutex_init(&state->mutex); + mutex_init(&state->ctlock); + +#ifdef USE_API3 + memcpy(&state->c_frontend.ops, &c_ops, sizeof(struct dvb_frontend_ops)); + memcpy(&state->t_frontend.ops, &t_ops, sizeof(struct dvb_frontend_ops)); + state->c_frontend.demodulator_priv = state; + state->t_frontend.demodulator_priv = state; +#else + memcpy(&state->frontend.ops, &common_ops, sizeof(struct dvb_frontend_ops)); + state->frontend.demodulator_priv = state; +#endif + + state->master_clock = 58000000; + state->adc_clock = 58000000; + state->I2CRPT = 0x08 | ((ulENARPTLEVEL & 0x07) << 4); + state->qam_inversion = ((ulQAMInversion & 3) << 6 ); + state->demod_state = Off; +} + + +struct dvb_frontend *stv0367_attach(struct i2c_adapter *i2c, struct stv0367_cfg *cfg, + struct dvb_frontend **fe_t) +{ + struct stv_state *state = NULL; + + state = kzalloc(sizeof(struct stv_state), GFP_KERNEL); + if (!state) + return NULL; + + state->i2c = i2c; + init_state(state, cfg); + + if (attach_init(state)<0) + goto error; +#ifdef USE_API3 + *fe_t = &state->t_frontend; + return &state->c_frontend; +#else + return &state->frontend; +#endif + +error: + printk("stv0367: not found\n"); + kfree(state); + return NULL; +} + + +MODULE_DESCRIPTION("STV0367DD driver"); +MODULE_AUTHOR("Ralph Metzler, Manfred Voelkel"); +MODULE_LICENSE("GPL"); + +EXPORT_SYMBOL(stv0367_attach); + + +drivers/media/dvb-frontends/stv0367dd.h new file +48
-0@@ -0,0 +1,48 @@ +/* +* stv0367dd.h: STV0367 DVB-C/T demodulator driver +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#ifndef _STV0367DD_H_ +#define _STV0367DD_H_ + +#include <linux/types.h> +#include <linux/i2c.h> + +struct stv0367_cfg { +u8 adr; +u32 xtal; +u32 ts_mode; +}; + +#if IS_ENABLED (CONFIG_DVB_STV0367DD ) +extern struct dvb_frontend *stv0367_attach (struct i2c_adapter *i2c, +struct stv0367_cfg *cfg, +struct dvb_frontend **fe_t); +#else +static inline struct dvb_frontend *stv0367_attach (struct i2c_adapter *i2c, +struct stv0367_cfg *cfg, +struct dvb_frontend **fe_t); +{ +printk (KERN_WARNING "%s: driver disabled by Kconfig\n" , __func__); +return NULL ; +} +#endif + +#endif drivers/media/dvb-frontends/stv0367dd_regs.h new file +3442
-0@@ -0,0 +1,3442 @@ +/* +* stv0367dd_regs.h: DVB-C/DVB-T STMicroelectronics STV0367 +* register defintions +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#ifndef _STV0367DD_REGS_H_ +#define _STV0367DD_REGS_H_ + +/* ID */ +#define R367_ID 0xF000 +#define F367_IDENTIFICATIONREG 0xF00000FF + +/* I2CRPT */ +#define R367_I2CRPT 0xF001 +#define F367_I2CT_ON 0xF0010080 +#define F367_ENARPT_LEVEL 0xF0010070 +#define F367_SCLT_DELAY 0xF0010008 +#define F367_SCLT_NOD 0xF0010004 +#define F367_STOP_ENABLE 0xF0010002 +#define F367_SDAT_NOD 0xF0010001 + +/* TOPCTRL */ +#define R367_TOPCTRL 0xF002 +#define F367_STDBY 0xF0020080 +#define F367_STDBY_FEC 0xF0020040 +#define F367_STDBY_CORE 0xF0020020 +#define F367_QAM_COFDM 0xF0020010 +#define F367_TS_DIS 0xF0020008 +#define F367_DIR_CLK_216 0xF0020004 +#define F367_TUNER_BB 0xF0020002 +#define F367_DVBT_H 0xF0020001 + +/* IOCFG0 */ +#define R367_IOCFG0 0xF003 +#define F367_OP0_SD 0xF0030080 +#define F367_OP0_VAL 0xF0030040 +#define F367_OP0_OD 0xF0030020 +#define F367_OP0_INV 0xF0030010 +#define F367_OP0_DACVALUE_HI 0xF003000F + +/* DAC0R */ +#define R367_DAC0R 0xF004 +#define F367_OP0_DACVALUE_LO 0xF00400FF + +/* IOCFG1 */ +#define R367_IOCFG1 0xF005 +#define F367_IP0 0xF0050040 +#define F367_OP1_OD 0xF0050020 +#define F367_OP1_INV 0xF0050010 +#define F367_OP1_DACVALUE_HI 0xF005000F + +/* DAC1R */ +#define R367_DAC1R 0xF006 +#define F367_OP1_DACVALUE_LO 0xF00600FF + +/* IOCFG2 */ +#define R367_IOCFG2 0xF007 +#define F367_OP2_LOCK_CONF 0xF00700E0 +#define F367_OP2_OD 0xF0070010 +#define F367_OP2_VAL 0xF0070008 +#define F367_OP1_LOCK_CONF 0xF0070007 + +/* SDFR */ +#define R367_SDFR 0xF008 +#define F367_OP0_FREQ 0xF00800F0 +#define F367_OP1_FREQ 0xF008000F + +/* STATUS */ +#define R367_OFDM_STATUS 0xF009 +#define F367_TPS_LOCK 0xF0090080 +#define F367_SYR_LOCK 0xF0090040 +#define F367_AGC_LOCK 0xF0090020 +#define F367_PRF 0xF0090010 +#define F367_LK 0xF0090008 +#define F367_PR 0xF0090007 + +/* AUX_CLK */ +#define R367_AUX_CLK 0xF00A +#define F367_AUXFEC_CTL 0xF00A00C0 +#define F367_DIS_CKX4 0xF00A0020 +#define F367_CKSEL 0xF00A0018 +#define F367_CKDIV_PROG 0xF00A0006 +#define F367_AUXCLK_ENA 0xF00A0001 + +/* FREESYS1 */ +#define R367_FREESYS1 0xF00B +#define F367_FREE_SYS1 0xF00B00FF + +/* FREESYS2 */ +#define R367_FREESYS2 0xF00C +#define F367_FREE_SYS2 0xF00C00FF + +/* FREESYS3 */ +#define R367_FREESYS3 0xF00D +#define F367_FREE_SYS3 0xF00D00FF + +/* GPIO_CFG */ +#define R367_GPIO_CFG 0xF00E +#define F367_GPIO7_NOD 0xF00E0080 +#define F367_GPIO7_CFG 0xF00E0040 +#define F367_GPIO6_NOD 0xF00E0020 +#define F367_GPIO6_CFG 0xF00E0010 +#define F367_GPIO5_NOD 0xF00E0008 +#define F367_GPIO5_CFG 0xF00E0004 +#define F367_GPIO4_NOD 0xF00E0002 +#define F367_GPIO4_CFG 0xF00E0001 + +/* GPIO_CMD */ +#define R367_GPIO_CMD 0xF00F +#define F367_GPIO7_VAL 0xF00F0008 +#define F367_GPIO6_VAL 0xF00F0004 +#define F367_GPIO5_VAL 0xF00F0002 +#define F367_GPIO4_VAL 0xF00F0001 + +/* AGC2MAX */ +#define R367_OFDM_AGC2MAX 0xF010 +#define F367_OFDM_AGC2_MAX 0xF01000FF + +/* AGC2MIN */ +#define R367_OFDM_AGC2MIN 0xF011 +#define F367_OFDM_AGC2_MIN 0xF01100FF + +/* AGC1MAX */ +#define R367_OFDM_AGC1MAX 0xF012 +#define F367_OFDM_AGC1_MAX 0xF01200FF + +/* AGC1MIN */ +#define R367_OFDM_AGC1MIN 0xF013 +#define F367_OFDM_AGC1_MIN 0xF01300FF + +/* AGCR */ +#define R367_OFDM_AGCR 0xF014 +#define F367_OFDM_RATIO_A 0xF01400E0 +#define F367_OFDM_RATIO_B 0xF0140018 +#define F367_OFDM_RATIO_C 0xF0140007 + +/* AGC2TH */ +#define R367_OFDM_AGC2TH 0xF015 +#define F367_OFDM_AGC2_THRES 0xF01500FF + +/* AGC12C */ +#define R367_OFDM_AGC12C 0xF016 +#define F367_OFDM_AGC1_IV 0xF0160080 +#define F367_OFDM_AGC1_OD 0xF0160040 +#define F367_OFDM_AGC1_LOAD 0xF0160020 +#define F367_OFDM_AGC2_IV 0xF0160010 +#define F367_OFDM_AGC2_OD 0xF0160008 +#define F367_OFDM_AGC2_LOAD 0xF0160004 +#define F367_OFDM_AGC12_MODE 0xF0160003 + +/* AGCCTRL1 */ +#define R367_OFDM_AGCCTRL1 0xF017 +#define F367_OFDM_DAGC_ON 0xF0170080 +#define F367_OFDM_INVERT_AGC12 0xF0170040 +#define F367_OFDM_AGC1_MODE 0xF0170008 +#define F367_OFDM_AGC2_MODE 0xF0170007 + +/* AGCCTRL2 */ +#define R367_OFDM_AGCCTRL2 0xF018 +#define F367_OFDM_FRZ2_CTRL 0xF0180060 +#define F367_OFDM_FRZ1_CTRL 0xF0180018 +#define F367_OFDM_TIME_CST 0xF0180007 + +/* AGC1VAL1 */ +#define R367_OFDM_AGC1VAL1 0xF019 +#define F367_OFDM_AGC1_VAL_LO 0xF01900FF + +/* AGC1VAL2 */ +#define R367_OFDM_AGC1VAL2 0xF01A +#define F367_OFDM_AGC1_VAL_HI 0xF01A000F + +/* AGC2VAL1 */ +#define R367_OFDM_AGC2VAL1 0xF01B +#define F367_OFDM_AGC2_VAL_LO 0xF01B00FF + +/* AGC2VAL2 */ +#define R367_OFDM_AGC2VAL2 0xF01C +#define F367_OFDM_AGC2_VAL_HI 0xF01C000F + +/* AGC2PGA */ +#define R367_OFDM_AGC2PGA 0xF01D +#define F367_OFDM_AGC2_PGA 0xF01D00FF + +/* OVF_RATE1 */ +#define R367_OFDM_OVF_RATE1 0xF01E +#define F367_OFDM_OVF_RATE_HI 0xF01E000F + +/* OVF_RATE2 */ +#define R367_OFDM_OVF_RATE2 0xF01F +#define F367_OFDM_OVF_RATE_LO 0xF01F00FF + +/* GAIN_SRC1 */ +#define R367_OFDM_GAIN_SRC1 0xF020 +#define F367_OFDM_INV_SPECTR 0xF0200080 +#define F367_OFDM_IQ_INVERT 0xF0200040 +#define F367_OFDM_INR_BYPASS 0xF0200020 +#define F367_OFDM_STATUS_INV_SPECRUM 0xF0200010 +#define F367_OFDM_GAIN_SRC_HI 0xF020000F + +/* GAIN_SRC2 */ +#define R367_OFDM_GAIN_SRC2 0xF021 +#define F367_OFDM_GAIN_SRC_LO 0xF02100FF + +/* INC_DEROT1 */ +#define R367_OFDM_INC_DEROT1 0xF022 +#define F367_OFDM_INC_DEROT_HI 0xF02200FF + +/* INC_DEROT2 */ +#define R367_OFDM_INC_DEROT2 0xF023 +#define F367_OFDM_INC_DEROT_LO 0xF02300FF + +/* PPM_CPAMP_DIR */ +#define R367_OFDM_PPM_CPAMP_DIR 0xF024 +#define F367_OFDM_PPM_CPAMP_DIRECT 0xF02400FF + +/* PPM_CPAMP_INV */ +#define R367_OFDM_PPM_CPAMP_INV 0xF025 +#define F367_OFDM_PPM_CPAMP_INVER 0xF02500FF + +/* FREESTFE_1 */ +#define R367_OFDM_FREESTFE_1 0xF026 +#define F367_OFDM_SYMBOL_NUMBER_INC 0xF02600C0 +#define F367_OFDM_SEL_LSB 0xF0260004 +#define F367_OFDM_AVERAGE_ON 0xF0260002 +#define F367_OFDM_DC_ADJ 0xF0260001 + +/* FREESTFE_2 */ +#define R367_OFDM_FREESTFE_2 0xF027 +#define F367_OFDM_SEL_SRCOUT 0xF02700C0 +#define F367_OFDM_SEL_SYRTHR 0xF027001F + +/* DCOFFSET */ +#define R367_OFDM_DCOFFSET 0xF028 +#define F367_OFDM_SELECT_I_Q 0xF0280080 +#define F367_OFDM_DC_OFFSET 0xF028007F + +/* EN_PROCESS */ +#define R367_OFDM_EN_PROCESS 0xF029 +#define F367_OFDM_FREE 0xF02900F0 +#define F367_OFDM_ENAB_MANUAL 0xF0290001 + +/* SDI_SMOOTHER */ +#define R367_OFDM_SDI_SMOOTHER 0xF02A +#define F367_OFDM_DIS_SMOOTH 0xF02A0080 +#define F367_OFDM_SDI_INC_SMOOTHER 0xF02A007F + +/* FE_LOOP_OPEN */ +#define R367_OFDM_FE_LOOP_OPEN 0xF02B +#define F367_OFDM_TRL_LOOP_OP 0xF02B0002 +#define F367_OFDM_CRL_LOOP_OP 0xF02B0001 + +/* FREQOFF1 */ +#define R367_OFDM_FREQOFF1 0xF02C +#define F367_OFDM_FREQ_OFFSET_LOOP_OPEN_VHI 0xF02C00FF + +/* FREQOFF2 */ +#define R367_OFDM_FREQOFF2 0xF02D +#define F367_OFDM_FREQ_OFFSET_LOOP_OPEN_HI 0xF02D00FF + +/* FREQOFF3 */ +#define R367_OFDM_FREQOFF3 0xF02E +#define F367_OFDM_FREQ_OFFSET_LOOP_OPEN_LO 0xF02E00FF + +/* TIMOFF1 */ +#define R367_OFDM_TIMOFF1 0xF02F +#define F367_OFDM_TIM_OFFSET_LOOP_OPEN_HI 0xF02F00FF + +/* TIMOFF2 */ +#define R367_OFDM_TIMOFF2 0xF030 +#define F367_OFDM_TIM_OFFSET_LOOP_OPEN_LO 0xF03000FF + +/* EPQ */ +#define R367_OFDM_EPQ 0xF031 +#define F367_OFDM_EPQ1 0xF03100FF + +/* EPQAUTO */ +#define R367_OFDM_EPQAUTO 0xF032 +#define F367_OFDM_EPQ2 0xF03200FF + +/* SYR_UPDATE */ +#define R367_OFDM_SYR_UPDATE 0xF033 +#define F367_OFDM_SYR_PROTV 0xF0330080 +#define F367_OFDM_SYR_PROTV_GAIN 0xF0330060 +#define F367_OFDM_SYR_FILTER 0xF0330010 +#define F367_OFDM_SYR_TRACK_THRES 0xF033000C + +/* CHPFREE */ +#define R367_OFDM_CHPFREE 0xF034 +#define F367_OFDM_CHP_FREE 0xF03400FF + +/* PPM_STATE_MAC */ +#define R367_OFDM_PPM_STATE_MAC 0xF035 +#define F367_OFDM_PPM_STATE_MACHINE_DECODER 0xF035003F + +/* INR_THRESHOLD */ +#define R367_OFDM_INR_THRESHOLD 0xF036 +#define F367_OFDM_INR_THRESH 0xF03600FF + +/* EPQ_TPS_ID_CELL */ +#define R367_OFDM_EPQ_TPS_ID_CELL 0xF037 +#define F367_OFDM_ENABLE_LGTH_TO_CF 0xF0370080 +#define F367_OFDM_DIS_TPS_RSVD 0xF0370040 +#define F367_OFDM_DIS_BCH 0xF0370020 +#define F367_OFDM_DIS_ID_CEL 0xF0370010 +#define F367_OFDM_TPS_ADJUST_SYM 0xF037000F + +/* EPQ_CFG */ +#define R367_OFDM_EPQ_CFG 0xF038 +#define F367_OFDM_EPQ_RANGE 0xF0380002 +#define F367_OFDM_EPQ_SOFT 0xF0380001 + +/* EPQ_STATUS */ +#define R367_OFDM_EPQ_STATUS 0xF039 +#define F367_OFDM_SLOPE_INC 0xF03900FC +#define F367_OFDM_TPS_FIELD 0xF0390003 + +/* AUTORELOCK */ +#define R367_OFDM_AUTORELOCK 0xF03A +#define F367_OFDM_BYPASS_BER_TEMPO 0xF03A0080 +#define F367_OFDM_BER_TEMPO 0xF03A0070 +#define F367_OFDM_BYPASS_COFDM_TEMPO 0xF03A0008 +#define F367_OFDM_COFDM_TEMPO 0xF03A0007 + +/* BER_THR_VMSB */ +#define R367_OFDM_BER_THR_VMSB 0xF03B +#define F367_OFDM_BER_THRESHOLD_HI 0xF03B00FF + +/* BER_THR_MSB */ +#define R367_OFDM_BER_THR_MSB 0xF03C +#define F367_OFDM_BER_THRESHOLD_MID 0xF03C00FF + +/* BER_THR_LSB */ +#define R367_OFDM_BER_THR_LSB 0xF03D +#define F367_OFDM_BER_THRESHOLD_LO 0xF03D00FF + +/* CCD */ +#define R367_OFDM_CCD 0xF03E +#define F367_OFDM_CCD_DETECTED 0xF03E0080 +#define F367_OFDM_CCD_RESET 0xF03E0040 +#define F367_OFDM_CCD_THRESHOLD 0xF03E000F + +/* SPECTR_CFG */ +#define R367_OFDM_SPECTR_CFG 0xF03F +#define F367_OFDM_SPECT_CFG 0xF03F0003 + +/* CONSTMU_MSB */ +#define R367_OFDM_CONSTMU_MSB 0xF040 +#define F367_OFDM_CONSTMU_FREEZE 0xF0400080 +#define F367_OFDM_CONSTNU_FORCE_EN 0xF0400040 +#define F367_OFDM_CONST_MU_MSB 0xF040003F + +/* CONSTMU_LSB */ +#define R367_OFDM_CONSTMU_LSB 0xF041 +#define F367_OFDM_CONST_MU_LSB 0xF04100FF + +/* CONSTMU_MAX_MSB */ +#define R367_OFDM_CONSTMU_MAX_MSB 0xF042 +#define F367_OFDM_CONST_MU_MAX_MSB 0xF042003F + +/* CONSTMU_MAX_LSB */ +#define R367_OFDM_CONSTMU_MAX_LSB 0xF043 +#define F367_OFDM_CONST_MU_MAX_LSB 0xF04300FF + +/* ALPHANOISE */ +#define R367_OFDM_ALPHANOISE 0xF044 +#define F367_OFDM_USE_ALLFILTER 0xF0440080 +#define F367_OFDM_INTER_ON 0xF0440040 +#define F367_OFDM_ALPHA_NOISE 0xF044001F + +/* MAXGP_MSB */ +#define R367_OFDM_MAXGP_MSB 0xF045 +#define F367_OFDM_MUFILTER_LENGTH 0xF04500F0 +#define F367_OFDM_MAX_GP_MSB 0xF045000F + +/* MAXGP_LSB */ +#define R367_OFDM_MAXGP_LSB 0xF046 +#define F367_OFDM_MAX_GP_LSB 0xF04600FF + +/* ALPHAMSB */ +#define R367_OFDM_ALPHAMSB 0xF047 +#define F367_OFDM_CHC_DATARATE 0xF04700C0 +#define F367_OFDM_ALPHA_MSB 0xF047003F + +/* ALPHALSB */ +#define R367_OFDM_ALPHALSB 0xF048 +#define F367_OFDM_ALPHA_LSB 0xF04800FF + +/* PILOT_ACCU */ +#define R367_OFDM_PILOT_ACCU 0xF049 +#define F367_OFDM_USE_SCAT4ADDAPT 0xF0490080 +#define F367_OFDM_PILOT_ACC 0xF049001F + +/* PILOTMU_ACCU */ +#define R367_OFDM_PILOTMU_ACCU 0xF04A +#define F367_OFDM_DISCARD_BAD_SP 0xF04A0080 +#define F367_OFDM_DISCARD_BAD_CP 0xF04A0040 +#define F367_OFDM_PILOT_MU_ACCU 0xF04A001F + +/* FILT_CHANNEL_EST */ +#define R367_OFDM_FILT_CHANNEL_EST 0xF04B +#define F367_OFDM_USE_FILT_PILOT 0xF04B0080 +#define F367_OFDM_FILT_CHANNEL 0xF04B007F + +/* ALPHA_NOPISE_FREQ */ +#define R367_OFDM_ALPHA_NOPISE_FREQ 0xF04C +#define F367_OFDM_NOISE_FREQ_FILT 0xF04C0040 +#define F367_OFDM_ALPHA_NOISE_FREQ 0xF04C003F + +/* RATIO_PILOT */ +#define R367_OFDM_RATIO_PILOT 0xF04D +#define F367_OFDM_RATIO_MEAN_SP 0xF04D00F0 +#define F367_OFDM_RATIO_MEAN_CP 0xF04D000F + +/* CHC_CTL */ +#define R367_OFDM_CHC_CTL 0xF04E +#define F367_OFDM_TRACK_EN 0xF04E0080 +#define F367_OFDM_NOISE_NORM_EN 0xF04E0040 +#define F367_OFDM_FORCE_CHC_RESET 0xF04E0020 +#define F367_OFDM_SHORT_TIME 0xF04E0010 +#define F367_OFDM_FORCE_STATE_EN 0xF04E0008 +#define F367_OFDM_FORCE_STATE 0xF04E0007 + +/* EPQ_ADJUST */ +#define R367_OFDM_EPQ_ADJUST 0xF04F +#define F367_OFDM_ADJUST_SCAT_IND 0xF04F00C0 +#define F367_OFDM_ONE_SYMBOL 0xF04F0010 +#define F367_OFDM_EPQ_DECAY 0xF04F000E +#define F367_OFDM_HOLD_SLOPE 0xF04F0001 + +/* EPQ_THRES */ +#define R367_OFDM_EPQ_THRES 0xF050 +#define F367_OFDM_EPQ_THR 0xF05000FF + +/* OMEGA_CTL */ +#define R367_OFDM_OMEGA_CTL 0xF051 +#define F367_OFDM_OMEGA_RST 0xF0510080 +#define F367_OFDM_FREEZE_OMEGA 0xF0510040 +#define F367_OFDM_OMEGA_SEL 0xF051003F + +/* GP_CTL */ +#define R367_OFDM_GP_CTL 0xF052 +#define F367_OFDM_CHC_STATE 0xF05200E0 +#define F367_OFDM_FREEZE_GP 0xF0520010 +#define F367_OFDM_GP_SEL 0xF052000F + +/* MUMSB */ +#define R367_OFDM_MUMSB 0xF053 +#define F367_OFDM_MU_MSB 0xF053007F + +/* MULSB */ +#define R367_OFDM_MULSB 0xF054 +#define F367_OFDM_MU_LSB 0xF05400FF + +/* GPMSB */ +#define R367_OFDM_GPMSB 0xF055 +#define F367_OFDM_CSI_THRESHOLD 0xF05500E0 +#define F367_OFDM_GP_MSB 0xF055000F + +/* GPLSB */ +#define R367_OFDM_GPLSB 0xF056 +#define F367_OFDM_GP_LSB 0xF05600FF + +/* OMEGAMSB */ +#define R367_OFDM_OMEGAMSB 0xF057 +#define F367_OFDM_OMEGA_MSB 0xF057007F + +/* OMEGALSB */ +#define R367_OFDM_OMEGALSB 0xF058 +#define F367_OFDM_OMEGA_LSB 0xF05800FF + +/* SCAT_NB */ +#define R367_OFDM_SCAT_NB 0xF059 +#define F367_OFDM_CHC_TEST 0xF05900F8 +#define F367_OFDM_SCAT_NUMB 0xF0590003 + +/* CHC_DUMMY */ +#define R367_OFDM_CHC_DUMMY 0xF05A +#define F367_OFDM_CHC_DUM 0xF05A00FF + +/* INC_CTL */ +#define R367_OFDM_INC_CTL 0xF05B +#define F367_OFDM_INC_BYPASS 0xF05B0080 +#define F367_OFDM_INC_NDEPTH 0xF05B000C +#define F367_OFDM_INC_MADEPTH 0xF05B0003 + +/* INCTHRES_COR1 */ +#define R367_OFDM_INCTHRES_COR1 0xF05C +#define F367_OFDM_INC_THRES_COR1 0xF05C00FF + +/* INCTHRES_COR2 */ +#define R367_OFDM_INCTHRES_COR2 0xF05D +#define F367_OFDM_INC_THRES_COR2 0xF05D00FF + +/* INCTHRES_DET1 */ +#define R367_OFDM_INCTHRES_DET1 0xF05E +#define F367_OFDM_INC_THRES_DET1 0xF05E003F + +/* INCTHRES_DET2 */ +#define R367_OFDM_INCTHRES_DET2 0xF05F +#define F367_OFDM_INC_THRES_DET2 0xF05F003F + +/* IIR_CELLNB */ +#define R367_OFDM_IIR_CELLNB 0xF060 +#define F367_OFDM_NRST_IIR 0xF0600080 +#define F367_OFDM_IIR_CELL_NB 0xF0600007 + +/* IIRCX_COEFF1_MSB */ +#define R367_OFDM_IIRCX_COEFF1_MSB 0xF061 +#define F367_OFDM_IIR_CX_COEFF1_MSB 0xF06100FF + +/* IIRCX_COEFF1_LSB */ +#define R367_OFDM_IIRCX_COEFF1_LSB 0xF062 +#define F367_OFDM_IIR_CX_COEFF1_LSB 0xF06200FF + +/* IIRCX_COEFF2_MSB */ +#define R367_OFDM_IIRCX_COEFF2_MSB 0xF063 +#define F367_OFDM_IIR_CX_COEFF2_MSB 0xF06300FF + +/* IIRCX_COEFF2_LSB */ +#define R367_OFDM_IIRCX_COEFF2_LSB 0xF064 +#define F367_OFDM_IIR_CX_COEFF2_LSB 0xF06400FF + +/* IIRCX_COEFF3_MSB */ +#define R367_OFDM_IIRCX_COEFF3_MSB 0xF065 +#define F367_OFDM_IIR_CX_COEFF3_MSB 0xF06500FF + +/* IIRCX_COEFF3_LSB */ +#define R367_OFDM_IIRCX_COEFF3_LSB 0xF066 +#define F367_OFDM_IIR_CX_COEFF3_LSB 0xF06600FF + +/* IIRCX_COEFF4_MSB */ +#define R367_OFDM_IIRCX_COEFF4_MSB 0xF067 +#define F367_OFDM_IIR_CX_COEFF4_MSB 0xF06700FF + +/* IIRCX_COEFF4_LSB */ +#define R367_OFDM_IIRCX_COEFF4_LSB 0xF068 +#define F367_OFDM_IIR_CX_COEFF4_LSB 0xF06800FF + +/* IIRCX_COEFF5_MSB */ +#define R367_OFDM_IIRCX_COEFF5_MSB 0xF069 +#define F367_OFDM_IIR_CX_COEFF5_MSB 0xF06900FF + +/* IIRCX_COEFF5_LSB */ +#define R367_OFDM_IIRCX_COEFF5_LSB 0xF06A +#define F367_OFDM_IIR_CX_COEFF5_LSB 0xF06A00FF + +/* FEPATH_CFG */ +#define R367_OFDM_FEPATH_CFG 0xF06B +#define F367_OFDM_DEMUX_SWAP 0xF06B0004 +#define F367_OFDM_DIGAGC_SWAP 0xF06B0002 +#define F367_OFDM_LONGPATH_IF 0xF06B0001 + +/* PMC1_FUNC */ +#define R367_OFDM_PMC1_FUNC 0xF06C +#define F367_OFDM_SOFT_RSTN 0xF06C0080 +#define F367_OFDM_PMC1_AVERAGE_TIME 0xF06C0078 +#define F367_OFDM_PMC1_WAIT_TIME 0xF06C0006 +#define F367_OFDM_PMC1_2N_SEL 0xF06C0001 + +/* PMC1_FOR */ +#define R367_OFDM_PMC1_FOR 0xF06D +#define F367_OFDM_PMC1_FORCE 0xF06D0080 +#define F367_OFDM_PMC1_FORCE_VALUE 0xF06D007C + +/* PMC2_FUNC */ +#define R367_OFDM_PMC2_FUNC 0xF06E +#define F367_OFDM_PMC2_SOFT_STN 0xF06E0080 +#define F367_OFDM_PMC2_ACCU_TIME 0xF06E0070 +#define F367_OFDM_PMC2_CMDP_MN 0xF06E0008 +#define F367_OFDM_PMC2_SWAP 0xF06E0004 + +/* STATUS_ERR_DA */ +#define R367_OFDM_STATUS_ERR_DA 0xF06F +#define F367_OFDM_COM_USEGAINTRK 0xF06F0080 +#define F367_OFDM_COM_AGCLOCK 0xF06F0040 +#define F367_OFDM_AUT_AGCLOCK 0xF06F0020 +#define F367_OFDM_MIN_ERR_X_LSB 0xF06F000F + +/* DIG_AGC_R */ +#define R367_OFDM_DIG_AGC_R 0xF070 +#define F367_OFDM_COM_SOFT_RSTN 0xF0700080 +#define F367_OFDM_COM_AGC_ON 0xF0700040 +#define F367_OFDM_COM_EARLY 0xF0700020 +#define F367_OFDM_AUT_SOFT_RESETN 0xF0700010Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 2 lines
Cheers, Mauro
Part of the diff is not shown here. View the raw message.
Re: [PATCH 04/12] tda18212dd: Support for NXP TDA18212 (DD) silicon tuner
In reply to Maik BroemmeHi Maik,
Em Sun, 3 Nov 2013 01:31:04 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 10 lines
Added support for the NXP TDA18212 silicon tuner used by recent Digital Devices hardware. This will allow update of ddbridge driver to support newer devices.
Signed-off-by Maik Broemme <[email protected]>--- drivers/media/dvb-frontends/Kconfig | 9 + drivers/media/dvb-frontends/Makefile | 1 + drivers/media/dvb-frontends/tda18212dd.c | 934 +++++++++++++++++++++++++++++++ drivers/media/dvb-frontends/tda18212dd.h | 37 ++
I'm not sure if support for this tuner is not provided already by one of the existing drivers. If not, it is ok to submit a driver for it, but you should just call it as tda18212.
I'm c/c Antti, as he worked on some NXP drivers recently, and may be aware if a driver already supports TDA18212.
This is not a full review, as I can't review quickly code that is not following the Linux Coding Style.
Yet, it points to some issues that I was able to notice on it.
Regards,
Mauro
Quoted 68 lines
4 files changed, 981 insertions(+) create mode 100644 drivers/media/dvb-frontends/tda18212dd.c create mode 100644 drivers/media/dvb-frontends/tda18212dd.hdrivers/media/dvb-frontends/Kconfig +9
-0@@ -65,6 +65,15 @@ config DVB_STV0367DD Say Y when you want to support this frontend. +config DVB_TDA18212DD + tristate "NXP TDA18212 silicon tuner (DD)" + depends on DVB_CORE && I2C + default m if DVB_FE_CUSTOMISE + help + NXP TDA18212 silicon tuner (Digital Devices driver). + + Say Y when you want to support this tuner. + comment "DVB-S (satellite) frontends" depends on DVB_COREdrivers/media/dvb-frontends/Makefile +1
-0@@ -98,6 +98,7 @@ obj-$(CONFIG_DVB_CXD2820R) += cxd2820r.o obj-$(CONFIG_DVB_DRXK) += drxk.o obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o obj-$(CONFIG_DVB_STV0367DD) += stv0367dd.o +obj-$(CONFIG_DVB_TDA18212DD) += tda18212dd.o obj-$(CONFIG_DVB_IT913X_FE) += it913x-fe.o obj-$(CONFIG_DVB_A8293) += a8293.o obj-$(CONFIG_DVB_TDA10071) += tda10071.odrivers/media/dvb-frontends/tda18212dd.c new file +26
-0@@ -0,0 +1,934 @@ +/* +* tda18212dd.c: Driver for the TDA18212 tuner +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/init.h> +#include <linux/delay.h>
drivers/media/dvb-frontends/tda18212dd.c line 36
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +10
-0+#include <linux/firmware.h> +#include <linux/i2c.h> +#include <linux/version.h> +#include <asm/div64.h> + +#include "dvb_frontend.h" + +#ifndef CHK_ERROR +#define CHK_ERROR (s) if ((status = s) < 0) break +#endif
Don't do that. Using macros to do break/return is explicitly forbidden at linux coding style. See Documentation/CodingStyle.
If you take a look on the git history for drx-k:
$ git log --follow drivers/media/dvb-frontends/drxk_hard.c
you'll see that I fixed it there, using some perl scripts, on this changeset:
commit ea90f011fdcc3d4fde78532eab8af09637176765
Author: Mauro Carvalho Chehab <[email protected]> Date: Sun Jul 3 18:06:07 2011 -0300
[media] drxk: Remove the CHK_ERROR macro
The CHK_ERROR macro does a flow control, violating chapter 12
of the Documentation/CodingStyle. Doing flow controls inside
macros is a bad idea, as it hides what's happening. It also
hides the var "status" with is also a bad idea.
The changes were done by this small perl script:
my $blk=0;
while (<>) {
s /^\s+// if ($blk);
$f =~ s/\s+$// if ($blk && /^\(/);
$blk = 1 if (!m/\#/ && m/CHK_ERROR/);
$blk=0 if ($blk && m/\;/);
s/\n/ / if ($blk);
$f.=$_;
};
$f=~ s,\n(\t+)CHK_ERROR\((.*)\)\;([^\n]*),\n\1status = \2;\3\n\1if (status < 0)\n\1\tbreak;,g;
print $f;
And manually fixed.
Signed-off-by: Mauro Carvalho Chehab <[email protected]>Eventually, the very same script could be useful for you.
Btw, I suggest you take a look at the cleanup patches for DRX-K, as you'll likely need to to the same here.
drivers/media/dvb-frontends/tda18212dd.c line 44
Quoted 8 lines
drivers/media/dvb-frontends/tda18212dd.c new file +8
-0+ +#define MASTER_PSM_AGC1 0 +#define MASTER_AGC1_6_15dB 1 + +#define SLAVE_PSM_AGC1 1 +#define SLAVE_AGC1_6_15dB 0 + +// 0 = 2 Vpp ... 2 = 1 Vpp, 7 = 0.5 Vpp
C99 comments is forbidden. Please review your code with script/checkpatch.pl to be sure that you're following our coding style.
Quoted 66 lines
drivers/media/dvb-frontends/tda18212dd.c new file +66
-0+#define IF_LEVEL_DVBC 2 +#define IF_LEVEL_DVBT 2 + +enum { +ID_1 =0x00 , +ID_2 =0x01 , +ID_3 =0x02 , +THERMO_1 , +THERMO_2 , +POWER_STATE_1 , +POWER_STATE_2 , +INPUT_POWER_LEVEL , +IRQ_STATUS , +IRQ_ENABLE , +IRQ_CLEAR , +IRQ_SET , +AGC1_1 , +AGC2_1 , +AGCK_1 , +RF_AGC_1 , +IR_MIXER_1 =0x10 , +AGC5_1 , +IF_AGC , +IF_1 , +REFERENCE , +IF_FREQUENCY_1 , +RF_FREQUENCY_1 , +RF_FREQUENCY_2 , +RF_FREQUENCY_3 , +MSM_1 , +MSM_2 , +PSM_1 , +DCC_1 , +FLO_MAX , +IR_CAL_1 , +IR_CAL_2 , +IR_CAL_3 =0x20 , +IR_CAL_4 , +VSYNC_MGT , +IR_MIXER_2 , +AGC1_2 , +AGC5_2 , +RF_CAL_1 , +RF_CAL_2 , +RF_CAL_3 , +RF_CAL_4 , +RF_CAL_5 , +RF_CAL_6 , +RF_FILTER_1 , +RF_FILTER_2 , +RF_FILTER_3 , +RF_BAND_PASS_FILTER , +CP_CURRENT =0x30 , +AGC_DET_OUT =0x31 , +RF_AGC_GAIN_1 =0x32 , +RF_AGC_GAIN_2 =0x33 , +IF_AGC_GAIN =0x34 , +POWER_1 =0x35 , +POWER_2 =0x36 , +MISC_1 , +RFCAL_LOG_1 , +RFCAL_LOG_2 , +RFCAL_LOG_3 , +RFCAL_LOG_4 , +RFCAL_LOG_5 , +RFCAL_LOG_6 ,
drivers/media/dvb-frontends/tda18212dd.c line 120
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +10
-0+RFCAL_LOG_7 , +RFCAL_LOG_8 , +RFCAL_LOG_9 =0x40 , +RFCAL_LOG_10 =0x41 , +RFCAL_LOG_11 =0x42 , +RFCAL_LOG_12 =0x43 , + REG_MAX, +}; + +enum HF_Standard {
No CammelCase is allowed.
Quoted 15 lines
drivers/media/dvb-frontends/tda18212dd.c new file +15
-0+ HF_None=0 ,HF_B ,HF_DK ,HF_G ,HF_I ,HF_L ,HF_L1 ,HF_MN , HF_FM_Radio, + HF_AnalogMax,HF_DVBT_6MHZ ,HF_DVBT_7MHZ ,HF_DVBT_8MHZ , +HF_DVBT ,HF_ATSC ,HF_DVBC_6MHZ ,HF_DVBC_7MHZ , +HF_DVBC_8MHZ ,HF_DVBC +}; + +struct SStandardParams { +s32 m_IFFrequency; +u32 m_BandWidth; +u8 m_IF_1;// FF IF_HP_fc:2 IF_Notch:1 LP_FC_Offset:2 LP_FC:3 +u8 m_IR_MIXER_2;// 03 :6 HI_Pass:1 DC_Notch:1 +u8 m_AGC1_1;// 0F :4 AGC1_Top:4 +u8 m_AGC2_1;// 0F :4 AGC2_Top:4 +u8 m_RF_AGC_1_Low;// EF RF_AGC_Adapt:1 RF_AGC_Adapt_Top:2 :1 RF_Atten_3dB:1 RF_AGC_Top:3 +u8 m_RF_AGC_1_High;// EF RF_AGC_Adapt:1 RF_AGC_Adapt_Top:2 :1 RF_Atten_3dB:1 RF_AGC_Top:3
drivers/media/dvb-frontends/tda18212dd.c line 145
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +10
-0+u8 m_IR_MIXER_1;// 0F :4 IR_mixer_Top:4 +u8 m_AGC5_1;// 1F :3 AGC5_Ana AGC5_Top:4 +u8 m_AGCK_1;// 0F :4 AGCK_Step:2 AGCK_Mode:2 +u8 m_PSM_1;// 20 :2 PSM_StoB:1 :5 +bool m_AGC1_Freeze; +bool m_LTO_STO_immune; +}; + +#if 0 +static struct SStandardParams m_StandardTable[HF_DVBC_8MHZ - HF_DVBT_6MHZ + 1] =
That "+1" looks weird... IMHO, what this code is trying to do is something like:
static struct SStandardParams m_StandardTable[] = {
{ some data },
{ some data },
{ some data },
{ some data },
{ 0 }
};
If so, please do on the above way, explicitly showing that a "zero" element at the end of the array is needed.
Quoted 46 lines
drivers/media/dvb-frontends/tda18212dd.c new file +46
-0+{ + { 3250000, 6000000, 0x20, 0x03, 0x00, 0x07, 0x2B, 0x2C, 0x0B, 0x0B, 0x02, 0x20, false, false }, // HF_DVBT_6MHZ + { 3500000, 7000000, 0x31, 0x01, 0x00, 0x07, 0x2B, 0x2C, 0x0B, 0x0B, 0x02, 0x20, false, false }, // HF_DVBT_7MHZ + { 4000000, 8000000, 0x22, 0x01, 0x00, 0x07, 0x2B, 0x2C, 0x0B, 0x0B, 0x02, 0x20, false, false }, // HF_DVBT_8MHZ + { 0, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, false, false }, // HF_DVBT (Unused) + { 3250000, 6000000, 0x20, 0x03, 0x0A, 0x07, 0x6D, 0x6D, 0x0E, 0x0E, 0x02, 0x20, false, false }, // HF_ATSC + { 3600000, 6000000, 0x10, 0x01, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_6MHZ +// { 5000000, 7000000, 0x53, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_7MHZ (not documented by NXP, use same settings as 8 MHZ) +// { 5000000, 8000000, 0x53, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_8MHZ + { 5000000, 7000000, 0x93, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_7MHZ (not documented by NXP, use same settings as 8 MHZ) + { 5000000, 8000000, 0x43, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_8MHZ +}; +#else +static struct SStandardParams m_StandardTable[HF_DVBC_8MHZ - HF_DVBT_6MHZ + 1] = +{ + { 4000000, 6000000, 0x41, 0x03, 0x00, 0x07, 0x2B, 0x2C, 0x0B, 0x0B, 0x02, 0x20, false, false }, // HF_DVBT_6MHZ + { 4500000, 7000000, 0x42, 0x03, 0x00, 0x07, 0x2B, 0x2C, 0x0B, 0x0B, 0x02, 0x20, false, false }, // HF_DVBT_7MHZ + { 5000000, 8000000, 0x43, 0x03, 0x00, 0x07, 0x2B, 0x2C, 0x0B, 0x0B, 0x02, 0x20, false, false }, // HF_DVBT_8MHZ + // ------------------------------ + { 0, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, false, false }, // HF_DVBT (Unused) + { 3250000, 6000000, 0x20, 0x03, 0x0A, 0x07, 0x6D, 0x6D, 0x0E, 0x0E, 0x02, 0x20, false, false }, // HF_ATSC + { 3600000, 6000000, 0x10, 0x01, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_6MHZ +// { 5000000, 7000000, 0x53, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_7MHZ (not documented by NXP, use same settings as 8 MHZ) +// { 5000000, 8000000, 0x53, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_8MHZ + { 5000000, 7000000, 0x93, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_7MHZ (not documented by NXP, use same settings as 8 MHZ) + { 5000000, 8000000, 0x43, 0x03, 0x00, 0x07, 0x83, 0x83, 0x0B, 0x0B, 0x02, 0x00, true , true }, // HF_DVBC_8MHZ +}; +#endif +struct tda_state { + struct i2c_adapter *i2c; + u8 adr; + + enum HF_Standard m_Standard; + u32 m_Frequency; + u32 IF; + + bool m_isMaster; + bool m_bPowerMeasurement; + bool m_bLTEnable; + bool m_bEnableFreeze; + + u16 m_ID; + + s32 m_SettlingTime; + + u8 m_IFLevelDVBC;
drivers/media/dvb-frontends/tda18212dd.c line 201
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +10
-0+u8 m_IFLevelDVBT; +u8 m_Regs[REG_MAX ]; +u8 m_LastPowerLevel; +}; + +static int i2c_readn (struct i2c_adapter *adapter,u8 adr,u8 *data,int len) +{ +struct i2c_msg msgs[1 ] = {{.addr = adr, .flags =I2C_M_RD , + .buf = data, .len = len}}; +return (i2c_transfer (adapter, msgs,1 ) ==1 ) ?0 :-1 ;
Error codes: just return the error code provided by Linux, instead of using any other error code convention.
Quoted 22 lines
drivers/media/dvb-frontends/tda18212dd.c new file +22
-0+} + +static int i2c_read (struct i2c_adapter *adap, +u8 adr,u8 *msg,int len,u8 *answ,int alen) +{ +struct i2c_msg msgs[2 ] = { { .addr = adr, .flags =0 , + .buf = msg, .len = len}, + { .addr = adr, .flags =I2C_M_RD , + .buf = answ, .len = alen } }; +if (i2c_transfer (adap, msgs,2 ) !=2 ) { +printk ("tda18212dd: i2c_read error\n" ); +return -1 ; + } +return 0 ; +} + +static int i2c_write (struct i2c_adapter *adap,u8 adr,u8 *data,int len) +{ +struct i2c_msg msg = {.addr = adr, .flags =0 , + .buf = data, .len = len}; + +if (i2c_transfer (adap, &msg,1 ) !=1 ) {
drivers/media/dvb-frontends/tda18212dd.c line 233
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +10
-0+printk ("tda18212: i2c_write error\n" ); +return -1 ; + } +return 0 ; +} + +static int write_regs (struct tda_state *state, +u8 SubAddr,u8 *Regs,u16 nRegs) +{ +u8 data[nRegs+1 ];
Don't use dynamic arrays. This is evil, as the Kernel stack is too small, and dynamic allocation disables the code that checks for the stack size at compile time.
Instead, just use a fixed size, like:
u8 data[80];
Quoted 512 lines
drivers/media/dvb-frontends/tda18212dd.c new file +512
-0+ + data[0 ] = SubAddr; +memcpy (data +1 , Regs, nRegs); +return i2c_write (state->i2c, state->adr, data, nRegs+1 ); +} + +static int write_reg (struct tda_state *state,u8 SubAddr,u8 Reg) +{ +u8 msg[2 ] = {SubAddr, Reg}; + +return i2c_write (state->i2c, state->adr, msg,2 ); +} + +static int Read (struct tda_state *state,u8 * Regs) +{ +return i2c_readn (state->i2c, state->adr, Regs,REG_MAX ); +} + +static int update_regs (struct tda_state *state,u8 RegFrom,u8 RegTo) +{ +return write_regs (state, RegFrom, + &state->m_Regs[RegFrom], RegTo-RegFrom+1 ); +} + +static int update_reg (struct tda_state *state,u8 Reg) +{ +return write_reg (state, Reg,state->m_Regs[Reg]); +} + + +static int read_regs (struct tda_state *state, +u8 SubAddr,u8 *Regs,u16 nRegs) +{ +return i2c_read (state->i2c, state->adr, + &SubAddr,1 , Regs, nRegs); +} + +static int read_reg (struct tda_state *state, +u8 SubAddr,u8 *Reg) +{ +return i2c_read (state->i2c, state->adr, + &SubAddr,1 , Reg,1 ); +} + +static int read_reg1 (struct tda_state *state,u8 Reg) +{ +return read_reg (state, Reg, &state->m_Regs[Reg]); +} + +static void init_state (struct tda_state *state) +{ +u32 ulIFLevelDVBC =IF_LEVEL_DVBC ; +u32 ulIFLevelDVBT =IF_LEVEL_DVBT ; +u32 ulPowerMeasurement =1 ; +u32 ulLTEnable =1 ; +u32 ulEnableFreeze =0 ; + + state->m_Frequency =0 ; + state->m_isMaster = true; + state->m_ID =0 ; + state->m_LastPowerLevel =0xFF ; + state->m_IFLevelDVBC = (ulIFLevelDVBC &0x07 ); + state->m_IFLevelDVBT = (ulIFLevelDVBT &0x07 ); + state->m_bPowerMeasurement = (ulPowerMeasurement !=0 ); + state->m_bLTEnable = (ulLTEnable !=0 ); + state->m_bEnableFreeze = (ulEnableFreeze !=0 ); +} + +static int StartCalibration (struct tda_state *state) +{ +int status =0 ; +do { + state->m_Regs[POWER_2 ] &= ~0x02 ;// RSSI CK = 31.25 kHz +CHK_ERROR (update_reg (state,POWER_2 )); + + state->m_Regs[AGC1_2 ] = (state->m_Regs[AGC1_2 ] & ~0x60 ) |0x40 ;// AGC1 Do Step = 2 +CHK_ERROR (update_reg (state,AGC1_2 ));// AGC + + state->m_Regs[RF_FILTER_3 ] = (state->m_Regs[RF_FILTER_3 ] & ~0xC0 ) |0x40 ;// AGC2 Do Step = 1 +CHK_ERROR (update_reg (state,RF_FILTER_3 )); + + state->m_Regs[AGCK_1 ] |=0xC0 ;// AGCs Assym Up Step = 3 // Datasheet sets all bits to 1! +CHK_ERROR (update_reg (state,AGCK_1 )); + + state->m_Regs[AGC5_1 ] = (state->m_Regs[AGC5_1 ] & ~0x60 ) |0x40 ;// AGCs Assym Do Step = 2 +CHK_ERROR (update_reg (state,AGC5_1 )); + + state->m_Regs[IRQ_CLEAR ] |=0x80 ;// Reset IRQ +CHK_ERROR (update_reg (state,IRQ_CLEAR )); + + state->m_Regs[MSM_1 ] =0x3B ;// Set Calibration + state->m_Regs[MSM_2 ] =0x01 ;// Start MSM +CHK_ERROR (update_regs (state,MSM_1 ,MSM_2 )); + state->m_Regs[MSM_2 ] =0x00 ; + + }while (0 ); +return status; +} + +static int FinishCalibration (struct tda_state *state) +{ +int status =0 ; +u8 RFCal_Log[12 ]; + +do { +u8 IRQ =0 ; +int Timeout =150 ;// 1.5 s +while (true) { +CHK_ERROR (read_reg (state,IRQ_STATUS , &IRQ )); +if ((IRQ &0x80 ) !=0 ) +break ; + Timeout -=1 ; +if (Timeout ==0 ) { + status =-1 ; +break ; + } +msleep (10 ); + } +CHK_ERROR (status); + + state->m_Regs[FLO_MAX ] =0x0A ; +CHK_ERROR (update_reg (state,FLO_MAX )); + + state->m_Regs[AGC1_1 ] &= ~0xC0 ; +if ( state->m_bLTEnable ) state->m_Regs[AGC1_1 ] |=0x80 ;// LTEnable + + state->m_Regs[AGC1_1 ] |= (state->m_isMaster ? MASTER_AGC1_6_15dB : SLAVE_AGC1_6_15dB ) <<6 ; +CHK_ERROR (update_reg (state,AGC1_1 )); + + state->m_Regs[PSM_1 ] &= ~0xC0 ; + state->m_Regs[PSM_1 ] |= (state->m_isMaster ?MASTER_PSM_AGC1 :SLAVE_PSM_AGC1 ) <<6 ; +CHK_ERROR (update_reg (state,PSM_1 )); + + state->m_Regs[REFERENCE ] |=0x03 ;// XTOUT = 3 +CHK_ERROR (update_reg (state,REFERENCE )); + +CHK_ERROR (read_regs (state,RFCAL_LOG_1 ,RFCal_Log,sizeof (RFCal_Log))); + }while (0 ); +return status; +} + +static int PowerOn (struct tda_state *state) +{ + state->m_Regs[POWER_STATE_2 ] &= ~0x0F ; +update_reg (state,POWER_STATE_2 ); + state->m_Regs[REFERENCE ] |=0x40 ;// Digital clock source = Sigma Delta +update_reg (state,REFERENCE ); +return 0 ; +} + +static int Standby (struct tda_state *state) +{ +int status =0 ; + +do { + state->m_Regs[REFERENCE ] &= ~0x40 ;// Digital clock source = Quarz +CHK_ERROR (update_reg (state,REFERENCE )); + + state->m_Regs[POWER_STATE_2 ] &= ~0x0F ; + state->m_Regs[POWER_STATE_2 ] |= state->m_isMaster ?0x08 :0x0E ; +CHK_ERROR (update_reg (state,POWER_STATE_2 )); + }while (0 ); +return status; +} + +static int attach_init (struct tda_state *state) +{ +int stat =0 ; +u8 Id[2 ]; +u8 PowerState =0x00 ; + + state->m_Standard = HF_None; + +/* first read after cold reset sometimes fails on some cards, +try twice */ + stat =read_regs (state,ID_1 , Id,sizeof (Id)); + stat =read_regs (state,ID_1 , Id,sizeof (Id)); +if (stat <0 ) +return -1 ; + + state->m_ID = ((Id[0 ] &0x7F ) <<8 ) | Id[1 ]; + state->m_isMaster = ((Id[0 ] &0x80 ) !=0 ); +if ( !state->m_isMaster ) + state->m_bLTEnable = false; + +printk ("tda18212dd: ChipID %04x\n" , state->m_ID); + +if ( state->m_ID !=18212 ) +return -1 ; + + stat =read_reg (state,POWER_STATE_1 ,&PowerState); +if (stat <0 ) +return stat; + +printk ("tda18212dd: PowerState %02x\n" , PowerState); + +if (state->m_isMaster) { +if ( PowerState &0x02 ) { +// msleep for XTAL Calibration (on a PC this should be long done) +u8 IRQStatus =0 ; +int Timeout =10 ; + +while (Timeout >0 ) { +read_reg (state,IRQ_STATUS , &IRQStatus); +if (IRQStatus &0x20 ) +break ; + Timeout -=1 ; +msleep (10 ); + } +if ( (IRQStatus &0x20 ) ==0 ) { + stat = -ETIMEDOUT ; + } + } + }else { +write_reg (state,FLO_MAX ,0x00 ); +write_reg (state,CP_CURRENT ,0x68 ); + } +Read (state, state->m_Regs); + +PowerOn (state); +StartCalibration (state); +FinishCalibration (state); +Standby (state); +return stat; +} + +static int PowerMeasurement (struct tda_state *state,u8 *pPowerLevel) +{ +int status =0 ; + +do { +u8 IRQ =0 ; +int Timeout =70 ;// 700 ms + + state->m_Regs[IRQ_CLEAR ] |=0x80 ;// Reset IRQ +CHK_ERROR (update_reg (state,IRQ_CLEAR )); + + state->m_Regs[MSM_1 ] =0x80 ;// power measurement + state->m_Regs[MSM_2 ] =0x01 ;// Start MSM +CHK_ERROR (update_regs (state,MSM_1 ,MSM_2 )); + state->m_Regs[MSM_2 ] =0x00 ; + +while (true) { +CHK_ERROR (read_reg (state,IRQ_STATUS , &IRQ )); +if ( (IRQ &0x80 ) !=0 ) +break ; + Timeout -=1 ; +if ( Timeout ==0 ) + { + status =-1 ; +break ; + } +msleep (10 ); + } +CHK_ERROR (status); + +CHK_ERROR (read_reg1 (state,INPUT_POWER_LEVEL )); + *pPowerLevel = state->m_Regs[INPUT_POWER_LEVEL ] &0x7F ; + + +if ( *pPowerLevel >110 ) *pPowerLevel =110 ; + }while (0 ); +/* printk("PL %d\n", *pPowerLevel); */ +return status; +} + +static int SetFrequency (struct tda_state *state,u32 Frequency,enum HF_Standard Standard) +{ +int status =0 ; +struct SStandardParams *StandardParams; +u32 f = Frequency /1000 ; +u8 IRQ =0 ; +int Timeout =25 ;// 250 ms +u32 fRatio = Frequency /16000000 ; +u32 fDelta = Frequency - fRatio *16000000 ; + +if ( Standard <HF_DVBT_6MHZ || Standard >HF_DVBC_8MHZ ) +return -EINVAL ; + StandardParams = &m_StandardTable[Standard -HF_DVBT_6MHZ ]; + +if ( StandardParams->m_IFFrequency ==0 ) +return -EINVAL ; + state->m_Standard = HF_None; + state->m_Frequency =0 ; + +do { +// IF Level + state->m_Regs[IF_AGC ] = (Standard >=HF_DVBC_6MHZ ) ? state->m_IFLevelDVBC : state->m_IFLevelDVBT; +CHK_ERROR (update_reg (state,IF_AGC )); + +// --------------------------------------------------------------------------------- +// Standard setup + + state->m_Regs[IF_1 ] = StandardParams->m_IF_1; +CHK_ERROR (update_reg (state,IF_1 )); + + state->m_Regs[IR_MIXER_2 ] = (state->m_Regs[IR_MIXER_2 ] & ~0x03 ) | StandardParams->m_IR_MIXER_2; +CHK_ERROR (update_reg (state,IR_MIXER_2 )); + + state->m_Regs[AGC1_1 ] = (state->m_Regs[AGC1_1 ] & ~0x0F ) | StandardParams->m_AGC1_1; +CHK_ERROR (update_reg (state,AGC1_1 )); + + state->m_Regs[AGC2_1 ] = (state->m_Regs[AGC2_1 ] & ~0x0F ) | StandardParams->m_AGC2_1; +CHK_ERROR (update_reg (state,AGC2_1 )); + + state->m_Regs[RF_AGC_1 ] &= ~0xEF ; +if ( Frequency <291000000 ) + state->m_Regs[RF_AGC_1 ] |= StandardParams->m_RF_AGC_1_Low; +else + state->m_Regs[RF_AGC_1 ] |= StandardParams->m_RF_AGC_1_High; +CHK_ERROR (update_reg (state,RF_AGC_1 )); + + state->m_Regs[IR_MIXER_1 ] = (state->m_Regs[IR_MIXER_1 ] & ~0x0F ) | StandardParams->m_IR_MIXER_1; +CHK_ERROR (update_reg (state,IR_MIXER_1 )); + + state->m_Regs[AGC5_1 ] = (state->m_Regs[AGC5_1 ] & ~0x1F ) | StandardParams->m_AGC5_1; +CHK_ERROR (update_reg (state,AGC5_1 )); + + state->m_Regs[AGCK_1 ] = (state->m_Regs[AGCK_1 ] & ~0x0F ) | StandardParams->m_AGCK_1; +CHK_ERROR (update_reg (state,AGCK_1 )); + + state->m_Regs[PSM_1 ] = (state->m_Regs[PSM_1 ] & ~0x20 ) | StandardParams->m_PSM_1; +CHK_ERROR (update_reg (state,PSM_1 )); + + state->m_Regs[IF_FREQUENCY_1 ] = ( StandardParams->m_IFFrequency /50000 ); +CHK_ERROR (update_reg (state,IF_FREQUENCY_1 )); + +if ( state->m_isMaster && StandardParams->m_LTO_STO_immune ) + { +u8 tmp; +u8 RF_Filter_Gain; + +CHK_ERROR (read_reg (state,RF_AGC_GAIN_1 ,&tmp)); + RF_Filter_Gain = (tmp &0x30 ) >>4 ; + + state->m_Regs[RF_FILTER_1 ] = (state->m_Regs[RF_FILTER_1 ] & ~0x0C ) | (RF_Filter_Gain <<2 ); +CHK_ERROR (update_reg (state,RF_FILTER_1 )); + + state->m_Regs[RF_FILTER_1 ] |=0x10 ;// Force +CHK_ERROR (update_reg (state,RF_FILTER_1 )); + +while ( RF_Filter_Gain !=0 ) + { + RF_Filter_Gain -=1 ; + state->m_Regs[RF_FILTER_1 ] = (state->m_Regs[RF_FILTER_1 ] & ~0x0C ) | (RF_Filter_Gain <<2 ); +CHK_ERROR (update_reg (state,RF_FILTER_1 )); +msleep (10 ); + } +CHK_ERROR (status); + + state->m_Regs[RF_AGC_1 ] |=0x08 ; +CHK_ERROR (update_reg (state,RF_AGC_1 )); + } + +// --------------------------------------------------------------------------------- + + state->m_Regs[IRQ_CLEAR ] |=0x80 ;// Reset IRQ +CHK_ERROR (update_reg (state,IRQ_CLEAR )); + +CHK_ERROR (PowerOn (state)); + + state->m_Regs[RF_FREQUENCY_1 ] = ((f >>16 ) &0xFF ); + state->m_Regs[RF_FREQUENCY_2 ] = ((f >>8 ) &0xFF ); + state->m_Regs[RF_FREQUENCY_3 ] = ((f ) &0xFF ); +CHK_ERROR (update_regs (state,RF_FREQUENCY_1 ,RF_FREQUENCY_3 )); + + state->m_Regs[MSM_1 ] =0x41 ;// Tune + state->m_Regs[MSM_2 ] =0x01 ;// Start MSM +CHK_ERROR (update_regs (state,MSM_1 ,MSM_2 )); + state->m_Regs[MSM_2 ] =0x00 ; + +while (true) + { +CHK_ERROR (read_reg (state,IRQ_STATUS , &IRQ )); +if ( (IRQ &0x80 ) !=0 )break ; + Timeout -=1 ; +if (Timeout ==0 ) { + status =-1 ; +break ; + } +msleep (10 ); + } +CHK_ERROR (status); + +// --------------------------------------------------------------------------------- + +if ( state->m_isMaster && StandardParams->m_LTO_STO_immune ) + { + state->m_Regs[RF_AGC_1 ] &= ~0x08 ; +CHK_ERROR (update_reg (state,RF_AGC_1 )); + +msleep (50 ); + + state->m_Regs[RF_FILTER_1 ] &= ~0x10 ;// remove force +CHK_ERROR (update_reg (state,RF_FILTER_1 )); + } + +// --------------------------------------------------------------------------------- +// Spur reduction + +if ( Frequency <72000000 ) + { + state->m_Regs[REFERENCE ] |=0x40 ;// Set digital clock + } +else if ( Frequency <104000000 ) + { + state->m_Regs[REFERENCE ] &= ~0x40 ;// Clear digital clock + } +else if ( Frequency <120000000 ) + { + state->m_Regs[REFERENCE ] |=0x40 ;// Set digital clock + } +else + { +if ( fDelta <=8000000 ) + { +if ( fRatio &1 ) state->m_Regs[REFERENCE ] &= ~0x40 ;// Clear digital clock +else state->m_Regs[REFERENCE ] |=0x40 ;// Set digital clock + } +else + { +if ( fRatio &1 ) state->m_Regs[REFERENCE ] |=0x40 ;// Set digital clock +else state->m_Regs[REFERENCE ] &= ~0x40 ;// Clear digital clock + } + + } +CHK_ERROR (update_reg (state,REFERENCE )); + +if ( StandardParams->m_AGC1_Freeze && state->m_bEnableFreeze ) + { +u8 tmp; +int AGC1GainMin =0 ; +int nSteps =10 ; +int Step =0 ; + +CHK_ERROR (read_reg (state,AGC1_2 ,&tmp)); + +if ( (tmp &0x80 ) ==0 ) + { + state->m_Regs[AGC1_2 ] |=0x80 ;// Loop off +CHK_ERROR (update_reg (state,AGC1_2 )); + state->m_Regs[AGC1_2 ] |=0x10 ;// Force gain +CHK_ERROR (update_reg (state,AGC1_2 )); + } +// Adapt +if ( state->m_Regs[AGC1_1 ] &0x40 )// AGC1_6_15dB set + { + AGC1GainMin =6 ; + nSteps =4 ; + } +while ( Step < nSteps ) + { +int Down =0 ; +int Up =0 , i; +u8 AGC1_Gain; + + Step = Step +1 ; + +for (i =0 ; i <40 ; i +=1 ) { +CHK_ERROR (read_reg (state,AGC_DET_OUT , &tmp)); + Up += (tmp &0x02 ) ?1 :-4 ; + Down += (tmp &0x01 ) ?14 :-1 ; +msleep (1 ); + } +CHK_ERROR (status); + AGC1_Gain = (state->m_Regs[AGC1_2 ] &0x0F ); +if ( Up >=15 && AGC1_Gain !=9 ) + { + state->m_Regs[AGC1_2 ] = ( state->m_Regs[AGC1_2 ] & ~0x0F ) | (AGC1_Gain +1 ); +CHK_ERROR (update_reg (state,AGC1_2 )); + } +else if ( Down >=10 && AGC1_Gain != AGC1GainMin ) + { + state->m_Regs[AGC1_2 ] = ( state->m_Regs[AGC1_2 ] & ~0x0F ) | (AGC1_Gain -1 ); +CHK_ERROR (update_reg (state,AGC1_2 )); + } +else + { + Step = nSteps; + } + } + } +else + { + state->m_Regs[AGC1_2 ] &= ~0x10 ;// unforce gain +CHK_ERROR (update_reg (state,AGC1_2 )); + state->m_Regs[AGC1_2 ] &= ~0x80 ;// Loop on +CHK_ERROR (update_reg (state,AGC1_2 )); + } + + state->m_Standard = Standard; + state->m_Frequency = Frequency; + +if ( state->m_bPowerMeasurement ) +PowerMeasurement (state, &state->m_LastPowerLevel); + }while (0 ); + +return status; +} + +static int sleep (struct dvb_frontend * fe) +{ +struct tda_state *state = fe->tuner_priv; + +Standby (state); +return 0 ; +} + +static int init (struct dvb_frontend * fe) +{ +//struct tda_state *state = fe->tuner_priv; +return 0 ;
drivers/media/dvb-frontends/tda18212dd.c line 755
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +10
-0+} + +static int release (struct dvb_frontend * fe) +{ +kfree (fe->tuner_priv); + fe->tuner_priv =NULL ; +return 0 ; +} + +#ifndef USE_API3
Why do you need this? Both "set_params" look identical.
Quoted 170 lines
drivers/media/dvb-frontends/tda18212dd.c new file +170
-0+static int set_params (struct dvb_frontend *fe) +{ +struct tda_state *state = fe->tuner_priv; +struct dtv_frontend_properties *p = &fe->dtv_property_cache; +int status =0 ; +int Standard; +u32 bw; + + bw = (p->bandwidth_hz +999999 ) /1000000 ; + state->m_Frequency = p->frequency; +if (p->delivery_system ==SYS_DVBT || + p->delivery_system ==SYS_DVBT2 || + p->delivery_system ==SYS_ISDBT || + p->delivery_system ==SYS_DVBC2 ) { +switch (bw) { +case 6 : + Standard =HF_DVBT_6MHZ ; +break ; +case 7 : + Standard =HF_DVBT_7MHZ ; +break ; +default : +case 8 : + Standard =HF_DVBT_8MHZ ; +break ; + } + }else if (p->delivery_system ==SYS_DVBC_ANNEX_A ) { +switch (bw) { +case 6 : + Standard =HF_DVBC_6MHZ ; +break ; +case 7 : + Standard =HF_DVBC_7MHZ ; +break ; +default : +case 8 : + Standard =HF_DVBC_8MHZ ; +break ; + } + }else +return -EINVAL ; + +if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl (fe,1 ); +SetFrequency (state, state->m_Frequency, Standard); +if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl (fe,0 ); + +return status; +} +#else +static int set_params (struct dvb_frontend *fe, +struct dvb_frontend_parameters *params) +{ +struct tda_state *state = fe->tuner_priv; +int status =0 ; +int Standard; + + state->m_Frequency = params->frequency; + +if (fe->ops.info.type ==FE_OFDM ) +switch (params->u.ofdm.bandwidth) { +case BANDWIDTH_6_MHZ : + Standard =HF_DVBT_6MHZ ; +break ; +case BANDWIDTH_7_MHZ : + Standard =HF_DVBT_7MHZ ; +break ; +default : +case BANDWIDTH_8_MHZ : + Standard =HF_DVBT_8MHZ ; +break ; + } +else if (fe->ops.info.type ==FE_QAM ) { + Standard =HF_DVBC_8MHZ ; + }else +return -EINVAL ; + +if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl (fe,1 ); +SetFrequency (state, state->m_Frequency, Standard); +if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl (fe,0 ); + +return status; +} +#endif + +static int get_frequency (struct dvb_frontend *fe,u32 *frequency) +{ +struct tda_state *state = fe->tuner_priv; + + *frequency = state->IF; +return 0 ; +} + +static int get_rf_strength (struct dvb_frontend *fe,u16 *st) +{ +struct tda_state *state = fe->tuner_priv; + + *st = state->m_LastPowerLevel; +return 0 ; +} + +static int get_if (struct dvb_frontend *fe,u32 *frequency) +{ +struct tda_state *state = fe->tuner_priv; + + state->IF =0 ; +if (state->m_Standard <HF_DVBT_6MHZ || + state->m_Standard >HF_DVBC_8MHZ ) +return 0 ; + state->IF = m_StandardTable[state->m_Standard -HF_DVBT_6MHZ ].m_IFFrequency; + *frequency = state->IF; +return 0 ; +} + +static int get_bandwidth (struct dvb_frontend *fe,u32 *bandwidth) +{ +//struct tda_state *state = fe->tuner_priv; +//*bandwidth = priv->bandwidth; +return 0 ; +} + + +static struct dvb_tuner_ops tuner_ops = { + .info = { + .name ="NXP TDA18212" , + .frequency_min =47125000 , + .frequency_max =865000000 , + .frequency_step =62500 + }, + .init = init, + .sleep = sleep, + .set_params = set_params, + .release = release, + .get_frequency = get_frequency, + .get_if_frequency = get_if, + .get_bandwidth = get_bandwidth, + .get_rf_strength = get_rf_strength, +}; + +struct dvb_frontend *tda18212dd_attach (struct dvb_frontend *fe, +struct i2c_adapter *i2c,u8 adr) +{ +struct tda_state *state; +int stat; + + state =kzalloc (sizeof (struct tda_state ),GFP_KERNEL ); +if (!state) +return NULL ; + state->adr = adr; + state->i2c = i2c; +memcpy (&fe->ops.tuner_ops, &tuner_ops,sizeof (struct dvb_tuner_ops )); +init_state (state); + +if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl (fe,1 ); + stat =attach_init (state); +if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl (fe,0 ); +if (stat <0 ) { +kfree (state); +return 0 ; + } + fe->tuner_priv = state; +return fe; +} + +EXPORT_SYMBOL_GPL (tda18212dd_attach);
drivers/media/dvb-frontends/tda18212dd.c line 934
Quoted 10 lines
drivers/media/dvb-frontends/tda18212dd.c new file +9
-0+MODULE_DESCRIPTION ("TDA18212 driver" ); +MODULE_AUTHOR ("DD" ); +MODULE_LICENSE ("GPL" ); + +/* +* Local variables: +* c-basic-offset: 8 +* End: +*/
Don't add editor-specific macros.
Quoted 43 lines
drivers/media/dvb-frontends/tda18212dd.h new file +37
-0@@ -0,0 +1,37 @@ +/* +* tda18212dd.h: Driver for the TDA18212 tuner +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#ifndef _TDA18212DD_H_ +#define _TDA18212DD_H_ + +#if IS_ENABLED (CONFIG_DVB_TDA18212DD ) +struct dvb_frontend *tda18212dd_attach (struct dvb_frontend *fe, +struct i2c_adapter *i2c,u8 adr); +#else +static inline struct dvb_frontend *tda18212dd_attach (struct dvb_frontend *fe, +struct i2c_adapter *i2c,u8 adr); +{ +printk (KERN_WARNING "%s: driver disabled by Kconfig\n" , __func__); +return NULL ; +} +#endif + +#endif
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 05/12] cxd2843: Support for CXD2843ER demodulator for DVB-T/T2/C/C2
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:32:52 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 2 lines
Added support for the CXD2843ER demodulator for DVB-T/T2/C/C2 used by recent Digital Devices hardware.
The same CodingStyle issues I pointed on patch 4/12 also applies here. I also noticed that on some places, the indent is not correct. Please fix.
Let me point a few other stuff I noticed here.
Quoted 599 lines
Signed-off-by Maik Broemme <[email protected]>--- drivers/media/dvb-frontends/Kconfig | 9 + drivers/media/dvb-frontends/Makefile | 1 + drivers/media/dvb-frontends/cxd2843.c | 1647 +++++++++++++++++++++++++++++++++ drivers/media/dvb-frontends/cxd2843.h | 47 + 4 files changed, 1704 insertions(+) create mode 100644 drivers/media/dvb-frontends/cxd2843.c create mode 100644 drivers/media/dvb-frontends/cxd2843.hdrivers/media/dvb-frontends/Kconfig +9
-0@@ -74,6 +74,15 @@ config DVB_TDA18212DD Say Y when you want to support this tuner. +config DVB_CXD2843 + tristate "CXD2843ER based for DVB-T/T2/C/C2" + depends on DVB_CORE && I2C + default m if DVB_FE_CUSTOMISE + help + Sony CXD2843ER/CXD2837ER DVB-T/T2/C/C2 demodulator. + + Say Y when you want to support this frontend. + comment "DVB-S (satellite) frontends" depends on DVB_COREdrivers/media/dvb-frontends/Makefile +1
-0@@ -99,6 +99,7 @@ obj-$(CONFIG_DVB_DRXK) += drxk.o obj-$(CONFIG_DVB_TDA18271C2DD) += tda18271c2dd.o obj-$(CONFIG_DVB_STV0367DD) += stv0367dd.o obj-$(CONFIG_DVB_TDA18212DD) += tda18212dd.o +obj-$(CONFIG_DVB_CXD2843) += cxd2843.o obj-$(CONFIG_DVB_IT913X_FE) += it913x-fe.o obj-$(CONFIG_DVB_A8293) += a8293.o obj-$(CONFIG_DVB_TDA10071) += tda10071.odrivers/media/dvb-frontends/cxd2843.c new file +550
-0@@ -0,0 +1,1647 @@ +/* +* cxd2843.c: Driver for the Sony CXD2843ER DVB-T/T2/C/C2 demodulator. +* Also supports the CXD2837ER DVB-T/T2/C and the CXD2838ER +* ISDB-T demodulator. +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/init.h> +#include <linux/delay.h> +#include <linux/firmware.h> +#include <linux/i2c.h> +#include <linux/version.h> +#include <linux/mutex.h> +#include <asm/div64.h> + +#include "dvb_frontend.h" +#include "cxd2843.h" + + +enum EDemodType {CXD2843 ,CXD2837 ,CXD2838 }; +enum EDemodState { Unknown, Shutdown, Sleep, ActiveT, ActiveT2, ActiveC, ActiveC2, ActiveIT }; +enum omode {OM_NONE ,OM_DVBT ,OM_DVBT2 ,OM_DVBC ,OM_QAM_ITU_C ,OM_DVBC2 ,OM_ISDBT }; + +struct cxd_state { +struct dvb_frontend frontend; +struct i2c_adapter *i2c; +struct mutex mutex; + +u8 adrt; +u8 curbankt; + +u8 adrx; +u8 curbankx; + +enum EDemodType type; +enum EDemodState state; +enum omode omode; + +u8 IF_FS; +int ContinuousClock; +int SerialMode; +u8 SerialClockFrequency; + +u32 LockTimeout; +u32 TSLockTimeout; +u32 L1PostTimeout; +u32 DataSliceID; +int FirstTimeLock; +u32 PLPNumber; +u32 last_status; + +u32 bandwidth; +u32 bw; +}; + +static int i2c_write (struct i2c_adapter *adap,u8 adr,u8 *data,int len) +{ +struct i2c_msg msg = + {.addr = adr, .flags =0 , .buf = data, .len = len}; + +if (i2c_transfer (adap, &msg,1 ) !=1 ) { +printk ("cxd2843: i2c_write error\n" ); +return -1 ; + } +return 0 ; +} + +static int writeregs (struct cxd_state *state,u8 adr,u8 reg,u8 *regd,u16 len) +{ +u8 data[len +1 ]; + + data[0 ] = reg; +memcpy (data +1 , regd, len); +return i2c_write (state->i2c, adr, data, len +1 ); +} + +static int writereg (struct cxd_state *state,u8 adr,u8 reg,u8 dat) +{ +u8 mm[2 ] = {reg, dat}; + +return i2c_write (state->i2c, adr, mm,2 ); +} + +static int i2c_read (struct i2c_adapter *adap, +u8 adr,u8 *msg,int len,u8 *answ,int alen) +{ +struct i2c_msg msgs[2 ] = { { .addr = adr, .flags =0 , + .buf = msg, .len = len}, + { .addr = adr, .flags =I2C_M_RD , + .buf = answ, .len = alen } }; +if (i2c_transfer (adap, msgs,2 ) !=2 ) { +printk ("cxd2843: i2c_read error\n" ); +return -1 ; + } +return 0 ; +} + +static int readregs (struct cxd_state *state,u8 adr,u8 reg,u8 *val,int count) +{ +return i2c_read (state->i2c, adr, ®,1 , val, count); +} + +static int readregst_unlocked (struct cxd_state *cxd,u8 bank,u8 Address,u8 *pValue,u16 count) +{ +int status =0 ; + +if (bank !=0xFF && cxd->curbankt != bank) { + status =writereg (cxd, cxd->adrt,0 , bank); +if (status <0 ) { + cxd->curbankt =0xFF ; +return status; + } + cxd->curbankt = bank; + } + status =readregs (cxd, cxd->adrt, Address, pValue, count); +return status; +} + +static int readregst (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status; + +mutex_lock (&cxd->mutex); + status =readregst_unlocked (cxd, Bank, Address, pValue, count); +mutex_unlock (&cxd->mutex); +return status; +} + +static int readregsx_unlocked (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status =0 ; + +if (Bank !=0xFF && cxd->curbankx != Bank) { + status =writereg (cxd, cxd->adrx,0 , Bank); +if (status <0 ) { + cxd->curbankx =0xFF ; +return status; + } + cxd->curbankx = Bank; + } + status =readregs (cxd, cxd->adrx, Address, pValue, count); +return status; +} + +static int readregsx (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status; + +mutex_lock (&cxd->mutex); + status =readregsx_unlocked (cxd, Bank, Address, pValue, count); +mutex_unlock (&cxd->mutex); +return status; +} + +static int writeregsx_unlocked (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status =0 ; + +if (Bank !=0xFF && cxd->curbankx != Bank) { + status =writereg (cxd, cxd->adrx,0 , Bank); +if (status <0 ) { + cxd->curbankx =0xFF ; +return status; + } + cxd->curbankx = Bank; + } + status =writeregs (cxd, cxd->adrx, Address, pValue, count); +return status; +} + +static int writeregsx (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status; + +mutex_lock (&cxd->mutex); + status =writeregsx_unlocked (cxd, Bank, Address, pValue, count); +mutex_unlock (&cxd->mutex); +return status; +} + +static int writeregx (struct cxd_state *cxd,u8 Bank,u8 Address,u8 val) +{ +return writeregsx (cxd, Bank, Address, &val,1 ); +} + +static int writeregst_unlocked (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status =0 ; + +if (Bank !=0xFF && cxd->curbankt != Bank) { + status =writereg (cxd, cxd->adrt,0 , Bank); +if (status <0 ) { + cxd->curbankt =0xFF ; +return status; + } + cxd->curbankt = Bank; + } + status =writeregs (cxd, cxd->adrt, Address, pValue, count); +return status; +} + +static int writeregst (struct cxd_state *cxd,u8 Bank,u8 Address,u8 *pValue,u16 count) +{ +int status; + +mutex_lock (&cxd->mutex); + status =writeregst_unlocked (cxd, Bank, Address, pValue, count); +mutex_unlock (&cxd->mutex); +return status; +} + +static int writeregt (struct cxd_state *cxd,u8 Bank,u8 Address,u8 val) +{ +return writeregst (cxd, Bank, Address, &val,1 ); +} + +static int writebitsx (struct cxd_state *cxd,u8 Bank,u8 Address,u8 Value,u8 Mask) +{ +int status =0 ; +u8 tmp; + +mutex_lock (&cxd->mutex); + status =readregsx_unlocked (cxd, Bank, Address, &tmp,1 ); +if (status <0 ) +return status; + tmp = (tmp & ~Mask) | Value; + status =writeregsx_unlocked (cxd, Bank, Address, &tmp,1 ); +mutex_unlock (&cxd->mutex); +return status; +} + +static int writebitst (struct cxd_state *cxd,u8 Bank,u8 Address,u8 Value,u8 Mask) +{ +int status =0 ; +u8 Tmp =0x00 ; + +mutex_lock (&cxd->mutex); + status =readregst_unlocked (cxd, Bank, Address, &Tmp,1 ); +if (status <0 ) +return status; + Tmp = (Tmp & ~Mask) | Value; + status =writeregst_unlocked (cxd, Bank, Address, &Tmp,1 ); +mutex_unlock (&cxd->mutex); +return status; +} + +static int FreezeRegsT (struct cxd_state *cxd) +{ +mutex_lock (&cxd->mutex); +return writereg (cxd, cxd->adrt,1 ,1 ); +} + +static int UnFreezeRegsT (struct cxd_state *cxd) +{ +int status =0 ; + + status =writereg (cxd, cxd->adrt,1 ,0 ); +mutex_unlock (&cxd->mutex); +return status; +} + +static inline u32 MulDiv32 (u32 a,u32 b,u32 c) +{ +u64 tmp64; + + tmp64 = (u64 )a * (u64 )b; +do_div (tmp64, c); + +return (u32 ) tmp64; +} + +static void Active_to_Sleep (struct cxd_state *state) +{ +if (state->state <= Sleep ) +return ; + +writeregt (state,0x00 ,0xC3 ,0x01 );// Disable TS +writeregt (state,0x00 ,0x80 ,0x3F );// Enable HighZ 1 +writeregt (state,0x00 ,0x81 ,0xFF );// Enable HighZ 2 +writeregx (state,0x00 ,0x18 ,0x01 );// Disable ADC 4 +writeregt (state,0x00 ,0x43 ,0x0A );// Disable ADC 2 // This looks broken (see enable) +writeregt (state,0x00 ,0x41 ,0x0A );// Disable ADC 1 +writeregt (state,0x00 ,0x30 ,0x00 );// Disable ADC Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF level Monitor +writeregt (state,0x00 ,0x2C ,0x00 );// Disable Demod Clock + state->state = Sleep; +} + +static void ActiveT2_to_Sleep (struct cxd_state *state) +{ +if (state->state <= Sleep ) +return ; + +writeregt (state,0x00 ,0xC3 ,0x01 );// Disable TS +writeregt (state,0x00 ,0x80 ,0x3F );// Enable HighZ 1 +writeregt (state,0x00 ,0x81 ,0xFF );// Enable HighZ 2 + +writeregt (state,0x13 ,0x83 ,0x40 );// +writeregt (state,0x13 ,0x86 ,0x21 );// +writebitst (state,0x13 ,0x9E ,0x09 ,0x0F );// ... +writeregt (state,0x13 ,0x9F ,0xFB );// + +writeregx (state,0x00 ,0x18 ,0x01 );// Disable ADC 4 +writeregt (state,0x00 ,0x43 ,0x0A );// Disable ADC 2 // This looks broken (see enable) +writeregt (state,0x00 ,0x41 ,0x0A );// Disable ADC 1 +writeregt (state,0x00 ,0x30 ,0x00 );// Disable ADC Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF level Monitor +writeregt (state,0x00 ,0x2C ,0x00 );// Disable Demod Clock + state->state = Sleep; +} + +static void ActiveC2_to_Sleep (struct cxd_state *state) +{ +if (state->state <= Sleep ) +return ; + +writeregt (state,0x00 ,0xC3 ,0x01 );// Disable TS +writeregt (state,0x00 ,0x80 ,0x3F );// Enable HighZ 1 +writeregt (state,0x00 ,0x81 ,0xFF );// Enable HighZ 2 + +writeregt (state,0x20 ,0xC2 ,0x11 );// +writebitst (state,0x25 ,0x6A ,0x02 ,0x03 );// + { +static u8 data[3 ] = {0x07 ,0x61 ,0x36 }; +writeregst (state,0x25 ,0x89 ,data,sizeof (data));// + } +writebitst (state,0x25 ,0xCB ,0x05 ,0x07 );// + { +static u8 data[4 ] = {0x2E ,0xE0 ,0x2E ,0xE0 }; +writeregst (state,0x25 ,0xDC ,data,sizeof (data));// + } +writeregt (state,0x25 ,0xE2 ,0x2F );// +writeregt (state,0x25 ,0xE5 ,0x2F );// +writebitst (state,0x27 ,0x20 ,0x00 ,0x01 );// +writebitst (state,0x27 ,0x35 ,0x00 ,0x01 );// +writebitst (state,0x27 ,0xD9 ,0x19 ,0x3F );// +writebitst (state,0x2A ,0x78 ,0x01 ,0x07 );// +writeregt (state,0x2A ,0x86 ,0x08 );// +writeregt (state,0x2A ,0x88 ,0x14 );// +writebitst (state,0x2B ,0x2B ,0x00 ,0x1F );// + { +u8 data[2 ] = {0x75 ,0x75 }; +writeregst (state,0x2D ,0x24 ,data,sizeof (data)); + } + +writeregx (state,0x00 ,0x18 ,0x01 );// Disable ADC 4 +writeregt (state,0x00 ,0x43 ,0x0A );// Disable ADC 2 // This looks broken (see enable) +writeregt (state,0x00 ,0x41 ,0x0A );// Disable ADC 1 +writeregt (state,0x00 ,0x30 ,0x00 );// Disable ADC Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF level Monitor +writeregt (state,0x00 ,0x2C ,0x00 );// Disable Demod Clock + state->state = Sleep; +} + +static int ConfigureTS (struct cxd_state *state,enum EDemodState newDemodState) +{ +int status =0 ; + +///* OSERCKMODE OSERDUTYMODE OTSCKPERIOD OREG_CKSEL_TSIF */ +// { 1, 1, 8, 0 }, /* High Freq, full rate */ +// { 1, 1, 8, 1 }, /* Mid Freq, full rate */ +// { 1, 1, 8, 2 }, /* Low Freq, full rate */ +// { 2, 2, 16, 0 }, /* High Freq, half rate */ +// { 2, 2, 16, 1 }, /* Mid Freq, half rate */ +// { 2, 2, 16, 2 } /* Low Freq, half rate */ + +u8 OSERCKMODE =1 ; +u8 OSERDUTYMODE =1 ; +u8 OTSCKPERIOD =8 ; +u8 OREG_CKSEL_TSIF = state->SerialClockFrequency; + +if (state->SerialClockFrequency >=3 ) { +OSERCKMODE =2 ; +OSERDUTYMODE =2 ; +OTSCKPERIOD =16 ; +OREG_CKSEL_TSIF = state->SerialClockFrequency -3 ; + } +writebitst (state,0x00 ,0xC4 ,OSERCKMODE ,0x03 );// OSERCKMODE +writebitst (state,0x00 ,0xD1 ,OSERDUTYMODE ,0x03 );// OSERDUTYMODE +writeregt (state,0x00 ,0xD9 ,OTSCKPERIOD );// OTSCKPERIOD +writebitst (state,0x00 ,0x32 ,0x00 ,0x01 );// Disable TS IF +writebitst (state,0x00 ,0x33 ,OREG_CKSEL_TSIF ,0x03 );// OREG_CKSEL_TSIF +writebitst (state,0x00 ,0x32 ,0x01 ,0x01 );// Enable TS IF + +if (newDemodState == ActiveT) +writebitst (state,0x10 ,0x66 ,0x01 ,0x01 ); +if (newDemodState == ActiveC) +writebitst (state,0x40 ,0x66 ,0x01 ,0x01 ); + +return status; +} + +static void BandSettingT (struct cxd_state *state,u32 iffreq) +{ +u8 IF_data[3 ] = { (iffreq >>16 ) &0xff , (iffreq >>8 ) &0xff , iffreq &0xff }; + +switch (state->bw) { +case 8 : + { +static u8 TR_data[] = {0x11 ,0xF0 ,0x00 ,0x00 ,0x00 }; +static u8 CL_data[] = {0x01 ,0xE0 }; +static u8 NF_data[] = {0x01 ,0x02 }; + +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x00 ,0x07 );// System Bandwidth +writeregst (state,0x10 ,0xD9 ,CL_data,sizeof (CL_data));// core latency +writeregst (state,0x17 ,0x38 ,NF_data,sizeof (NF_data));// notch filter +break ; + } +case 7 : + { +static u8 TR_data[] = {0x14 ,0x80 ,0x00 ,0x00 ,0x00 }; +static u8 CL_data[] = {0x12 ,0xF8 }; +static u8 NF_data[] = {0x00 ,0x03 }; + +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x02 ,0x07 );// System Bandwidth +writeregst (state,0x10 ,0xD9 ,CL_data,sizeof (CL_data));// core latency +writeregst (state,0x17 ,0x38 ,NF_data,sizeof (NF_data));// notch filter +break ; + } +case 6 : + { +static u8 TR_data[] = {0x17 ,0xEA ,0xAA ,0xAA ,0xAA }; +static u8 CL_data[] = {0x1F ,0xDC }; +static u8 NF_data[] = {0x00 ,0x03 }; + +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here + +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x04 ,0x07 );// System Bandwidth +writeregst (state,0x10 ,0xD9 ,CL_data,sizeof (CL_data));// core latency +writeregst (state,0x17 ,0x38 ,NF_data,sizeof (NF_data));// notch filter +break ; + } +case 5 : + { +static u8 TR_data[] = {0x1C ,0xB3 ,0x33 ,0x33 ,0x33 }; +static u8 CL_data[] = {0x26 ,0x3C }; +static u8 NF_data[] = {0x00 ,0x03 }; + +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here + +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq + +writebitst (state,0x10 ,0xD7 ,0x06 ,0x07 );// System Bandwidth +writeregst (state,0x10 ,0xD9 ,CL_data,sizeof (CL_data));// core latency +writeregst (state,0x17 ,0x38 ,NF_data,sizeof (NF_data));// notch filter +break ; + } + } +} + +static void Sleep_to_ActiveT (struct cxd_state *state,u32 iffreq) +{ +printk ("%s\n" , __FUNCTION__); + +ConfigureTS (state, ActiveT); + +writeregx (state,0x00 ,0x17 ,0x01 );// Mode +writeregt (state,0x00 ,0x2C ,0x01 );// Demod Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF Monitor +writeregt (state,0x00 ,0x30 ,0x00 );// Enable ADC Clock +writeregt (state,0x00 ,0x41 ,0x1A );// Enable ADC1 + + { +u8 data[2 ] = {0x09 ,0x54 };// 20.5 MHz +//u8 data[2] = { 0x0A, 0xD4 }; // 41 MHz +writeregst (state,0x00 ,0x43 ,data,2 );// Enable ADC 2+3 + } +writeregx (state,0x00 ,0x18 ,0x00 );// Enable ADC 4 + +// -- till here identical to DVB-C (apart from mode) + +writebitst (state,0x10 ,0xD2 ,0x0C ,0x1F );// IF AGC Gain +writeregt (state,0x11 ,0x6A ,0x48 );// BB AGC Target Level + +writebitst (state,0x10 ,0xA5 ,0x00 ,0x01 );// ASCOT Off + +writebitst (state,0x18 ,0x36 ,0x40 ,0x07 );// Pre RS Monitoring +writebitst (state,0x18 ,0x30 ,0x01 ,0x01 );// FEC Autorecover +writebitst (state,0x18 ,0x31 ,0x01 ,0x01 );// FEC Autorecover + +writebitst (state,0x00 ,0xCE ,0x01 ,0x01 );// TSIF ONOPARITY +writebitst (state,0x00 ,0xCF ,0x01 ,0x01 );// TSIF ONOPARITY_MANUAL_ON + +BandSettingT (state, iffreq); + +writeregt (state,0x00 ,0x80 ,0x28 );// Disable HiZ Setting 1 +writeregt (state,0x00 ,0x81 ,0x00 );// Disable HiZ Setting 2 +} + +static void BandSettingT2 (struct cxd_state *state,u32 iffreq) +{ +u8 IF_data[3 ] = { (iffreq >>16 ) &0xff , (iffreq >>8 ) &0xff , iffreq &0xff }; + +switch (state->bw) { +default : +case 8 : + { +static u8 TR_data[] = {0x11 ,0xF0 ,0x00 ,0x00 ,0x00 }; +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x00 ,0x07 );// System Bandwidth + } +break ; +case 7 : + { +static u8 TR_data[] = {0x14 ,0x80 ,0x00 ,0x00 ,0x00 }; +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x02 ,0x07 );// System Bandwidth + } +break ; +case 6 : + { +static u8 TR_data[] = {0x17 ,0xEA ,0xAA ,0xAA ,0xAA }; +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x04 ,0x07 );// System Bandwidth + } +break ;
drivers/media/dvb-frontends/cxd2843.c line 560
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+case 5 : + { +static u8 TR_data[] = {0x1C ,0xB3 ,0x33 ,0x33 ,0x33 }; +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x06 ,0x07 );// System Bandwidth + } +break ; +case 1 :// 1.7 MHz
That looks weird on my eyes... it seems better to not divide the bw by 1000000, and check for 1700000 here, instead of checking for just "1" for 1.7 MHz.
Quoted 19 lines
drivers/media/dvb-frontends/cxd2843.c new file +19
-0+ { +static u8 TR_data[] = {0x58 ,0xE2 ,0xAF ,0xE0 ,0xBC }; +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here + +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq + +writebitst (state,0x10 ,0xD7 ,0x03 ,0x07 );// System Bandwidth + } +break ; + } +} + + +static void Sleep_to_ActiveT2 (struct cxd_state *state,u32 iffreq) +{ +ConfigureTS (state, ActiveT2); + +writeregx (state,0x00 ,0x17 ,0x02 );// Mode
drivers/media/dvb-frontends/cxd2843.c line 589
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+writeregt (state,0x00 ,0x2C ,0x01 );// Demod Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF Monitor +writeregt (state,0x00 ,0x30 ,0x00 );// Enable ADC Clock +writeregt (state,0x00 ,0x41 ,0x1A );// Enable ADC1 + + { +u8 data[2 ] = {0x09 ,0x54 };// 20.5 MHz +//u8 data[2] = { 0x0A, 0xD4 }; // 41 MHz +writeregst (state,0x00 ,0x43 ,data,2 );// Enable ADC 2+3 + }
Why the braces?
Quoted 495 lines
drivers/media/dvb-frontends/cxd2843.c new file +495
-0+writeregx (state,0x00 ,0x18 ,0x00 );// Enable ADC 4 + +writebitst (state,0x10 ,0xD2 ,0x0C ,0x1F );//IFAGC coarse gain +writeregt (state,0x11 ,0x6A ,0x50 );// BB AGC Target Level +writebitst (state,0x10 ,0xA5 ,0x00 ,0x01 );// ASCOT Off + +writeregt (state,0x20 ,0x8B ,0x3C );// SNR Good count +writebitst (state,0x2B ,0x76 ,0x20 ,0x70 );// Noise Gain ACQ + +writebitst (state,0x00 ,0xCE ,0x01 ,0x01 );// TSIF ONOPARITY +writebitst (state,0x00 ,0xCF ,0x01 ,0x01 );// TSIF ONOPARITY_MANUAL_ON + +writeregt (state,0x13 ,0x83 ,0x10 );// T2 Inital settings +writeregt (state,0x13 ,0x86 ,0x34 );// ... +writebitst (state,0x13 ,0x9E ,0x09 ,0x0F );// ... +writeregt (state,0x13 ,0x9F ,0xD8 );// ... + +BandSettingT2 (state, iffreq); + +writeregt (state,0x00 ,0x80 ,0x28 );// Disable HiZ Setting 1 +writeregt (state,0x00 ,0x81 ,0x00 );// Disable HiZ Setting 2 +} + + +static void BandSettingC (struct cxd_state *state,u32 iffreq) +{ +u8 data[3 ]; + data[0 ] = (iffreq >>16 ) &0xFF ; + data[1 ] = (iffreq >>8 ) &0xFF ; + data[2 ] = (iffreq ) &0xFF ; +writeregst (state,0x10 ,0xB6 , data,3 );// iffreq +} + +static void Sleep_to_ActiveC (struct cxd_state *state,u32 iffreq) +{ +ConfigureTS (state, ActiveC); + +writeregx (state,0x00 ,0x17 ,0x04 );// Mode +writeregt (state,0x00 ,0x2C ,0x01 );// Demod Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF Monitor +writeregt (state,0x00 ,0x30 ,0x00 );// Enable ADC Clock +writeregt (state,0x00 ,0x41 ,0x1A );// Enable ADC1 + + { +u8 data[2 ] = {0x09 ,0x54 };// 20.5 MHz +//u8 data[2] = { 0x0A, 0xD4 }; // 41 MHz +writeregst (state,0x00 ,0x43 ,data,2 );// Enable ADC 2+3 + } +writeregx (state,0x00 ,0x18 ,0x00 );// Enable ADC 4 + +writebitst (state,0x10 ,0xD2 ,0x09 ,0x1F );// IF AGC Gain +writeregt (state,0x11 ,0x6A ,0x48 );// BB AGC Target Level +writebitst (state,0x10 ,0xA5 ,0x00 ,0x01 );// ASCOT Off + +writebitst (state,0x40 ,0xC3 ,0x00 ,0x04 );// OREG_BNDET_EN_64 + +writebitst (state,0x00 ,0xCE ,0x01 ,0x01 );// TSIF ONOPARITY +writebitst (state,0x00 ,0xCF ,0x01 ,0x01 );// TSIF ONOPARITY_MANUAL_ON + +BandSettingC (state, iffreq); + +writeregt (state,0x00 ,0x80 ,0x28 );// Disable HiZ Setting 1 +writeregt (state,0x00 ,0x81 ,0x00 );// Disable HiZ Setting 2 +} + +static void BandSettingC2 (struct cxd_state *state,u32 iffreq) +{ +u8 IF_data[3 ] = { (iffreq >>16 ) &0xff , (iffreq >>8 ) &0xff , iffreq &0xff }; + +switch (state->bw) { +case 8 : + { +static u8 TR_data[] = {0x11 ,0xF0 ,0x00 ,0x00 ,0x00 }; +static u8 data[2 ] = {0x11 ,0x9E }; + +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here + +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq + +writebitst (state,0x10 ,0xD7 ,0x00 ,0x07 );// System Bandwidth + +writeregst (state,0x50 ,0xEC ,data,sizeof (data));// timeout +writeregt (state,0x50 ,0xEF ,0x11 ); +writeregt (state,0x50 ,0xF1 ,0x9E ); + } +break ; +case 6 : + { +static u8 TR_data[] = {0x17 ,0xEA ,0xAA ,0xAA ,0xAA }; +static u8 data[2 ] = {0x17 ,0x70 }; + +writeregst (state,0x20 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq +writebitst (state,0x10 ,0xD7 ,0x04 ,0x07 );// System Bandwidth + +writeregst (state,0x50 ,0xEC ,data,sizeof (data));// timeout +writeregt (state,0x50 ,0xEF ,0x17 ); +writeregt (state,0x50 ,0xF1 ,0x70 ); + } +break ; + } +} + +static void Sleep_to_ActiveC2 (struct cxd_state *state,u32 iffreq) +{ +ConfigureTS (state, ActiveC2); + +writeregx (state,0x00 ,0x17 ,0x05 );// Mode +writeregt (state,0x00 ,0x2C ,0x01 );// Demod Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF Monitor +writeregt (state,0x00 ,0x30 ,0x00 );// Enable ADC Clock +writeregt (state,0x00 ,0x41 ,0x1A );// Enable ADC1 + + { +u8 data[2 ] = {0x09 ,0x54 };// 20.5 MHz +//u8 data[2] = { 0x0A, 0xD4 }; // 41 MHz +writeregst (state,0x00 ,0x43 ,data,sizeof (data));// Enable ADC 2+3 + } +writeregx (state,0x00 ,0x18 ,0x00 );// Enable ADC 4 + +writebitst (state,0x10 ,0xD2 ,0x0C ,0x1F );//IFAGC coarse gain +writeregt (state,0x11 ,0x6A ,0x50 );// BB AGC Target Level +writebitst (state,0x10 ,0xA5 ,0x00 ,0x01 );// ASCOT Off + +writebitst (state,0x00 ,0xCE ,0x01 ,0x01 );// TSIF ONOPARITY +writebitst (state,0x00 ,0xCF ,0x01 ,0x01 );// TSIF ONOPARITY_MANUAL_ON + +writeregt (state,0x20 ,0xC2 ,0x00 );// +writebitst (state,0x25 ,0x6A ,0x00 ,0x03 );// + { +u8 data[3 ] = {0x0C ,0xD1 ,0x40 }; +writeregst (state,0x25 ,0x89 ,data,sizeof (data)); + } +writebitst (state,0x25 ,0xCB ,0x01 ,0x07 );// + { +u8 data[4 ] = {0x7B ,0x00 ,0x7B ,0x00 }; +writeregst (state,0x25 ,0xDC ,data,sizeof (data)); + } +writeregt (state,0x25 ,0xE2 ,0x30 );// +writeregt (state,0x25 ,0xE5 ,0x30 );// +writebitst (state,0x27 ,0x20 ,0x01 ,0x01 );// +writebitst (state,0x27 ,0x35 ,0x01 ,0x01 );// +writebitst (state,0x27 ,0xD9 ,0x18 ,0x3F );// +writebitst (state,0x2A ,0x78 ,0x00 ,0x07 );// +writeregt (state,0x2A ,0x86 ,0x20 );// +writeregt (state,0x2A ,0x88 ,0x32 );// +writebitst (state,0x2B ,0x2B ,0x10 ,0x1F );// + { +u8 data[2 ] = {0x01 ,0x01 }; +writeregst (state,0x2D ,0x24 ,data,sizeof (data)); + } + +BandSettingC2 (state, iffreq); + +writeregt (state,0x00 ,0x80 ,0x28 );// Disable HiZ Setting 1 +writeregt (state,0x00 ,0x81 ,0x00 );// Disable HiZ Setting 2 +} + + +static void BandSettingIT (struct cxd_state *state,u32 iffreq) +{ +u8 IF_data[3 ] = { (iffreq >>16 ) &0xff , (iffreq >>8 ) &0xff , iffreq &0xff }; + +switch (state->bw) { +default : +case 8 : + { +static u8 TR_data[] = {0x0F ,0x22 ,0x80 ,0x00 ,0x00 };// 20.5/41 +static u8 CL_data[] = {0x15 ,0xA8 }; + +// static u8 TR_data[] = { 0x11, 0xB8, 0x00, 0x00, 0x00 }; // 24 +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq + +writeregt (state,0x10 ,0xD7 ,0x00 );// System Bandwidth +//static u8 CL_data[] = { 0x13, 0xFC }; +writeregst (state,0x10 ,0xD9 ,CL_data,sizeof (CL_data));// core latency + } +break ; +case 7 : + { +static u8 TR_data[] = {0x11 ,0x4c ,0x00 ,0x00 ,0x00 }; +static u8 CL_data[] = {0x1B ,0x5D }; + +//static u8 TR_data[] = { 0x14, 0x40, 0x00, 0x00, 0x00 }; +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq + +writeregt (state,0x10 ,0xD7 ,0x02 );// System Bandwidth +//static u8 CL_data[] = { 0x1A, 0xFA }; +writeregst (state,0x10 ,0xD9 ,CL_data,sizeof (CL_data));// core latency + } +break ; +case 6 : + { +static u8 TR_data[] = {0x14 ,0x2E ,0x00 ,0x00 ,0x00 }; +static u8 CL_data[] = {0x1F ,0xEC }; +//static u8 TR_data[] = { 0x17, 0xA0, 0x00, 0x00, 0x00 }; +//static u8 CL_data[] = { 0x1F, 0x79 }; + +writeregst (state,0x10 ,0x9F ,TR_data,sizeof (TR_data));// Timing recovery +// Add EQ Optimisation for tuner here +writeregst (state,0x10 ,0xB6 ,IF_data,sizeof (IF_data));// iffreq + +writeregt (state,0x10 ,0xD7 ,0x04 );// System Bandwidth +writeregst (state,0x10 ,0xD9 , CL_data,sizeof (CL_data));// core latency + } +break ; + } +} + +static void Sleep_to_ActiveIT (struct cxd_state *state,u32 iffreq) +{ +static u8 data2[3 ] = {0xB9 ,0xBA ,0x63 };// 20.5/41 MHz +//static u8 data2[3] = { 0xB7,0x1B,0x00 }; // 24 MHz +static u8 TSIF_data[2 ] = {0x61 ,0x60 } ;// 20.5/41 MHz +//static u8 TSIF_data[2] = { 0x60,0x00 } ; // 24 MHz + +printk ("%s\n" , __FUNCTION__); + +ConfigureTS (state, ActiveIT); + +// writeregx(state, 0x00,0x17,0x01); // 2838 has only one Mode +writeregt (state,0x00 ,0x2C ,0x01 );// Demod Clock +writeregt (state,0x00 ,0x2F ,0x00 );// Disable RF Monitor +writeregt (state,0x00 ,0x30 ,0x00 );// Enable ADC Clock +writeregt (state,0x00 ,0x41 ,0x1A );// Enable ADC1 + + { +u8 data[2 ] = {0x09 ,0x54 };// 20.5 MHz, 24 MHz +//u8 data[2] = { 0x0A, 0xD4 }; // 41 MHz +writeregst (state,0x00 ,0x43 ,data,2 );// Enable ADC 2+3 + } +writeregx (state,0x00 ,0x18 ,0x00 );// Enable ADC 4 + +writeregst (state,0x60 ,0xA8 ,data2,sizeof (data2)); + +writeregst (state,0x10 ,0xBF ,TSIF_data,sizeof (TSIF_data)); + +writeregt (state,0x10 ,0xE2 ,0xCE );// OREG_PNC_DISABLE +writebitst (state,0x10 ,0xA5 ,0x00 ,0x01 );// ASCOT Off + +BandSettingIT (state, iffreq); + +writeregt (state,0x00 ,0x80 ,0x28 );// Disable HiZ Setting 1 +writeregt (state,0x00 ,0x81 ,0x00 );// Disable HiZ Setting 2 +} + +static void T2_SetParameters (struct cxd_state *state) +{ +u8 Profile =0x01 ;// Profile Base +u8 notT2time =12 ;// early unlock detection time + +//u8 Profile = 0x05; // Lite +//u8 notT2time = 40; + +//u8 Profile = 0x00; // Any +//u8 notT2time = 40; + + +if (state->PLPNumber !=0xffffffff ) { +writeregt (state,0x23 ,0xAF , state->PLPNumber); +writeregt (state,0x23 ,0xAD ,0x01 ); + }else { +writeregt (state,0x23 ,0xAD ,0x00 ); + } + +writebitst (state,0x2E ,0x10 , Profile,0x07 ); +writeregt (state,0x2B ,0x19 , notT2time); +} + +static void C2_ReleasePreset (struct cxd_state *state) +{ + { +static u8 data[2 ] = {0x02 ,0x80 }; +writeregst (state,0x27 ,0xF4 ,data,sizeof (data)); + } +writebitst (state,0x27 ,0x51 ,0x40 ,0xF0 ); +writebitst (state,0x27 ,0x73 ,0x07 ,0x0F ); +writebitst (state,0x27 ,0x74 ,0x19 ,0x3F ); +writebitst (state,0x27 ,0x75 ,0x19 ,0x3F ); +writebitst (state,0x27 ,0x76 ,0x19 ,0x3F ); +if (state->bw ==6 ) { +static u8 data[5 ] = {0x17 ,0xEA ,0xAA ,0xAA ,0xAA }; +writeregst (state,0x20 ,0x9F ,data,sizeof (data)); + }else { +static u8 data[5 ] = {0x11 ,0xF0 ,0x00 ,0x00 ,0x00 }; +writeregst (state,0x20 ,0x9F ,data,sizeof (data)); + } +writebitst (state,0x27 ,0xC9 ,0x07 ,0x07 ); +writebitst (state,0x20 ,0xC2 ,0x11 ,0x33 ); + { +static u8 data[10 ] = {0x16 ,0xF0 ,0x2B ,0xD8 ,0x16 ,0x16 ,0xF0 ,0x2C ,0xD8 ,0x16 }; +writeregst (state,0x2A ,0x20 ,data,sizeof (data)); + } + { +static u8 data[4 ] = {0x00 ,0x00 ,0x00 ,0x00 }; +writeregst (state,0x50 ,0x6B ,data,sizeof (data)); + } +writebitst (state,0x50 ,0x6F ,0x00 ,0x40 );// Disable Preset +} + +static void C2_DemodSetting2 (struct cxd_state *state) +{ +u8 data[6 ]; +u32 TunePosition = state->frontend.dtv_property_cache.frequency /1000 ; + +if (state->bw ==6 ) { + TunePosition = ((TunePosition *1792 ) /3 ) /1000 ; + }else { + TunePosition = (TunePosition *448 ) /1000 ; + } + TunePosition = ((TunePosition +6 ) /12 ) *12 ; + +printk ("TunePosition = %u\n" , TunePosition); + + data[0 ] = ( (TunePosition >>16 ) &0xFF ); + data[1 ] = ( (TunePosition >>8 ) &0xFF ); + data[2 ] = ( (TunePosition ) &0xFF ); + data[3 ] =0x02 ; + data[4 ] = (state->DataSliceID &0xFF ); + data[5 ] = (state->PLPNumber &0xFF ); +writeregst (state,0x50 ,0x7A , data,sizeof (data)); +writebitst (state,0x50 ,0x87 ,0x01 ,0x01 );/* Preset Clear */ +} + +static void Stop (struct cxd_state *state) +{ +writeregt (state,0x00 ,0xC3 ,0x01 );/* Disable TS */ +} + +static void ShutDown (struct cxd_state *state) +{ +switch (state->state) { +case ActiveT2: +ActiveT2_to_Sleep (state); +break ; +case ActiveC2: +ActiveC2_to_Sleep (state); +break ; +default : +Active_to_Sleep (state); +break ; + } +} + +static int gate_ctrl (struct dvb_frontend *fe,int enable) +{ +struct cxd_state *state = fe->demodulator_priv; + +return writebitsx (state,0xFF ,0x08 , enable ?0x01 :0x00 ,0x01 ); +} + +static void release (struct dvb_frontend * fe) +{ +struct cxd_state *state = fe->demodulator_priv; + +Stop (state); +ShutDown (state); +kfree (state); +} + +static int Start (struct cxd_state *state,u32 IntermediateFrequency) +{ +enum EDemodState newDemodState = Unknown; +u32 iffreq; + +if (state->state < Sleep ) { +return -EINVAL ; + } + + iffreq =MulDiv32 (IntermediateFrequency,16777216 ,41000000 ); + +switch (state->omode) { +case OM_DVBT : +if (state->type ==CXD2838 ) +return -EINVAL ; + newDemodState = ActiveT; +break ; +case OM_DVBT2 : +if (state->type ==CXD2838 ) +return -EINVAL ; + newDemodState = ActiveT2; +break ; +case OM_DVBC : +case OM_QAM_ITU_C : +if (state->type ==CXD2838 ) +return -EINVAL ; + newDemodState = ActiveC; +break ; +case OM_DVBC2 : +if (state->type !=CXD2843 ) +return -EINVAL ; + newDemodState = ActiveC2; +break ; +case OM_ISDBT : +if (state->type !=CXD2838 ) +return -EINVAL ; + newDemodState = ActiveIT; +break ; +default : +return -EINVAL ; + } + + state->LockTimeout =0 ; + state->TSLockTimeout =0 ; + state->L1PostTimeout =0 ; + state->FirstTimeLock =1 ; + +if (state->state == newDemodState ) { +writeregt (state,0x00 ,0xC3 ,0x01 );/* Disable TS Output */ +switch (newDemodState) { +case ActiveT: +writeregt (state,0x10 ,0x67 ,0x00 );/* Stick with HP ( 0x01 = LP ) */ +BandSettingT (state, iffreq); +break ; +case ActiveT2: +T2_SetParameters (state); +BandSettingT2 (state, iffreq); +break ; +case ActiveC: +BandSettingC (state, iffreq); +break ; +case ActiveC2: +BandSettingC2 (state, iffreq); +C2_ReleasePreset (state); +C2_DemodSetting2 (state); +break ; +case ActiveIT: +BandSettingIT (state, iffreq); +break ; +default : +break ; + } + }else { +if (state->state > Sleep ) { +switch (state->state) { +case ActiveT2: +ActiveT2_to_Sleep (state); +break ; +case ActiveC2: +ActiveC2_to_Sleep (state); +break ; +default : +Active_to_Sleep (state); +break ; + } + } +switch (newDemodState) { +case ActiveT: +writeregt (state,0x10 ,0x67 ,0x00 );// Stick with HP ( 0x01 = LP ) +Sleep_to_ActiveT (state, iffreq); +break ; +case ActiveT2: +T2_SetParameters (state); +Sleep_to_ActiveT2 (state, iffreq); +break ; +case ActiveC: +Sleep_to_ActiveC (state, iffreq); +break ; +case ActiveC2: +Sleep_to_ActiveC2 (state, iffreq); +C2_ReleasePreset (state); +C2_DemodSetting2 (state); +break ; +case ActiveIT: +Sleep_to_ActiveIT (state, iffreq); +break ; +default : +break ; + } + } + state->state = newDemodState; +writeregt (state,0x00 ,0xFE ,0x01 );// SW Reset +writeregt (state,0x00 ,0xC3 ,0x00 );// Enable TS Output + +return 0 ; +} + +static int set_parameters (struct dvb_frontend *fe) +{ +int stat; +struct cxd_state *state = fe->demodulator_priv; +u32 IF ; + +switch (fe->dtv_property_cache.delivery_system) { +case SYS_DVBC_ANNEX_A : + state->omode =OM_DVBC ; +break ; +case SYS_DVBC2 : + state->omode =OM_DVBC2 ;
drivers/media/dvb-frontends/cxd2843.c line 1094
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+break ; +case SYS_DVBT : + state->omode =OM_DVBT ; +break ; +case SYS_DVBT2 : + state->omode =OM_DVBT2 ; +break ; +case SYS_ISDBT : + state->omode =OM_ISDBT ; +break ;
Why don't you just do "state->omode = delivery_system" and remove this enum?
drivers/media/dvb-frontends/cxd2843.c line 1101
Quoted 7 lines
drivers/media/dvb-frontends/cxd2843.c new file +7
-0+default : +return -EINVAL ; + } +if (fe->ops.tuner_ops.set_params) + fe->ops.tuner_ops.set_params (fe); + state->bandwidth = fe->dtv_property_cache.bandwidth_hz; + state->bw = (fe->dtv_property_cache.bandwidth_hz +999999 ) /1000000 ;
Btw, that code that checks for 1.7MHz will not work, as you're actually rounding 1.7 to "2" on the above.
Quoted 66 lines
drivers/media/dvb-frontends/cxd2843.c new file +66
-0+ state->DataSliceID =0 ;//fe->dtv_property_cache.slice_id; + state->PLPNumber = fe->dtv_property_cache.stream_id; + fe->ops.tuner_ops.get_if_frequency (fe, &IF ); + stat =Start (state,IF ); +return stat; +} + + +static void init (struct cxd_state *state) +{ +u8 data[2 ] = {0x00 ,0x00 };// 20.5 MHz + + state->omode =OM_NONE ; + state->state = Unknown; + +writeregx (state,0xFF ,0x02 ,0x00 ); +msleep (4 ); +writeregx (state,0x00 ,0x10 ,0x01 ); + +writeregsx (state,0x00 ,0x13 , data,2 ); +writeregx (state,0x00 ,0x10 ,0x00 ); +msleep (2 ); + state->curbankx =0xFF ; + state->curbankt =0xFF ; + +writeregt (state,0x00 ,0x43 ,0x0A ); +writeregt (state,0x00 ,0x41 ,0x0A ); +if (state->type ==CXD2838 ) +writeregt (state,0x60 ,0x5A ,0x00 ); + +writebitst (state,0x10 ,0xCB ,0x00 ,0x40 ); +writeregt (state,0x10 ,0xCD , state->IF_FS); + +writebitst (state,0x00 ,0xC4 ,0x80 ,0x98 ); +writebitst (state,0x00 ,0xC5 ,0x00 ,0x07 ); +writebitst (state,0x00 ,0xCB ,0x00 ,0x01 ); +writebitst (state,0x00 ,0xC6 ,0x00 ,0x1D ); +writebitst (state,0x00 ,0xC8 ,0x00 ,0x1D ); +writebitst (state,0x00 ,0xC9 ,0x00 ,0x1D ); +writebitst (state,0x00 ,0x83 ,0x00 ,0x07 ); +writeregt (state,0x00 ,0x84 ,0x00 ); +writebitst (state,0x00 ,0xD3 , (state->type ==CXD2838 ) ?0x01 :0x00 ,0x01 ); +writebitst (state,0x00 ,0xDE ,0x00 ,0x01 ); + + state->state = Sleep; +} + + +static void init_state (struct cxd_state *state,struct cxd2843_cfg *cfg) +{ + state->adrt = cfg->adr; + state->adrx = cfg->adr +0x02 ; + state->curbankt =0xff ; + state->curbankx =0xff ; + +mutex_init (&state->mutex); + + state->SerialMode =1 ; + state->ContinuousClock =1 ; + state->SerialClockFrequency = + (cfg->ts_clock >=1 && cfg->ts_clock <=5 ) ? cfg->ts_clock :1 ;// 1 = fastest (82 MBit/s), 5 = slowest + state->SerialClockFrequency =1 ; + state->IF_FS =0x50 ;// IF Fullscale 0x50 = 1.4V, 0x39 = 1V, 0x28 = 0.7V +} + +static int get_tune_settings(struct dvb_frontend *fe,
drivers/media/dvb-frontends/cxd2843.c line 1177
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+ struct dvb_frontend_tune_settings *sets) +{ +switch (fe->dtv_property_cache.delivery_system) { +case SYS_DVBC_ANNEX_A : +case SYS_DVBC_ANNEX_C : +//return c_get_tune_settings(fe, sets); +default : +/* DVB-T: Use info.frequency_stepsize. */ +return -EINVAL ; + }
The above looks weird... it is jus returning -EINVAL on all cases.
Quoted 80 lines
drivers/media/dvb-frontends/cxd2843.c new file +80
-0+} + +static int read_status (struct dvb_frontend *fe,fe_status_t *status) +{ +struct cxd_state *state = fe->demodulator_priv; +u8 rdata; + + *status=0 ; +switch (state->state) { +case ActiveC: +readregst (state,0x40 ,0x88 , &rdata,1 ); +if (rdata &0x02 ) +break ; +if (rdata &0x01 ) { + *status |=0x07 ; +readregst (state,0x40 ,0x10 , &rdata,1 ); +if (rdata &0x20 ) + *status |=0x1f ; + } +break ; +case ActiveT: +readregst (state,0x10 ,0x10 , &rdata,1 ) ; +if (rdata &0x10 ) +break ; +if ((rdata &0x07 ) ==0x06 ) { + *status |=0x07 ; +if (rdata &0x20 ) + *status |=0x1f ; + } +break ; +case ActiveT2: +readregst (state,0x20 ,0x10 , &rdata,1 ); +if (rdata &0x10 ) +break ; +if ((rdata &0x07 ) ==0x06 ) { + *status |=0x07 ; +if (rdata &0x20 ) + *status |=0x08 ; + } +if (*status &0x08 ) { +readregst (state,0x22 ,0x12 , &rdata,1 ); +if (rdata &0x01 ) + *status |=0x10 ; + } +break ; +case ActiveC2: +readregst (state,0x20 ,0x10 , &rdata,1 ); +if (rdata &0x10 ) +break ; +if ((rdata &0x07 ) ==0x06 ) { + *status |=0x07 ; +if (rdata &0x20 ) + *status |=0x18 ; + } +if ((*status &0x10 ) && state->FirstTimeLock) { +u8 data; + +// Change1stTrial +readregst (state,0x28 ,0xE6 , &rdata,1 ); + data = rdata &1 ; +readregst (state,0x50 ,0x15 , &rdata,1 ); + data |= ((rdata &0x18 ) >>2 ); +//writebitst(state, 0x50,0x6F,rdata,0x07); + state->FirstTimeLock =0 ; + } +break ; +case ActiveIT: +readregst (state,0x60 ,0x10 , &rdata,1 ); +if (rdata &0x10 ) +break ; +if (rdata &0x02 ) { + *status |=0x07 ; +if (rdata &0x01 ) + *status |=0x18 ; + } +break ; +default : +break ; + } + state->last_status = *status;
drivers/media/dvb-frontends/cxd2843.c line 1267
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+return 0 ; +} + +static int read_ber (struct dvb_frontend *fe,u32 *ber) +{ +//struct cxd_state *state = fe->demodulator_priv; + + *ber =0 ; +return 0 ; +}
Just don't implement it, if you don't support.
drivers/media/dvb-frontends/cxd2843.c line 1278
Quoted 11 lines
drivers/media/dvb-frontends/cxd2843.c new file +11
-0+ +static int read_signal_strength (struct dvb_frontend *fe,u16 *strength) +{ +if (fe->ops.tuner_ops.get_rf_strength) + fe->ops.tuner_ops.get_rf_strength (fe, strength); +else + *strength =0 ; +return 0 ; +} + +static s32 Log10x100 (u32 x)
We have already code for doing log10 calculus at the dvb core. Please reuse it.
Quoted 38 lines
drivers/media/dvb-frontends/cxd2843.c new file +38
-0+{ +static u32 LookupTable[100 ] = { +101157945 ,103514217 ,105925373 ,108392691 ,110917482 , +113501082 ,116144861 ,118850223 ,121618600 ,124451461 ,// 800.5 - 809.5 +127350308 ,130316678 ,133352143 ,136458314 ,139636836 , +142889396 ,146217717 ,149623566 ,153108746 ,156675107 ,// 810.5 - 819.5 +160324539 ,164058977 ,167880402 ,171790839 ,175792361 , +179887092 ,184077200 ,188364909 ,192752491 ,197242274 ,// 820.5 - 829.5 +201836636 ,206538016 ,211348904 ,216271852 ,221309471 , +226464431 ,231739465 ,237137371 ,242661010 ,248313311 ,// 830.5 - 839.5 +254097271 ,260015956 ,266072506 ,272270131 ,278612117 , +285101827 ,291742701 ,298538262 ,305492111 ,312607937 ,// 840.5 - 849.5 +319889511 ,327340695 ,334965439 ,342767787 ,350751874 , +358921935 ,367282300 ,375837404 ,384591782 ,393550075 ,// 850.5 - 859.5 +402717034 ,412097519 ,421696503 ,431519077 ,441570447 , +451855944 ,462381021 ,473151259 ,484172368 ,495450191 ,// 860.5 - 869.5 +506990708 ,518800039 ,530884444 ,543250331 ,555904257 , +568852931 ,582103218 ,595662144 ,609536897 ,623734835 ,// 870.5 - 879.5 +638263486 ,653130553 ,668343918 ,683911647 ,699841996 , +716143410 ,732824533 ,749894209 ,767361489 ,785235635 ,// 880.5 - 889.5 +803526122 ,822242650 ,841395142 ,860993752 ,881048873 , +901571138 ,922571427 ,944060876 ,966050879 ,988553095 ,// 890.5 - 899.5 + }; +s32 y; +int i; + +if (x ==0 ) +return 0 ; + y =800 ; +if (x >=1000000000 ) { + x /=10 ; + y +=100 ; + } + +while (x <100000000 ) { + x *=10 ; + y -=100 ; + }
drivers/media/dvb-frontends/cxd2843.c line 1326
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+ i =0 ; +while (i <100 && x > LookupTable[i]) + i +=1 ; + y += i; +return y; +} + +#if 0 +static void GetPLPIds (struct cxd_state *state,u32 nValues,u8 *Values,u32 *Returned) +{
Why to comment it?
Quoted 151 lines
drivers/media/dvb-frontends/cxd2843.c new file +151
-0+u8 nPids =0 ; + + *Returned =0 ; +if (state->state != ActiveT2 ) +return ; +if (state->last_status !=0x1f ) +return ; + +FreezeRegsT (state); +readregst_unlocked (state,0x22 ,0x7F , &nPids,1 ); + + Values[0 ] = nPids; +if ( nPids >= nValues ) + nPids = nValues -1 ; + +readregst_unlocked (state,0x22 ,0x80 , &Values[1 ], nPids >128 ?128 : nPids); + +if ( nPids >128 ) +readregst_unlocked (state,0x23 ,0x10 , &Values[129 ], nPids -128 ); + + *Returned = nPids +1 ; + +UnFreezeRegsT (state); +} +#endif + +static void GetSignalToNoiseIT (struct cxd_state *state,u32 *SignalToNoise) +{ +u8 Data[2 ]; +u32 reg; + +FreezeRegsT (state); +readregst_unlocked (state,0x60 ,0x28 , Data,sizeof (Data)); +UnFreezeRegsT (state); + + reg = (Data[0 ] <<8 ) | Data[1 ]; +if (reg >51441 ) + reg =51441 ; + +if (state->bw ==8 ) { +if (reg >1143 ) + reg =1143 ; + *SignalToNoise = (Log10x100 (reg) -Log10x100 (1200 - reg)) +220 ; + }else + *SignalToNoise =Log10x100 (reg) -90 ; +} + +static void GetSignalToNoiseC2 (struct cxd_state *state,u32 *SignalToNoise) +{ +u8 Data[2 ]; +u32 reg; + +FreezeRegsT (state); +readregst_unlocked (state,0x20 ,0x28 , Data,sizeof (Data)); +UnFreezeRegsT (state); + + reg = (Data[0 ] <<8 ) | Data[1 ]; +if (reg >51441 ) + reg =51441 ; + + *SignalToNoise = (Log10x100 (reg) -Log10x100 (55000 - reg)) +384 ; +} + + +static void GetSignalToNoiseT2 (struct cxd_state *state,u32 *SignalToNoise) +{ +u8 Data[2 ]; +u32 reg; + +FreezeRegsT (state); +readregst_unlocked (state,0x20 ,0x28 , Data,sizeof (Data)); +UnFreezeRegsT (state); + + reg = (Data[0 ] <<8 ) | Data[1 ]; +if (reg >10876 ) + reg =10876 ; + + *SignalToNoise = (Log10x100 (reg) -Log10x100 (12600 - reg)) +320 ; +} + +static void GetSignalToNoiseT (struct cxd_state *state,u32 *SignalToNoise) +{ +u8 Data[2 ]; +u32 reg; + +FreezeRegsT (state); +readregst_unlocked (state,0x10 ,0x28 , Data,sizeof (Data)); +UnFreezeRegsT (state); + + reg = (Data[0 ] <<8 ) | Data[1 ]; +if (reg >4996 ) + reg =4996 ; + + *SignalToNoise = (Log10x100 (reg) -Log10x100 (5350 - reg)) +285 ; +} + +static void GetSignalToNoiseC (struct cxd_state *state,u32 *SignalToNoise) +{ +u8 Data[2 ]; +u8 Constellation =0 ; +u32 reg; + + *SignalToNoise =0 ; + +FreezeRegsT (state); +readregst_unlocked (state,0x40 ,0x19 , &Constellation,1 ); +readregst_unlocked (state,0x40 ,0x4C , Data,sizeof (Data)); +UnFreezeRegsT (state); + + reg = ((u32)(Data[0 ] &0x1F ) <<8 ) | (Data[1 ]); +if (reg ==0 ) +return ; + +switch (Constellation &0x07 ) { +case 0 :// QAM 16 +case 2 :// QAM 64 +case 4 :// QAM 256 +if (reg <126 ) + reg =126 ; + *SignalToNoise = ((439 -Log10x100 (reg)) *2134 +500 ) /1000 ; +break ; +case 1 :// QAM 32 +case 3 :// QAM 128 +if (reg <69 ) + reg =69 ; + *SignalToNoise = ((432 -Log10x100 (reg)) *2015 +500 ) /1000 ; +break ; + } +} + +static int read_snr (struct dvb_frontend *fe,u16 *snr) +{ +struct cxd_state *state = fe->demodulator_priv; +u32 SNR =0 ; + + *snr =0 ; +if (state->last_status !=0x1f ) +return 0 ; + +switch (state->state) { +case ActiveC: +GetSignalToNoiseC (state, &SNR ); +break ; +case ActiveC2: +GetSignalToNoiseC2 (state, &SNR ); +break ; +case ActiveT: +GetSignalToNoiseT (state, &SNR ); +break ; +case ActiveT2: +GetSignalToNoiseT2 (state, &SNR );
drivers/media/dvb-frontends/cxd2843.c line 1487
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+break ; +case ActiveIT: +GetSignalToNoiseIT (state, &SNR ); +break ; +default : +break ; + } + *snr =SNR ; +return 0 ; +}
Please implement it as a DVBv5 stats.
drivers/media/dvb-frontends/cxd2843.c line 1493
Quoted 6 lines
drivers/media/dvb-frontends/cxd2843.c new file +6
-0+ +static int read_ucblocks (struct dvb_frontend *fe,u32 *ucblocks) +{ + *ucblocks =0 ; +return 0 ; +}
If frontend doesn't support, just don't implement it.
Quoted 114 lines
drivers/media/dvb-frontends/cxd2843.c new file +114
-0+ +static struct dvb_frontend_ops common_ops_2843 = { + .delsys = {SYS_DVBC_ANNEX_A ,SYS_DVBT ,SYS_DVBT2 ,SYS_DVBC2 }, + .info = { + .name ="CXD2843 DVB-C/C2 DVB-T/T2" , + .frequency_stepsize =166667 ,/* DVB-T only */ + .frequency_min =47000000 ,/* DVB-T: 47125000 */ + .frequency_max =865000000 ,/* DVB-C: 862000000 */ + .symbol_rate_min =870000 , + .symbol_rate_max =11700000 , + .caps =/* DVB-C */ +FE_CAN_QAM_16 |FE_CAN_QAM_32 |FE_CAN_QAM_64 | +FE_CAN_QAM_128 |FE_CAN_QAM_256 | +FE_CAN_FEC_AUTO | +/* DVB-T */ +FE_CAN_QAM_16 |FE_CAN_QAM_64 |FE_CAN_QAM_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_TRANSMISSION_MODE_AUTO | +FE_CAN_GUARD_INTERVAL_AUTO |FE_CAN_HIERARCHY_AUTO | +FE_CAN_RECOVER |FE_CAN_MUTE_TS + }, + .release = release, + .i2c_gate_ctrl = gate_ctrl, + .set_frontend = set_parameters, + + .get_tune_settings = get_tune_settings, + .read_status = read_status, + .read_ber = read_ber, + .read_signal_strength = read_signal_strength, + .read_snr = read_snr, + .read_ucblocks = read_ucblocks, +}; + +static struct dvb_frontend_ops common_ops_2837 = { + .delsys = {SYS_DVBC_ANNEX_A ,SYS_DVBT ,SYS_DVBT2 }, + .info = { + .name ="CXD2837 DVB-C DVB-T/T2" , + .frequency_stepsize =166667 ,/* DVB-T only */ + .frequency_min =47000000 ,/* DVB-T: 47125000 */ + .frequency_max =865000000 ,/* DVB-C: 862000000 */ + .symbol_rate_min =870000 , + .symbol_rate_max =11700000 , + .caps =/* DVB-C */ +FE_CAN_QAM_16 |FE_CAN_QAM_32 |FE_CAN_QAM_64 | +FE_CAN_QAM_128 |FE_CAN_QAM_256 | +FE_CAN_FEC_AUTO | +/* DVB-T */ +FE_CAN_QAM_16 |FE_CAN_QAM_64 |FE_CAN_QAM_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_TRANSMISSION_MODE_AUTO | +FE_CAN_GUARD_INTERVAL_AUTO |FE_CAN_HIERARCHY_AUTO | +FE_CAN_RECOVER |FE_CAN_MUTE_TS + }, + .release = release, + .i2c_gate_ctrl = gate_ctrl, + .set_frontend = set_parameters, + + .get_tune_settings = get_tune_settings, + .read_status = read_status, + .read_ber = read_ber, + .read_signal_strength = read_signal_strength, + .read_snr = read_snr, + .read_ucblocks = read_ucblocks, +}; + +static struct dvb_frontend_ops common_ops_2838 = { + .delsys = {SYS_ISDBT }, + .info = { + .name ="CXD2838 ISDB-T" , + .frequency_stepsize =166667 , + .frequency_min =47000000 , + .frequency_max =865000000 , + .symbol_rate_min =870000 , + .symbol_rate_max =11700000 , + .caps =FE_CAN_QAM_16 |FE_CAN_QAM_64 |FE_CAN_QAM_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_TRANSMISSION_MODE_AUTO | +FE_CAN_GUARD_INTERVAL_AUTO |FE_CAN_HIERARCHY_AUTO | +FE_CAN_RECOVER |FE_CAN_MUTE_TS + }, + .release = release, + .i2c_gate_ctrl = gate_ctrl, + .set_frontend = set_parameters, + + .get_tune_settings = get_tune_settings, + .read_status = read_status, + .read_ber = read_ber, + .read_signal_strength = read_signal_strength, + .read_snr = read_snr, + .read_ucblocks = read_ucblocks, +}; + +static int probe (struct cxd_state *state) +{ +u8 ChipID =0x00 ; +int status; + + status =readregst (state,0x00 ,0xFD , &ChipID,1 ); + +if (status) { + status =readregsx (state,0x00 ,0xFD , &ChipID,1 ); + } +if (status) +return status; + +//printk("ChipID = %02X\n", ChipID); +switch (ChipID) { +case 0xa4 : + state->type =CXD2843 ; +memcpy (&state->frontend.ops, &common_ops_2843,sizeof (struct dvb_frontend_ops )); +break ;
drivers/media/dvb-frontends/cxd2843.c line 1617
Quoted 10 lines
drivers/media/dvb-frontends/cxd2843.c new file +10
-0+case 0xb1 : + state->type =CXD2837 ; +memcpy (&state->frontend.ops, &common_ops_2837,sizeof (struct dvb_frontend_ops )); +break ; +case 0xb0 : + state->type =CXD2838 ; +memcpy (&state->frontend.ops, &common_ops_2838,sizeof (struct dvb_frontend_ops )); +break ; +default : +return -1 ;
-1 is the wrong error code here. -ENODEV is likely the proper one.
drivers/media/dvb-frontends/cxd2843.c line 1618
Quoted 1 line
drivers/media/dvb-frontends/cxd2843.c new file +1
-0+ }
IMHO, the better is to add a printk info message, saying what chip got detected.
Quoted 82 lines
drivers/media/dvb-frontends/cxd2843.c new file +29
-0+ state->frontend.demodulator_priv = state; +return 0 ; +} + +struct dvb_frontend *cxd2843_attach (struct i2c_adapter *i2c,struct cxd2843_cfg *cfg) +{ +struct cxd_state *state =NULL ; + + state =kzalloc (sizeof (struct cxd_state ),GFP_KERNEL ); +if (!state) +return NULL ; + + state->i2c = i2c; +init_state (state, cfg); +if (probe (state) ==0 ) { +init (state); +return &state->frontend; + } +printk ("cxd2843: not found\n" ); +kfree (state); +return NULL ; +} + +MODULE_DESCRIPTION ("CXD2843/37/38 driver" ); +MODULE_AUTHOR ("Ralph Metzler, Manfred Voelkel" ); +MODULE_LICENSE ("GPL" ); + +EXPORT_SYMBOL (cxd2843_attach); +drivers/media/dvb-frontends/cxd2843.h new file +47
-0@@ -0,0 +1,47 @@ +/* +* cxd2843.h: Driver for the Sony CXD2843ER DVB-T/T2/C/C2 demodulator. +* Also supports the CXD2837ER DVB-T/T2/C and the CXD2838ER +* ISDB-T demodulator. +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#ifndef _CXD2843_H_ +#define _CXD2843_H_ + +#include <linux/types.h> +#include <linux/i2c.h> + +struct cxd2843_cfg { +u8 adr; +u32 ts_clock; +}; + +#if IS_ENABLED (CONFIG_DVB_CXD2843 ) +struct dvb_frontend *cxd2843_attach (struct i2c_adapter *i2c, +struct cxd2843_cfg *cfg); +#else +static inline struct dvb_frontend *cxd2843_attach (struct i2c_adapter *i2c, +struct cxd2843_cfg *cfg); +{ +printk (KERN_WARNING "%s: driver disabled by Kconfig\n" , __func__); +return NULL ; +} +#endif + +#endif
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 06/12] dvb-core: export dvb_usercopy and new DVB device constants
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:33:54 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 3 lines
Added
EXPORT_SYMBOL(dvb_usercopy)to allow new ddbridge driver to use it. It is questionable if I should use it in this way or not. If not I will fix it.
I don't like the idea of doing that. This likely means that ddbridge is needing to do something else. The better is to add core support for that, if pertinent, instead of moving the code to ddbridge.
Quoted 4 lines
Added two new DVB device constants
DVB_DEVICE_CIandDVB_DEVICE_MODrequired by newer ddbridge driver. Again it is questionable to use them or modify ddbridge driver.
Why those new types are needed? How those are used?
It could be needed, but then you should document them at DocBook.
It is probably better to open a separate thread to discuss those API changes in separate (DVB C2 properties and those two new types of devices).
Quoted 32 lines
Signed-off-by Maik Broemme <[email protected]>--- drivers/media/dvb-core/dvbdev.c | 1 + drivers/media/dvb-core/dvbdev.h | 2 ++ 2 files changed, 3 insertions(+)drivers/media/dvb-core/dvbdev.c +1
-0@@ -438,6 +438,7 @@ out:kfree (mbuf);return err; } +EXPORT_SYMBOL (dvb_usercopy);static int dvb_uevent (struct device *dev,struct kobj_uevent_env *env) {drivers/media/dvb-core/dvbdev.h +2
-0@@ -47,6 +47,8 @@#define DVB_DEVICE_CA 6#define DVB_DEVICE_NET 7#define DVB_DEVICE_OSD 8 +#define DVB_DEVICE_CI 9 +#define DVB_DEVICE_MOD 10#define DVB_DEFINE_MOD_OPT_ADAPTER_NR (adapter_nr) \ static short adapter_nr[] = \
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 07/12] ddbridge: Updated ddbridge registers
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:35:45 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 11 lines
Updated ddbridge registers:
- Added GPIO and MDIO registers
- Added Clock Generator (Sil598 @0xAAI2c)
- Added DAC (AD9781/AD9783 SPI)
- Added Temperature Monitor (2x LM75A @ 0x90,0x92 I2c)
- Added CI Interface (only CI-Bridge)
- Added output control registers
- Added modulator channels
- Removed unneded defines (might be added later again if needed)
Quoted 1 line
Signed-off-by Maik Broemme <[email protected]>
You should be sure that this change won't break compilation and/or the driver for the already supported devices. If this is not the case, then this patch is ok.
Quoted 320 lines
--- drivers/media/pci/ddbridge/ddbridge-regs.h | 273 ++++++++++++++++++----------- 1 file changed, 168 insertions(+), 105 deletions(-)drivers/media/pci/ddbridge/ddbridge-regs.h +168
-105@@ -1,47 +1,53 @@/* -* ddbridge-regs.h: Digital Devices PCIe bridge driver +* ddbridge-regs.h: Digital Devices PCIe bridge driver * -* Copyright (C) 2010-2011 Digital Devices GmbH +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> * -* This program is free software; you can redistribute it and/or -* modify it under the terms of the GNU General Public License -* version 2 only, as published by the Free Software Foundation. +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. * +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. * -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* -* You should have received a copy of the GNU General Public License -* along with this program; if not, write to the Free Software -* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -* 02110-1301, USA -* Or, point your browser to http://www.gnu.org/copyleft/gpl.html +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA */ -/* DD-DVBBridgeV1.h 273 2010-09-17 05:03:16Z manfred */ +#ifndef _DDBRIDGE_REGS_H_ +#define _DDBRIDGE_REGS_H_/* Register Definitions */ +#define CUR_REGISTERMAP_VERSION 0x10003 +#define CUR_REGISTERMAP_VERSION_CI 0x10000 +#define CUR_REGISTERMAP_VERSION_MOD 0x10000 -#define CUR_REGISTERMAP_VERSION 0x10000 - -#define HARDWARE_VERSION 0x00 -#define REGISTERMAP_VERSION 0x04 +#define HARDWARE_VERSION 0x00 +#define REGISTERMAP_VERSION 0x04 -/* ------------------------------------------------------------------------- */ /* SPI Controller */ +#define SPI_CONTROL 0x10 +#define SPI_DATA 0x14 -#define SPI_CONTROL 0x10 -#define SPI_DATA 0x14 +/* GPIO */ +#define GPIO_OUTPUT 0x20 +#define GPIO_DIRECTION 0x28 -/* ------------------------------------------------------------------------- */ +/* MDIO */ +#define MDIO_CTRL 0x20 +#define MDIO_ADR 0x24 +#define MDIO_REG 0x28 +#define MDIO_VAL 0x2C -/* Interrupt controller */ -/* How many MSI's are available depends on HW (Min 2 max 8) */ -/* How many are usable also depends on Host platform */ +/* How many MSI's are available depends on HW (Min 2 max 8) +How many are usable also depends on Host platform */ +/* Interrupt controller */ #define INTERRUPT_BASE (0x40)#define INTERRUPT_ENABLE (INTERRUPT_BASE + 0x00)@@ -57,95 +63,152 @@#define INTERRUPT_STATUS (INTERRUPT_BASE + 0x20)#define INTERRUPT_ACK (INTERRUPT_BASE + 0x20) -#define INTMASK_I2C1 (0x00000001) -#define INTMASK_I2C2 (0x00000002) -#define INTMASK_I2C3 (0x00000004) -#define INTMASK_I2C4 (0x00000008) - -#define INTMASK_CIRQ1 (0x00000010) -#define INTMASK_CIRQ2 (0x00000020) -#define INTMASK_CIRQ3 (0x00000040) -#define INTMASK_CIRQ4 (0x00000080) - -#define INTMASK_TSINPUT1 (0x00000100) -#define INTMASK_TSINPUT2 (0x00000200) -#define INTMASK_TSINPUT3 (0x00000400) -#define INTMASK_TSINPUT4 (0x00000800) -#define INTMASK_TSINPUT5 (0x00001000) -#define INTMASK_TSINPUT6 (0x00002000) -#define INTMASK_TSINPUT7 (0x00004000) -#define INTMASK_TSINPUT8 (0x00008000) - -#define INTMASK_TSOUTPUT1 (0x00010000) -#define INTMASK_TSOUTPUT2 (0x00020000) -#define INTMASK_TSOUTPUT3 (0x00040000) -#define INTMASK_TSOUTPUT4 (0x00080000) - -/* ------------------------------------------------------------------------- */ -/* I2C Master Controller */ - -#define I2C_BASE (0x80)/* Byte offset */ - -#define I2C_COMMAND (0x00) -#define I2C_TIMING (0x04) -#define I2C_TASKLENGTH (0x08)/* High read, low write */ -#define I2C_TASKADDRESS (0x0C)/* High read, low write */ +/* Clock Generator (Sil598 @ 0xAA I2c) */ +#define CLOCKGEN_BASE (0x80) +#define CLOCKGEN_CONTROL (CLOCKGEN_BASE + 0x00) +#define CLOCKGEN_INDEX (CLOCKGEN_BASE + 0x04) +#define CLOCKGEN_WRITEDATA (CLOCKGEN_BASE + 0x08) +#define CLOCKGEN_READDATA (CLOCKGEN_BASE + 0x0C) -#define I2C_MONITOR (0x1C) +/* DAC (AD9781/AD9783 SPI) */ +#define DAC_BASE (0x090) +#define DAC_CONTROL (DAC_BASE) +#define DAC_WRITE_DATA (DAC_BASE+4) +#define DAC_READ_DATA (DAC_BASE+8) -#define I2C_BASE_1 (I2C_BASE + 0x00) -#define I2C_BASE_2 (I2C_BASE + 0x20) -#define I2C_BASE_3 (I2C_BASE + 0x40) -#define I2C_BASE_4 (I2C_BASE + 0x60) +#define DAC_CONTROL_STARTIO (0x100) +#define DAC_CONTROL_RESET (0x200) -#define I2C_BASE_N (i) (I2C_BASE + (i) * 0x20) +/* Temperature Monitor (2x LM75A @ 0x90,0x92 I2c) */ +#define TEMPMON_BASE (0xA0) +#define TEMPMON_CONTROL (TEMPMON_BASE + 0x00) +#define TEMPMON_SENSOR1 (TEMPMON_BASE + 0x08) // SHORT Temperature in °C x 256 +#define TEMPMON_SENSOR2 (TEMPMON_BASE + 0x0C) // SHORT Temperature in °C x 256 -#define I2C_TASKMEM_BASE (0x1000)/* Byte offset */ -#define I2C_TASKMEM_SIZE (0x1000) - -#define I2C_SPEED_400 (0x04030404) -#define I2C_SPEED_200 (0x09080909) -#define I2C_SPEED_154 (0x0C0B0C0C) -#define I2C_SPEED_100 (0x13121313) -#define I2C_SPEED_77 (0x19181919) -#define I2C_SPEED_50 (0x27262727) - - -/* ------------------------------------------------------------------------- */ -/* DMA Controller */ - -#define DMA_BASE_WRITE (0x100) -#define DMA_BASE_READ (0x140) +/* I2C Master Controller */ +#define I2C_BASE (0x80)/* Byte offset */ -#define DMA_CONTROL (0x00)/* 64 */ -#define DMA_ERROR (0x04)/* 65 ( only read instance ) */ +#define I2C_COMMAND (0x00) +#define I2C_TIMING (0x04) +#define I2C_TASKLENGTH (0x08)/* High read, low write */ +#define I2C_TASKADDRESS (0x0C)/* High read, low write */ +#define I2C_TASKMEM_BASE (0x1000)/* Byte offset */ +#define I2C_TASKMEM_SIZE (0x0800) -#define DMA_DIAG_CONTROL (0x1C)/* 71 */ -#define DMA_DIAG_PACKETCOUNTER_LOW (0x20)/* 72 */ -#define DMA_DIAG_PACKETCOUNTER_HIGH (0x24)/* 73 */ -#define DMA_DIAG_TIMECOUNTER_LOW (0x28)/* 74 */ -#define DMA_DIAG_TIMECOUNTER_HIGH (0x2C)/* 75 */ -#define DMA_DIAG_RECHECKCOUNTER (0x30)/* 76 ( Split completions on read ) */ -#define DMA_DIAG_WAITTIMEOUTINIT (0x34)/* 77 */ -#define DMA_DIAG_WAITOVERFLOWCOUNTER (0x38)/* 78 */ -#define DMA_DIAG_WAITCOUNTER (0x3C)/* 79 */ +#define I2C_SPEED_400 (0x04030404) +#define I2C_SPEED_100 (0x13121313) -/* ------------------------------------------------------------------------- */ -/* DMA Buffer */ +/* DMA Controller */ +#define DMA_BASE_WRITE (0x100) +#define DMA_BASE_READ (0x140) +/* DMA Buffer */ #define TS_INPUT_BASE (0x200) -#define TS_INPUT_CONTROL (i) (TS_INPUT_BASE + (i) * 16 + 0x00) +#define TS_INPUT_CONTROL (i) (TS_INPUT_BASE + (i) * 0x10 + 0x00) +#define TS_INPUT_CONTROL2 (i) (TS_INPUT_BASE + (i) * 0x10 + 0x04) -#define TS_OUTPUT_BASE (0x280) -#define TS_OUTPUT_CONTROL (i) (TS_OUTPUT_BASE + (i) * 16 + 0x00) +#define TS_OUTPUT_BASE (0x280) +#define TS_OUTPUT_CONTROL (i) (TS_OUTPUT_BASE + (i) * 0x10 + 0x00) +#define TS_OUTPUT_CONTROL2 (i) (TS_OUTPUT_BASE + (i) * 0x10 + 0x04)#define DMA_BUFFER_BASE (0x300) - -#define DMA_BUFFER_CONTROL (i) (DMA_BUFFER_BASE + (i) * 16 + 0x00) -#define DMA_BUFFER_ACK (i) (DMA_BUFFER_BASE + (i) * 16 + 0x04) -#define DMA_BUFFER_CURRENT (i) (DMA_BUFFER_BASE + (i) * 16 + 0x08) -#define DMA_BUFFER_SIZE (i) (DMA_BUFFER_BASE + (i) * 16 + 0x0c) +#define DMA_BUFFER_CONTROL (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x00) +#define DMA_BUFFER_ACK (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x04) +#define DMA_BUFFER_CURRENT (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x08) +#define DMA_BUFFER_SIZE (i) (DMA_BUFFER_BASE + (i) * 0x10 + 0x0c)#define DMA_BASE_ADDRESS_TABLE (0x2000) -#define DMA_BASE_ADDRESS_TABLE_ENTRIES (512) +/* CI Interface (only CI-Bridge) */ +#define CI_BASE (0x400) +#define CI_CONTROL (i) (CI_BASE + (i) * 32 + 0x00) + +#define CI_DO_ATTRIBUTE_RW (i) (CI_BASE + (i) * 32 + 0x04) +#define CI_DO_IO_RW (i) (CI_BASE + (i) * 32 + 0x08) +#define CI_READDATA (i) (CI_BASE + (i) * 32 + 0x0c) +#define CI_DO_READ_ATTRIBUTES (i) (CI_BASE + (i) * 32 + 0x10) + +#define CI_RESET_CAM (0x00000001) +#define CI_POWER_ON (0x00000002) +#define CI_ENABLE (0x00000004) +#define CI_BYPASS_DISABLE (0x00000010) + +#define CI_CAM_READY (0x00010000) +#define CI_CAM_DETECT (0x00020000) +#define CI_READY (0x80000000) + +#define CI_READ_CMD (0x40000000) +#define CI_WRITE_CMD (0x80000000) + +#define CI_BUFFER_BASE (0x3000) +#define CI_BUFFER_SIZE (0x0800) + +#define CI_BUFFER (i) (CI_BUFFER_BASE + (i) * CI_BUFFER_SIZE ) + +#define VCO1_BASE (0xC0) +#define VCO1_CONTROL (VCO1_BASE + 0x00) +#define VCO1_DATA (VCO1_BASE + 0x04) // 24 Bit +#define VCO1_CONTROL_WRITE (0x00000001) // 1 = Trigger write, resets when done +#define VCO1_CONTROL_CE (0x00000002) // 0 = Put VCO into power down + +#define VCO2_BASE (0xC8) +#define VCO2_CONTROL (VCO2_BASE + 0x00) +#define VCO2_DATA (VCO2_BASE + 0x04) // 24 Bit +#define VCO2_CONTROL_WRITE (0x00000001) // 1 = Trigger write, resets when done +#define VCO2_CONTROL_CE (0x00000002) // 0 = Put VCO into power down + +#define VCO3_BASE (0xD0) +#define VCO3_CONTROL (VCO3_BASE + 0x00) +#define VCO3_DATA (VCO3_BASE + 0x04) // 32 Bit +#define VCO3_CONTROL_WRITE (0x00000001) // 1 = Trigger write, resets when done +#define VCO3_CONTROL_CE (0x00000002) // 0 = Put VCO into power down + +#define RF_ATTENUATOR (0xD8) + +/* Output control */ +#define IQOUTPUT_BASE (0x240) +#define IQOUTPUT_CONTROL (IQOUTPUT_BASE + 0x00) +#define IQOUTPUT_CONTROL2 (IQOUTPUT_BASE + 0x04) +#define IQOUTPUT_POSTSCALER (IQOUTPUT_BASE + 0x0C) +#define IQOUTPUT_PRESCALER (IQOUTPUT_BASE + 0x10) + +#define IQOUTPUT_EQUALIZER_0 (IQOUTPUT_BASE + 0x14) + +#define IQOUTPUT_CONTROL_RESET (0x00000001) +#define IQOUTPUT_CONTROL_ENABLE (0x00000002) +#define IQOUTPUT_CONTROL_BYPASS_EQUALIZER (0x00000010) + +#define MODULATOR_BASE (0x200) +#define MODULATOR_CONTROL (MODULATOR_BASE) +#define MODULATOR_IQTABLE_END (MODULATOR_BASE+4) +#define MODULATOR_IQTABLE_INDEX (MODULATOR_BASE+8) +#define MODULATOR_IQTABLE_DATA (MODULATOR_BASE+12) + +#define MODULATOR_IQTABLE_INDEX_IQ_MASK ( 0x00008000 ) +#define MODULATOR_IQTABLE_INDEX_SEL_I ( 0x00000000 ) +#define MODULATOR_IQTABLE_INDEX_SEL_Q ( MODULATOR_IQTABLE_INDEX_IQ_MASK ) + +/* Modulator Channels */ +#define CHANNEL_BASE (0x400) +#define CHANNEL_CONTROL (i) (CHANNEL_BASE + (i) * 64 + 0x00) +#define CHANNEL_SETTINGS (i) (CHANNEL_BASE + (i) * 64 + 0x04) +#define CHANNEL_RATE_INCR (i) (CHANNEL_BASE + (i) * 64 + 0x0C) +#define CHANNEL_PCR_ADJUST_OUTL (i) (CHANNEL_BASE + (i) * 64 + 0x10) +#define CHANNEL_PCR_ADJUST_OUTH (i) (CHANNEL_BASE + (i) * 64 + 0x14) +#define CHANNEL_PCR_ADJUST_INL (i) (CHANNEL_BASE + (i) * 64 + 0x18) +#define CHANNEL_PCR_ADJUST_INH (i) (CHANNEL_BASE + (i) * 64 + 0x1C) +#define CHANNEL_PCR_ADJUST_ACCUL (i) (CHANNEL_BASE + (i) * 64 + 0x20) +#define CHANNEL_PCR_ADJUST_ACCUH (i) (CHANNEL_BASE + (i) * 64 + 0x24) +#define CHANNEL_PKT_COUNT_OUT (i) (CHANNEL_BASE + (i) * 64 + 0x28) +#define CHANNEL_PKT_COUNT_IN (i) (CHANNEL_BASE + (i) * 64 + 0x2C) + +#define CHANNEL_CONTROL_RESET (0x00000001) +#define CHANNEL_CONTROL_ENABLE_DVB (0x00000002) +#define CHANNEL_CONTROL_ENABLE_IQ (0x00000004) +#define CHANNEL_CONTROL_ENABLE_SOURCE (0x00000008) +#define CHANNEL_CONTROL_ENABLE_PCRADJUST (0x00000010) +#define CHANNEL_CONTROL_FREEZE_STATUS (0x00000100) + +#define CHANNEL_CONTROL_BUSY (0x01000000) + +#endif
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 08/12] ddbridge: Moved i2c interfaces into separate file
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:40:15 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 5 lines
Moved i2c interfaces from
ddbridge-core.cinto separate file.Signed-off-by Maik Broemme <[email protected]>--- drivers/media/pci/ddbridge/ddbridge-i2c.c | 239 ++++++++++++++++++++++++++++++
Shouldn't you also be deleting it from ddbridge-core.c and updating the Makefile?
Btw, please do the pure code move in one patch, and, on a next patch, do the changes you need. That helps reviewers to check what actually changed between the two versions.
Again, I won't repeat myself with regards to CodingStyle.
Quoted 222 lines
1 file changed, 239 insertions(+) create mode 100644 drivers/media/pci/ddbridge/ddbridge-i2c.cdrivers/media/pci/ddbridge/ddbridge-i2c.c new file +213
-0@@ -0,0 +1,239 @@ +/* +* ddbridge-i2c.c: Digital Devices bridge i2c driver +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include "ddbridge.h" +#include "ddbridge-regs.h" + +static int i2c_cmd (struct ddb_i2c *i2c,u32 adr,u32 cmd) +{ +struct ddb *dev = i2c->dev; +int stat; +u32 val; +u32 istat; + +// i2c->done = 0; +ddbwritel (dev, (adr <<9 ) | cmd, i2c->regs +I2C_COMMAND ); + +// TODO: fix timeout issue. +// stat = wait_event_timeout(i2c->wq, i2c->done == 1, HZ); + stat =wait_for_completion_timeout (&i2c->completion,HZ ); +if (stat <=0 ) { +printk (KERN_ERR "DDBridge I2C timeout, card %d, port %d\n" , + dev->nr, i2c->nr); + istat =ddbreadl (dev,INTERRUPT_STATUS ); +printk (KERN_ERR "DDBridge IRS %08x\n" , istat); +ddbwritel (dev, istat,INTERRUPT_ACK ); +return -EIO ; + } + val =ddbreadl (dev, i2c->regs +I2C_COMMAND ); +if (val &0x70000 ) +return -EIO ; +return 0 ; +} + +static int i2c_master_xfer (struct i2c_adapter *adapter, +struct i2c_msg msg[],int num) +{ +struct ddb_i2c *i2c = (struct ddb_i2c *)i2c_get_adapdata (adapter); +struct ddb *dev = i2c->dev; +u8 addr =0 ; + +if (num) + addr = msg[0 ].addr; +if (num ==2 && msg[1 ].flags &I2C_M_RD && + !(msg[0 ].flags &I2C_M_RD )) { +memcpy_toio (dev->regs +I2C_TASKMEM_BASE + i2c->wbuf, + msg[0 ].buf, msg[0 ].len); +ddbwritel (dev, msg[0 ].len|(msg[1 ].len <<16 ), + i2c->regs +I2C_TASKLENGTH ); +if (!i2c_cmd (i2c, addr,1 )) { +memcpy_fromio (msg[1 ].buf, + dev->regs +I2C_TASKMEM_BASE + i2c->rbuf, + msg[1 ].len); +return num; + } + } +if (num ==1 && !(msg[0 ].flags &I2C_M_RD )) { +ddbcpyto (dev,I2C_TASKMEM_BASE + i2c->wbuf, + msg[0 ].buf, msg[0 ].len); +ddbwritel (dev, msg[0 ].len, i2c->regs +I2C_TASKLENGTH ); +if (!i2c_cmd (i2c, addr,2 )) { +return num; + } + } +if (num ==1 && (msg[0 ].flags &I2C_M_RD )) { +ddbwritel (dev, msg[0 ].len <<16 , i2c->regs +I2C_TASKLENGTH ); +if (!i2c_cmd (i2c, addr,3 )) { +ddbcpyfrom (dev, msg[0 ].buf, +I2C_TASKMEM_BASE + i2c->rbuf, msg[0 ].len); +return num; + } + } +return -EIO ; +} + +static u32 i2c_functionality (struct i2c_adapter *adap) +{ +return I2C_FUNC_SMBUS_EMUL ; +} + +static void i2c_handler (unsigned long priv) +{ +struct ddb_i2c *i2c = (struct ddb_i2c *) priv; + +complete (&i2c->completion); +} + +static struct i2c_algorithm i2c_algo = { + .master_xfer = i2c_master_xfer, + .functionality = i2c_functionality, +}; + +int ddb_i2c_write (struct i2c_adapter *adap,u8 adr,u8 *data,int len) +{ +struct i2c_msg msg = {.addr = adr, .flags =0 , .buf = data, .len = len}; + +return (i2c_transfer (adap, &msg,1 ) ==1 ) ?0 :-1 ; +} + +int ddb_i2c_read (struct i2c_adapter *adapter,u8 adr,u8 *val) +{ +struct i2c_msg msgs[1 ] = {{.addr = adr, .flags =I2C_M_RD , + .buf = val, .len =1 } }; +return (i2c_transfer (adapter, msgs,1 ) ==1 ) ?0 :-1 ; +} + +int ddb_i2c_read_regs (struct i2c_adapter *adapter, +u8 adr,u8 reg,u8 *val,u8 len) +{ +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = ®, .len =1 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len = len } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_read_regs16 (struct i2c_adapter *adapter, +u8 adr,u16 reg,u8 *val,u8 len) +{ +u8 reg16[2 ] = { reg >>8 , reg }; +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = reg16, .len =2 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len = len } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_read_reg (struct i2c_adapter *adapter,u8 adr,u8 reg,u8 *val) +{ +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = ®, .len =1 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len =1 } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_read_reg16 (struct i2c_adapter *adapter,u8 adr, +u16 reg,u8 *val) +{ +u8 msg[2 ] = {reg >>8 , reg &0xff }; +struct i2c_msg msgs[2 ] = {{.addr = adr, .flags =0 , + .buf = msg, .len =2 }, + {.addr = adr, .flags =I2C_M_RD , + .buf = val, .len =1 } }; +return (i2c_transfer (adapter, msgs,2 ) ==2 ) ?0 :-1 ; +} + +int ddb_i2c_write_reg16 (struct i2c_adapter *adap,u8 adr, +u16 reg,u8 val) +{ +u8 msg[3 ] = {reg >>8 , reg &0xff , val}; + +return ddb_i2c_write (adap, adr, msg,3 ); +} + +int ddb_i2c_write_reg (struct i2c_adapter *adap,u8 adr, +u8 reg,u8 val) +{ +u8 msg[2 ] = {reg, val}; + +return ddb_i2c_write (adap, adr, msg,2 ); +} + +void ddb_i2c_release (struct ddb *dev) +{ +int i; +struct ddb_i2c *i2c; +struct i2c_adapter *adap; + +for (i =0 ; i < dev->info->i2c_num; i++) { + i2c = &dev->i2c[i]; + adap = &i2c->adap; +i2c_del_adapter (adap); + } +} + +int ddb_i2c_init (struct ddb *dev) +{ +int i, j, stat =0 ; +struct ddb_i2c *i2c; +struct i2c_adapter *adap; + +for (i =0 ; i < dev->info->i2c_num; i++) { + i2c = &dev->i2c[i]; + dev->handler[i] = i2c_handler; + dev->handler_data[i] = (unsigned long ) i2c; + i2c->dev = dev; + i2c->nr = i; + i2c->wbuf = i * (I2C_TASKMEM_SIZE /4 ); + i2c->rbuf = i2c->wbuf + (I2C_TASKMEM_SIZE /8 ); + i2c->regs =0x80 + i *0x20 ; +ddbwritel (dev,I2C_SPEED_100 , i2c->regs +I2C_TIMING ); +ddbwritel (dev, (i2c->rbuf <<16 ) | i2c->wbuf, + i2c->regs +I2C_TASKADDRESS ); +// init_waitqueue_head(&i2c->wq); +init_completion (&i2c->completion);
drivers/media/pci/ddbridge/ddbridge-i2c.c line 223
Quoted 10 lines
drivers/media/pci/ddbridge/ddbridge-i2c.c new file +10
-0+ + adap = &i2c->adap; +i2c_set_adapdata (adap, i2c); +#ifdef I2C_ADAP_CLASS_TV_DIGITAL + adap->class =I2C_ADAP_CLASS_TV_DIGITAL |I2C_CLASS_TV_ANALOG ; +#else +#ifdef I2C_CLASS_TV_ANALOG + adap->class =I2C_CLASS_TV_ANALOG ; +#endif +#endif
FYI, the usage of adap->class is long gone. You can just remove the above on the second patch (the one after the moving code, that does other changes).
Quoted 16 lines
drivers/media/pci/ddbridge/ddbridge-i2c.c new file +16
-0+strcpy (adap->name,"ddbridge" ); + adap->algo = &i2c_algo; + adap->algo_data = (void *)i2c; + adap->dev.parent = dev->dev; + stat =i2c_add_adapter (adap); +if (stat) +break ; + } +if (stat) +for (j =0 ; j < i; j++) { + i2c = &dev->i2c[j]; + adap = &i2c->adap; +i2c_del_adapter (adap); + } +return stat; +}
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 09/12] ddbridge: Support for the Digital Devices Resi DVB-C Modulator card
In reply to Maik BroemmeEm Sun, 3 Nov 2013 01:41:38 +0100
Maik Broemme <[email protected]> escreveu:
Quoted 1 line
Added support for the Digital Devices Resi DVB-C Modulator card.
If I got this right, this driver provides functionality to modulate a DVB signal, right?
This driver will likely require more discussions, as it is a modulator driver, with is new at the subsystem. So, we should discuss about the API used here.
Btw, it is not clear what kind of delivery system this modulator is generating signals, nor the API provides enough control over all delivery system properties.
I'm wandering how much of this code is generic enough to be part of a DVB modulator core.
Quoted 119 lines
Signed-off-by Maik Broemme <[email protected]>--- drivers/media/pci/ddbridge/ddbridge-mod.c | 1033 +++++++++++++++++++++++++++++ 1 file changed, 1033 insertions(+) create mode 100644 drivers/media/pci/ddbridge/ddbridge-mod.cdrivers/media/pci/ddbridge/ddbridge-mod.c new file +106
-0@@ -0,0 +1,1033 @@ +/* +* ddbridge-mod.c: Digital Devices DVB modulator driver +* +* Copyright (C) 2010-2013 Digital Devices GmbH +* Copyright (C) 2013 Maik Broemme <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* version 2 only, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +* 02110-1301, USA +*/ + +#include "ddbridge.h" +#include "ddbridge-regs.h" + +inline s64 ConvertPCR (s64 a) +{ +s32 ext; +s64 b; + + b =div_s64_rem (a,300 <<22 , &ext); + +return (b <<31 ) | ext; + +} + +inline s64 NegConvertPCR (s64 a) +{ +s32 ext; +s64 b; + + b = -div_s64_rem (a,300 <<22 , &ext); + +if ( ext !=0 ) { + ext = (300 <<22 ) - ext; + b -=1 ; + } +return (b <<31 ) | ext; +} + +inline s64 RoundPCR (s64 a) +{ +s64 b = a + (HW_LSB_MASK >>1 ); +return b & ~(HW_LSB_MASK -1 ); +} + +inline s64 RoundPCRUp (s64 a) +{ +s64 b = a + (HW_LSB_MASK -1 ); +return b & ~(HW_LSB_MASK -1 ); +} + +inline s64 RoundPCRDown (s64 a) +{ +return a & ~(HW_LSB_MASK -1 ); +} + +static int mod_busy (struct ddb *dev,int chan) +{ +u32 creg; + +while (1 ) { + creg =ddbreadl (dev,CHANNEL_CONTROL (chan)); +if (creg ==0xffffffff ) +return -EFAULT ; +if ((creg &CHANNEL_CONTROL_BUSY ) ==0 ) +break ; + } +return 0 ; +} + +void ddbridge_mod_output_stop (struct ddb_output *output) +{ +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + + mod->State =CM_IDLE ; + mod->Control =0 ; +ddbwritel (dev,0 ,CHANNEL_CONTROL (output->nr)); + +mod_busy (dev, output->nr); +printk ("mod_output_stop %d.%d\n" , dev->nr, output->nr); +} + +static void mod_set_incs (struct ddb_output *output) +{ +s64 pcr; +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + + pcr =ConvertPCR (mod->PCRIncrement); +ddbwritel (dev, pcr &0xffffffff , +CHANNEL_PCR_ADJUST_OUTL (output->nr)); +ddbwritel (dev, (pcr >>32 ) &0xffffffff , +CHANNEL_PCR_ADJUST_OUTH (output->nr)); +mod_busy (dev, output->nr); +
drivers/media/pci/ddbridge/ddbridge-mod.c line 116
Quoted 10 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +10
-0+ pcr =NegConvertPCR (mod->PCRDecrement); +ddbwritel (dev, pcr &0xffffffff , +CHANNEL_PCR_ADJUST_INL (output->nr)); +ddbwritel (dev, (pcr >>32 ) &0xffffffff , +CHANNEL_PCR_ADJUST_INH (output->nr)); +mod_busy (dev, output->nr); + +} + +static u32 qamtab[6 ] = {0x000 ,0x600 ,0x601 ,0x602 ,0x903 ,0x604 };
Please better document it, with something like:
static u32 qamtab[6] = {
[QPSK] = 0x000,
[QAM_16] = 0x600,
[QAM_32] = 0x601,
[QAM_64] = 0x602,
[QAM_128] = 0x903,
[QAM_256] = 0x604,
};This way, it is clearer what register value is needed for each type of the supported modulations.
Quoted 208 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +208
-0+ +void ddbridge_mod_output_start (struct ddb_output *output) +{ +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + +// PCRIncrement = RoundPCR(PCRIncrement); +// PCRDecrement = RoundPCR(PCRDecrement); + + mod->LastInPacketCount =0 ; + mod->LastOutPacketCount =0 ; + mod->InOverflowPacketCount =0 ; + mod->OutOverflowPacketCount =0 ; + mod->LastInPackets =0 ; + mod->LastOutPackets =0 ; + mod->LastPCRAdjust =0 ; + mod->PCRRunningCorr =0 ; + mod->MinInputPackets =524288 /2 ;// we interrupt every 0x80000=524288 packets + mod->PCRIncrement =0 ;// PCRIncrement; + mod->PCRDecrement =0 ;// PCRDecrement; + + mod->State =CM_STARTUP ; + mod->StateCounter =CM_STARTUP_DELAY ; + +ddbwritel (dev,0 ,CHANNEL_CONTROL (output->nr)); +udelay (10 ); +ddbwritel (dev,CHANNEL_CONTROL_RESET ,CHANNEL_CONTROL (output->nr)); +udelay (10 ); +ddbwritel (dev,0 ,CHANNEL_CONTROL (output->nr)); + +// QAM: 600 601 602 903 604 = 16 32 64 128 256 +// ddbwritel(dev, 0x604, CHANNEL_SETTINGS(output->nr)); +ddbwritel (dev, qamtab[mod->modulation],CHANNEL_SETTINGS (output->nr)); + +ddbwritel (dev, mod->rate_inc,CHANNEL_RATE_INCR (output->nr)); +mod_busy (dev, output->nr); + +mod_set_incs (output); + + mod->Control = (CHANNEL_CONTROL_ENABLE_IQ | +CHANNEL_CONTROL_ENABLE_DVB | +CHANNEL_CONTROL_ENABLE_SOURCE ); + +ddbwritel (dev, mod->Control,CHANNEL_CONTROL (output->nr)); +printk ("mod_output_start %d.%d\n" , dev->nr, output->nr); +} + +static void mod_write_dac_register (struct ddb *dev,u8 Index,u8 Value) +{ +u32 RegValue =0 ; + +ddbwritel (dev, Value,DAC_WRITE_DATA ); +ddbwritel (dev,DAC_CONTROL_STARTIO | Index,DAC_CONTROL ); +do { + RegValue =ddbreadl (dev,DAC_CONTROL ); + }while ((RegValue &DAC_CONTROL_STARTIO ) !=0 ); +} + +static void mod_write_dac_register2 (struct ddb *dev,u8 Index,u16 Value) +{ +u32 RegValue =0 ; + +ddbwritel (dev, Value,DAC_WRITE_DATA ); +ddbwritel (dev,DAC_CONTROL_STARTIO |0x20 | Index,DAC_CONTROL ); +do { + RegValue =ddbreadl (dev,DAC_CONTROL ); + }while ((RegValue &DAC_CONTROL_STARTIO ) !=0 ); +} + +static int mod_read_dac_register (struct ddb *dev,u8 Index,u8 *pValue) +{ +u32 RegValue =0 ; + +ddbwritel (dev,DAC_CONTROL_STARTIO |0x80 | Index,DAC_CONTROL ); +do { + RegValue =ddbreadl (dev,DAC_CONTROL ); + }while ( (RegValue &DAC_CONTROL_STARTIO ) !=0 ); + + RegValue =ddbreadl (dev,DAC_READ_DATA ); + *pValue = (u8 ) RegValue; +return 0 ; +} + +static void mod_set_up_converter_vco1 (struct ddb *dev,u32 Value) +{ +u32 RegValue =0 ; + +/* Extra delay before writing N divider */ +if ((Value &0x03 ) ==0x02 ) +msleep (50 ); +do { + RegValue =ddbreadl (dev,VCO1_CONTROL ); + }while ( (RegValue &VCO1_CONTROL_WRITE ) !=0 ); + +if ((RegValue &VCO1_CONTROL_CE ) ==0 ) { + RegValue |=VCO1_CONTROL_CE ; +ddbwritel (dev, RegValue,VCO1_CONTROL ); +msleep (10 ); + } + +ddbwritel (dev, Value,VCO1_DATA ); +ddbwritel (dev, RegValue |VCO1_CONTROL_WRITE ,VCO1_CONTROL ); +} + +static void mod_set_up_converter_vco2 (struct ddb *dev,u32 Value) +{ +u32 RegValue =0 ; + +/* Extra delay before writing N divider */ +if ((Value &0x03 ) ==0x02 ) +msleep (50 ); +do { + RegValue =ddbreadl (dev,VCO2_CONTROL ); + }while ((RegValue &VCO2_CONTROL_WRITE ) !=0 ); + +if ((RegValue &VCO2_CONTROL_CE ) ==0 ) { + RegValue |=VCO2_CONTROL_CE ; +ddbwritel (dev, RegValue,VCO2_CONTROL ); +msleep (10 ); + } + +ddbwritel (dev, Value,VCO2_DATA ); +ddbwritel (dev, RegValue |VCO2_CONTROL_WRITE ,VCO2_CONTROL ); +} + +static void mod_set_down_converter_vco (struct ddb *dev,u32 Value) +{ +u32 RegValue =0 ; + +do { + RegValue =ddbreadl (dev,VCO3_CONTROL ); + }while ( (RegValue &VCO3_CONTROL_WRITE ) !=0 ); + +if ((RegValue &VCO3_CONTROL_CE ) ==0 ) { + RegValue |=VCO3_CONTROL_CE ; +ddbwritel (dev, RegValue,VCO3_CONTROL ); +msleep (10 ); + } +ddbwritel (dev, Value,VCO3_DATA ); +ddbwritel (dev, RegValue |VCO3_CONTROL_WRITE ,VCO3_CONTROL ); +} + +static int mod_set_attenuator (struct ddb *dev,u32 Value) +{ +if (Value >31 ) +return -EINVAL ; +ddbwritel (dev, Value,RF_ATTENUATOR ); +return 0 ; +} + +static void mod_si598_readreg (struct ddb *dev,u8 index,u8 *val) +{ +ddbwritel (dev, index,CLOCKGEN_INDEX ); +ddbwritel (dev,1 ,CLOCKGEN_CONTROL ); +msleep (5 ); + *val =ddbreadl (dev,CLOCKGEN_READDATA ); +} + +static void mod_si598_writereg (struct ddb *dev,u8 index,u8 val) +{ +ddbwritel (dev, index,CLOCKGEN_INDEX ); +ddbwritel (dev, val,CLOCKGEN_WRITEDATA ); +ddbwritel (dev,3 ,CLOCKGEN_CONTROL ); +msleep (5 ); +} + +static int mod_set_si598 (struct ddb *dev,u32 freq) +{ +u8 Data[6 ]; +u64 fDCO =0 ; +u64 RFreq =0 ; +u32 fOut =10000000 ; +u64 m_fXtal =0 ; +u32 N =0 ; +u64 HSDiv =0 ; + +u32 fxtal; +u64 MinDiv, MaxDiv, Div; +u64 RF ; + +if (freq <10000000 || freq >525000000 ) +return -EINVAL ; +mod_si598_writereg (dev,137 ,0x10 ); + +if (m_fXtal ==0 ) { +mod_si598_writereg (dev,135 ,0x01 ); +mod_si598_readreg (dev,7 , &Data[0 ]); +mod_si598_readreg (dev,8 , &Data[1 ]); +mod_si598_readreg (dev,9 , &Data[2 ]); +mod_si598_readreg (dev,10 , &Data[3 ]); +mod_si598_readreg (dev,11 , &Data[4 ]); +mod_si598_readreg (dev,12 , &Data[5 ]); + +printk (" Data = %02x %02x %02x %02x %02x %02x\n" , + Data[0 ],Data[1 ],Data[2 ],Data[3 ],Data[4 ],Data[5 ]); + RFreq = (((u64 )Data[1 ] &0x3F ) <<32 ) | ((u64 )Data[2 ] <<24 ) | + ((u64 )Data[3 ] <<16 ) | ((u64 )Data[4 ] <<8 ) | ((u64 )Data[5 ]); +if (RFreq ==0 ) +return -EINVAL ; + HSDiv = ((Data[0 ] &0xE0 ) >>5 ) +4 ; +if (HSDiv ==8 || HSDiv ==10 ) +return -EINVAL ; +N = (((u32)(Data[0 ] &0x1F ) <<2 ) | ((u32)(Data[1 ] &0xE0 ) >>6 )) +1 ; + fDCO = fOut * (u64)(HSDiv *N ); + m_fXtal = fDCO <<28 ; +printk ("fxtal %016llx rfreq %016llx\n" , m_fXtal, RFreq); + + m_fXtal += RFreq >>1 ;
drivers/media/pci/ddbridge/ddbridge-mod.c line 334
Quoted 10 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +10
-0+ m_fXtal =div64_u64 (m_fXtal, RFreq); + +printk (" fOut = %d fXtal = %d fDCO = %d HDIV = %2d, N = %3d \n" , + (u32 ) fOut, (u32 ) m_fXtal, (u32 ) fDCO, (u32 ) HSDiv,N ); + } + + fOut = freq; + MinDiv =4850000000ULL ;do_div (MinDiv, freq); MinDiv +=1 ; + MaxDiv =5670000000ULL ;do_div (MaxDiv, freq); + Div =5260000000ULL ;do_div (Div, freq);
One instruction per line.
Quoted 169 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +169
-0+ +if ( Div < MinDiv ) + Div = Div +1 ; +printk (" fOut = %d MinDiv = %4d MaxDiv = %4d StartDiv = %d\n" , fOut, (u32 ) MinDiv, (u32 ) MaxDiv, (u32 ) Div); + +if ( Div <=11 ) { +N =1 ; + HSDiv = Div; + }else { +int retry =100 ; +while (retry >0 ) { +N =0 ; + HSDiv = Div; +while ( (HSDiv >11 )/*|| ((HSDiv * N) != Div)*/ ) { +N =N +2 ; + HSDiv = Div; +do_div (HSDiv,N ); +if (N >128 ) +break ; + } +printk (" %3d: %llu %u %u %u\n" , retry, Div, (u32 ) HSDiv*N , (u32 ) HSDiv,N ); +if (HSDiv *N < MinDiv) { + Div = Div +2 ; + }else if (HSDiv *N > MaxDiv) { + Div = Div -2 ; + }else +break ; + retry = retry -1 ; + } +if ( retry ==0 ) { +printk (" FAIL \n" ); +return -EINVAL ; + } + } + +if (HSDiv ==8 || HSDiv ==10 ) { + HSDiv = HSDiv >>1 ; +N =N *2 ; + } + +if (HSDiv <4 ) +return -EINVAL ; + + + fDCO = (u64 )fOut * (u64 )N * (u64 )HSDiv; +printk ("fdco %16llx\n" , fDCO); + RFreq = fDCO<<28 ; +printk ("%16llx %16llx\n" , fDCO, RFreq); + + fxtal = m_fXtal; +do_div (RFreq, fxtal); +printk ("%16llx %d\n" , RFreq, fxtal); +RF = RFreq; + +// printk("fOut = %d fXtal = %d fDCO = %d HDIV = %d, N = %d, RFreq = %d\n",fOut,m_fXtal,fDCO,HSDiv,N,RFreq); +// printk("%16llx\n", RF); + + Data[0 ] = (u8)( ((HSDiv -4 ) <<5 ) | ((N -1 ) >>2 ) ); + Data[1 ] = (u8)( (((N -1 ) &0x03 ) <<6 ) | ((RF >>32 ) &0x3F ) ); + Data[2 ] = (u8)( (RF >>24 ) &0xFF ); + Data[3 ] = (u8)( (RF >>16 ) &0xFF ); + Data[4 ] = (u8)( (RF >>8 ) &0xFF ); + Data[5 ] = (u8)( (RF ) &0xFF ); + +printk (" Data = %02x %02x %02x %02x %02x %02x\n" , + Data[0 ], Data[1 ], Data[2 ], Data[3 ], Data[4 ], Data[5 ]); +mod_si598_writereg (dev,7 , Data[0 ]); +mod_si598_writereg (dev,8 , Data[1 ]); +mod_si598_writereg (dev,9 , Data[2 ]); +mod_si598_writereg (dev,10 , Data[3 ]); +mod_si598_writereg (dev,11 , Data[4 ]); +mod_si598_writereg (dev,12 , Data[5 ]); + +mod_si598_writereg (dev,137 ,0x00 ); +mod_si598_writereg (dev,135 ,0x40 ); +return 0 ; +} + + +static void mod_bypass_equalizer (struct ddb *dev,int bypass) +{ +u32 RegValue; + + RegValue =ddbreadl (dev,IQOUTPUT_CONTROL ); + RegValue &= ~IQOUTPUT_CONTROL_BYPASS_EQUALIZER ; + RegValue |= (bypass ?IQOUTPUT_CONTROL_BYPASS_EQUALIZER :0x00 ); +ddbwritel (dev, RegValue,IQOUTPUT_CONTROL ); +} + +static int mod_set_equalizer (struct ddb *dev,u32 Num,s16 *cTable) +{ +u32 i, adr =IQOUTPUT_EQUALIZER_0 ; + +if (Num >11 ) +return -EINVAL ; + +for (i =0 ; i <11 - Num; i +=1 ) { +ddbwritel (dev,0 , adr); + adr +=4 ; + } +for (i =0 ; i < Num; i +=1 ) { +ddbwritel (dev, (u32 ) cTable[i], adr); + adr +=4 ; + } +return 0 ; +} + +static int mod_init_dac_input (struct ddb *dev) +{ +u8 Set =0 ; +u8 Hld =0 ; +u8 Sample =0 ; + +u8 Seek =0 ; +u8 ReadSeek =0 ; + +u8 SetTable[32 ]; +u8 HldTable[32 ]; +u8 SeekTable[32 ]; + +u8 Sample1 =0xFF ; +u8 Sample2 =0xFF ; + +u8 SelectSample =0xFF ; +u8 DiffMin =0xFF ; + +for (Sample =0 ; Sample <32 ; Sample++ ) { + Set =0 ; + Hld =0 ; + +mod_write_dac_register (dev,0x04 , Set <<4 | Hld); +mod_write_dac_register (dev,0x05 , Sample); +mod_read_dac_register (dev,0x06 , &ReadSeek); + Seek = ReadSeek &0x01 ; + SeekTable[Sample] = Seek; + + HldTable[Sample] =15 ; + +for (Hld =1 ; Hld <16 ; Hld +=1 ) { +mod_write_dac_register (dev,0x04 , Set <<4 | Hld); +mod_read_dac_register (dev,0x06 , &ReadSeek); + +if ((ReadSeek &0x01 ) != Seek) + { + HldTable[Sample] = Hld; +break ; + } + } + + Hld =0 ; + SetTable[Sample] =15 ; +for (Set =1 ; Set <16 ; Set +=1 ) { +mod_write_dac_register (dev,0x04 , Set <<4 | Hld); +mod_read_dac_register (dev,0x06 , &ReadSeek); + +if ( (ReadSeek &0x01 ) != Seek ) { + SetTable[Sample] = Set; +break ; + } + } + } + + Seek =1 ; +for (Sample =0 ; Sample <32 ; Sample +=1 ) { +// printk(" %2d: %d %2d %2d\n", Sample,SeekTable[Sample],SetTable[Sample],HldTable[Sample]); + +if (Sample1 ==0xFF && SeekTable[Sample] ==1 && Seek ==0 ) + Sample1 = Sample; +if (Sample1 !=0xFF && Sample2 ==0xFF && SeekTable[Sample] ==0 && Seek ==1 )
drivers/media/pci/ddbridge/ddbridge-mod.c line 513
Quoted 10 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +10
-0+ Sample2 = Sample; + Seek = SeekTable[Sample]; + } + +if (Sample1 ==0xFF || Sample2 ==0xFF ) { +printk (" No valid window found\n" ); +return -EINVAL ; + } + +printk (" Window = %d - %d\n" , Sample1, Sample2);
Don't add printks without specifying the level. Also, those seem to be debug printks. The better is to use pr_debug().
Quoted 499 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +499
-0+ +for (Sample = Sample1; Sample < Sample2; Sample +=1 ) { +if (SetTable[Sample] < HldTable[Sample]) { +if (HldTable[Sample] - SetTable[Sample] < DiffMin) { + DiffMin = HldTable[Sample] - SetTable[Sample]; + SelectSample = Sample; + } + } + } + +printk ("Select Sample %d\n" , SelectSample); + +if (SelectSample ==0xFF ) { +printk ("No valid sample found\n" ); +return -EINVAL ; + } + +if (HldTable[SelectSample] + SetTable[SelectSample] <8 ) { +printk ("Too high jitter\n" ); +return -EINVAL ; + } + +mod_write_dac_register (dev,0x04 ,0x00 ); +mod_write_dac_register (dev,0x05 , (SelectSample -1 ) &0x1F ); +mod_read_dac_register (dev,0x06 , &Seek); +mod_write_dac_register (dev,0x05 , (SelectSample +1 ) &0x1F ); +mod_read_dac_register (dev,0x06 ,&ReadSeek); + Seek &= ReadSeek; + +mod_write_dac_register (dev,0x05 , SelectSample); +mod_read_dac_register (dev,0x06 , &ReadSeek); + Seek &= ReadSeek; +if ( (Seek &0x01 ) ==0 ) { +printk ("Insufficient timing margin\n" ); +return -EINVAL ; + } +printk ("Done\n" ); +return 0 ; +} + +static void mod_set_up1 (struct ddb *dev,u32 Frequency,u32 Ref,u32 Ext) +{ +u32 RDiv = Ext / Ref; + + Frequency = Frequency / Ref; +mod_set_up_converter_vco1 (dev,0x360001 | (RDiv <<2 )); +mod_set_up_converter_vco1 (dev,0x0ff128 ); +mod_set_up_converter_vco1 (dev,0x02 | (Frequency <<8 )); +} + +static void mod_set_up2 (struct ddb *dev,u32 Frequency,u32 Ref,u32 Ext) +{ +u32 Rdiv = Ext / Ref; +u32 PreScale =8 ; + + Frequency = Frequency / Ref; +mod_set_up_converter_vco2 (dev,0x360001 | (Rdiv <<2 )); +mod_set_up_converter_vco2 (dev,0x0fc128 | (((PreScale -8 ) /8 ) <<22 )); +mod_set_up_converter_vco2 (dev,0x02 | ((Frequency / PreScale) <<8 ) + | (Frequency & (PreScale -1 )) <<2 ); +} + +static int mod_set_down (struct ddb *dev,u32 Frequency,u32 Ref,u32 Ext) +{ +u32 BandSelect = Ref *8 ; +u32 RefMul =1 ; +u32 RefDiv2 =1 ; +u32 RefDiv = Ext * RefMul / (Ref * RefDiv2); + +if (Frequency <2200 || Frequency >4000 ) +return -EINVAL ; + + Frequency = Frequency / Ref; + +mod_set_down_converter_vco (dev,0x0080003C | ((BandSelect &0xFF ) <<12 )); +mod_set_down_converter_vco (dev,0x00000003 ); +mod_set_down_converter_vco (dev,0x18001E42 | ((RefMul-1 ) <<25 ) | + ((RefDiv2-1 ) <<24 ) | (RefDiv <<14 ) ); +mod_set_down_converter_vco (dev,0x08008021 ); +mod_set_down_converter_vco (dev, Frequency <<15 ); +return 0 ; +} + +static int mod_set_dac_clock (struct ddb *dev,u32 Frequency) +{ +int hr, i; + +if (Frequency) { +ddbwritel (dev,DAC_CONTROL_RESET ,DAC_CONTROL ); +msleep (10 ); +if (mod_set_si598 (dev, Frequency)) { +printk ("mod_set_si598 failed\n" ); +return -1 ; + } +msleep (50 ); +ddbwritel (dev,0x000 ,DAC_CONTROL ); +msleep (10 ); +mod_write_dac_register (dev,0 ,0x02 ); + } + +for (i =0 ; i <10 ; i++) { + hr =mod_init_dac_input (dev); +if (hr ==0 ) +break ; +msleep (100 ); + } +printk ("mod_set_dac_clock OK\n" ); +return hr; +} + +static void mod_set_dac_current (struct ddb *dev,u32 Current1,u32 Current2) +{ +mod_write_dac_register2 (dev,0x0b , Current1 &0x3ff ); +mod_write_dac_register2 (dev,0x0f , Current2 &0x3ff ); +} + +static void mod_output_enable (struct ddb *dev,int enable) +{ + +u32 RegValue; + + RegValue =ddbreadl (dev,IQOUTPUT_CONTROL ); + RegValue &= ~(IQOUTPUT_CONTROL_ENABLE |IQOUTPUT_CONTROL_RESET ); +ddbwritel (dev, RegValue,IQOUTPUT_CONTROL ); + +if (enable) { +ddbwritel (dev, RegValue |IQOUTPUT_CONTROL_RESET ,IQOUTPUT_CONTROL ); +msleep (10 ); +ddbwritel (dev, RegValue,IQOUTPUT_CONTROL ); +ddbwritel (dev, RegValue |IQOUTPUT_CONTROL_ENABLE ,IQOUTPUT_CONTROL ); + } +} + +static int mod_set_iq (struct ddb *dev,u32 steps,u32 chan,u32 freq) +{ +u32 i, j, k, fac =8 ; +u32 s1 =22 , s2 =33 ; +u64 amp = (1ULL <<17 ) -1ULL ; +u64 s =0 , c = (amp << s1), ss; +u64 frq =0xC90FDAA22168C234ULL ; +u32 *iqtab; +u32 iqtabadr; +u32 volatile regval; + + iqtab =kmalloc ((steps +1 ) *4 ,GFP_KERNEL ); +if (!iqtab) +return -ENOMEM ; + frq =div64_u64 (frq, steps * fac) >> (61 - s2); + +/* create sine table */ +for (i =0 ; i <= steps * fac /4 ; i++) { +if (!(i & (fac -1 ))) { + j = i / fac; + ss = s >> s1; +// ss = ((s >> (s1 - 1)) + 1) >> 1; + + iqtab[j] = iqtab[steps /2 - j] = ss; + iqtab[steps /2 + j] = iqtab[steps - j] = -ss; + } + c -= ((s * frq) >> s2); + s += ((c * frq) >> s2); + } + + iqtabadr = chan <<16 ; +ddbwritel (dev, chan &0x0f ,MODULATOR_IQTABLE_INDEX ); +for (i = j =0 , k = steps /4 ; i < steps; i++) { +ddbwritel (dev, (iqtabadr + i) |MODULATOR_IQTABLE_INDEX_SEL_I , +MODULATOR_IQTABLE_INDEX ); +ddbwritel (dev, iqtab[j],MODULATOR_IQTABLE_DATA ); + regval =ddbreadl (dev,MODULATOR_CONTROL ); +ddbwritel (dev, (iqtabadr + i) |MODULATOR_IQTABLE_INDEX_SEL_Q , +MODULATOR_IQTABLE_INDEX ); +ddbwritel (dev, iqtab[k],MODULATOR_IQTABLE_DATA ); + regval =ddbreadl (dev,MODULATOR_CONTROL ); + j += freq; + j %= steps; + k += freq; + k %= steps; + } +ddbwritel (dev, steps -1 ,MODULATOR_IQTABLE_END ); +kfree (iqtab); +return 0 ; +} + +u32 eqtab[] = { +0x0000FFDB ,0x00000121 ,0x0000FF0A ,0x000003D7 , +0x000001C4 ,0x000005A5 ,0x000009CC ,0x0000F50D , +0x00001B23 ,0x0000EEB7 ,0x00006A28 +}; + +static void mod_set_channelsumshift (struct ddb *dev,u32 shift) +{ +ddbwritel (dev, (shift &3 ) <<2 ,MODULATOR_CONTROL ); +} + +static void mod_pre_eq_gain (struct ddb *dev,u16 gain) +{ +ddbwritel (dev, gain,IQOUTPUT_PRESCALER ); +} + +static void mod_post_eq_gain (struct ddb *dev,u16 igain,u16 qgain) +{ +ddbwritel (dev, ((u32 )qgain <<16 ) | igain,IQOUTPUT_POSTSCALER ); +} + +static int set_base_frequency (struct ddb *dev,u32 freq) +{ +u32 Ext =40 ; +u32 UP1Frequency =290 ; +u32 UP2Frequency =1896 ; +u32 down, freq10; + +printk ("set base to %u\n" , freq); + dev->mod_base.frequency = freq; + freq /=1000000 ; + freq10 = dev->mod_base.flat_start +4 ; + down = freq +9 *8 + freq10 + UP1Frequency + UP2Frequency; + +if ((freq10 +9 *8 ) > (dev->mod_base.flat_end -4 )) { +printk ("Frequency out of range %d\n" , freq10); +return -EINVAL ; + } +if (down %8 ) { +printk (" Invalid Frequency %d\n" , down); +return -EINVAL ; + } +return mod_set_down (dev, down,8 , Ext); +} + +static int mod_init (struct ddb *dev,u32 Frequency) +{ +int stat =0 ; +u8 *buffer; +struct DDMOD_FLASH *flash; +u32 Ext =40 ; +u32 UP1Frequency =290 ; +u32 UP2Frequency =1896 ; +u32 DownFrequency; +u32 FrequencyCH10; +u32 iqfreq, iqsteps, i; + + buffer =kmalloc (4096 ,GFP_KERNEL ); +if (!buffer) +return -ENOMEM ; + flash = (struct DDMOD_FLASH *) buffer; + +ddbridge_flashread (dev, buffer,DDMOD_FLASH_START ,4096 ); + +if (flash->Magic !=DDMOD_FLASH_MAGIC && flash->Magic !=1 ) { + stat = -EINVAL ; + goto fail; + } +printk ("srate = %d\n" , flash->DataSet[0 ].Symbolrate *1000 ); + +mod_output_enable (dev,0 ); + stat =mod_set_dac_clock (dev, flash->DataSet[0 ].DACFrequency *1000 ); +if (stat <0 ) { +printk ("setting DAC clock failed\n" ); + goto fail; + } +mod_set_dac_current (dev,512 ,512 ); + +ddbwritel (dev, flash->DataSet[0 ].Control2,IQOUTPUT_CONTROL2 ); + +mod_set_up1 (dev, UP1Frequency,5 , Ext); +mod_set_up2 (dev, UP2Frequency,8 , Ext); + + dev->mod_base.flat_start = flash->DataSet[0 ].FlatStart; + dev->mod_base.flat_end = flash->DataSet[0 ].FlatEnd; + + Frequency /=1000000 ; + FrequencyCH10 = flash->DataSet[0 ].FlatStart +4 ; + DownFrequency = Frequency +9 *8 + FrequencyCH10 + UP1Frequency + UP2Frequency; +printk ("CH10 = %d, Down = %d\n" , FrequencyCH10, DownFrequency); + + +if ((FrequencyCH10 +9 *8 ) > (flash->DataSet[0 ].FlatEnd -4 )) { +printk ("Frequency out of range %d\n" , FrequencyCH10); + stat = -EINVAL ; + goto fail; + } + +if (DownFrequency %8 !=0 ) { +printk (" Invalid Frequency %d\n" , DownFrequency); + stat = -EINVAL ; + goto fail; + } + +mod_set_down (dev, DownFrequency,8 , Ext); + +for (i =0 ; i <10 ; i++) { +ddbwritel (dev,0 ,CHANNEL_CONTROL (i)); + + iqfreq = flash->DataSet[0 ].FrequencyFactor * (FrequencyCH10 + (9 - i) *8 ); + iqsteps = flash->DataSet[0 ].IQTableLength; +mod_set_iq (dev, iqsteps, i, iqfreq); + + dev->mod[i].modulation =QAM_256 ; + } + +mod_bypass_equalizer (dev,1 ); +mod_set_equalizer (dev,11 , flash->DataSet[0 ].EQTap); +mod_bypass_equalizer (dev,0 ); +mod_post_eq_gain (dev, flash->DataSet[0 ].PostScaleI, flash->DataSet[0 ].PostScaleQ); +mod_pre_eq_gain (dev, flash->DataSet[0 ].PreScale); +// mod_pre_eq_gain(dev, 0x0680); +printk ("prescaler %04x\n" , flash->DataSet[0 ].PreScale); +mod_set_channelsumshift (dev,2 ); +mod_output_enable (dev,1 ); + +// mod_set_attenuator(dev, 10); +fail: +kfree (buffer); +return stat; +} + + +void ddbridge_mod_rate_handler (unsigned long data) +{ +struct ddb_output *output = (struct ddb_output *) data; +struct ddb_dma *dma = output->dma; +struct ddb *dev = output->port->dev; +struct mod_state *mod= &dev->mod[output->nr]; + +u32 chan = output->nr; +u32 OutPacketCount; +u32 InPacketCount; +u64 OutPackets, InPackets; +s64 PCRAdjust; +u32 PCRAdjustExt, PCRAdjustExtFrac, InPacketDiff, OutPacketDiff; +s32 PCRCorr; + +s64 pcr; +s64 PCRIncrementDiff; +s64 PCRIncrement; +u64 mul; + +if (!mod->do_handle) +return ; +printk ("rate_handler\n" ); + +spin_lock (&dma->lock); +ddbwritel (dev, mod->Control |CHANNEL_CONTROL_FREEZE_STATUS , +CHANNEL_CONTROL (output->nr)); + + OutPacketCount =ddbreadl (dev,CHANNEL_PKT_COUNT_OUT (chan)); +if (OutPacketCount < mod->LastOutPacketCount ) + mod->OutOverflowPacketCount +=1 ; + mod->LastOutPacketCount = OutPacketCount; + + InPacketCount =ddbreadl (dev,CHANNEL_PKT_COUNT_IN (chan)); +if (InPacketCount < mod->LastInPacketCount ) + mod->InOverflowPacketCount +=1 ; + mod->LastInPacketCount = InPacketCount; + + OutPackets = ((u64) (mod->OutOverflowPacketCount) <<20 ) | OutPacketCount; + InPackets = ((u64) (mod->InOverflowPacketCount) <<20 ) | InPacketCount; + + PCRAdjust = (s64) ((u64 )ddbreadl (dev,CHANNEL_PCR_ADJUST_ACCUL (chan)) | + (((u64 )ddbreadl (dev,CHANNEL_PCR_ADJUST_ACCUH (chan)) <<32 ))); + PCRAdjustExt = (u32)((PCRAdjust &0x7FFFFFFF ) >>22 ); + PCRAdjustExtFrac = (u32)((PCRAdjust &0x003FFFFF ) >>12 ); + PCRAdjust >>=31 ; + InPacketDiff = (u32) (InPackets - mod->LastInPackets); + OutPacketDiff = (u32) (OutPackets - mod->LastOutPackets); + PCRCorr =0 ; + +switch (mod->State) { +case CM_STARTUP : +if (mod->StateCounter) { +if (mod->StateCounter ==1 ) { + mul = (0x1000000 * (u64) (OutPacketDiff - InPacketDiff - InPacketDiff/1000 )); +if (OutPacketDiff) + mod->rate_inc =div_u64 (mul, OutPacketDiff); +else + mod->rate_inc =0 ; +printk ("RI %08x\n" , mod->rate_inc); +ddbwritel (dev, mod->rate_inc,CHANNEL_RATE_INCR (output->nr)); +mod_busy (dev, output->nr); +// #define PACKET_CLOCKS (27000000ULL*1504) +// #define FACTOR (1024<<12) +// double Increment = FACTOR*PACKET_CLOCKS/double(m_OutputBitrate); +// double Decrement = FACTOR*PACKET_CLOCKS/double(m_InputBitrate); + mod->PCRIncrement =3348148758ULL ; +if (InPacketDiff) + mod->PCRDecrement =div_u64 (3348148758ULL * (u64 ) OutPacketDiff, + InPacketDiff); +else + mod->PCRDecrement =0 ; +mod_set_incs (output); + } + mod->StateCounter--; +break ; + } +if (InPacketDiff >= mod->MinInputPackets) { + mod->State =CM_ADJUST ; + mod->Control |=CHANNEL_CONTROL_ENABLE_PCRADJUST ; + mod->InPacketsSum =0 ; + mod->OutPacketsSum =0 ; + mod->PCRAdjustSum =0 ; + mod->StateCounter =CM_AVERAGE ; + } +break ; + +case CM_ADJUST : +if (InPacketDiff < mod->MinInputPackets) { +printk ("PCR Adjust reset IN: %u Min: %u\n" , + InPacketDiff, mod->MinInputPackets); + mod->InPacketsSum =0 ; + mod->OutPacketsSum =0 ; + mod->PCRAdjustSum =0 ; + mod->StateCounter =CM_AVERAGE ; +ddbwritel (dev, + (mod->Control |CHANNEL_CONTROL_FREEZE_STATUS ) & + ~CHANNEL_CONTROL_ENABLE_PCRADJUST , +CHANNEL_CONTROL (chan)); +break ; + } + + mod->PCRAdjustSum += (s32 ) PCRAdjust; + mod->InPacketsSum += InPacketDiff; + mod->OutPacketsSum += OutPacketDiff; +if (mod->StateCounter--) +break ; + +if (mod->OutPacketsSum) + PCRIncrement =div_s64 ((s64 )mod->InPacketsSum * + (s64 )mod->PCRDecrement + + (s64)(mod->OutPacketsSum >>1 ) , + mod->OutPacketsSum); +else + PCRIncrement =0 ; + +if ( mod->PCRAdjustSum >0 ) + PCRIncrement =RoundPCRDown (PCRIncrement); +else + PCRIncrement =RoundPCRUp (PCRIncrement); + + PCRIncrementDiff = PCRIncrement - mod->PCRIncrement; +if ( PCRIncrementDiff >HW_LSB_MASK ) + PCRIncrementDiff =HW_LSB_MASK ; +if ( PCRIncrementDiff < -HW_LSB_MASK ) + PCRIncrementDiff = -HW_LSB_MASK ; + + mod->PCRIncrement += PCRIncrementDiff; + pcr =ConvertPCR (mod->PCRIncrement); +printk ("outl %016llx\n" , pcr); +ddbwritel (dev, pcr &0xffffffff , +CHANNEL_PCR_ADJUST_OUTL (output->nr)); +ddbwritel (dev, (pcr >>32 ) &0xffffffff , +CHANNEL_PCR_ADJUST_OUTH (output->nr)); +mod_busy (dev, chan); + + PCRCorr = (s32) (PCRIncrementDiff >>HW_LSB_SHIFT ); + mod->PCRRunningCorr += PCRCorr; + + mod->InPacketsSum =0 ; + mod->OutPacketsSum =0 ; + mod->PCRAdjustSum =0 ; + mod->StateCounter =CM_AVERAGE ; +break ; + +default : +break ; + } +ddbwritel (dev, mod->Control,CHANNEL_CONTROL (chan)); + + mod->LastInPackets = InPackets; + mod->LastOutPackets = OutPackets; + mod->LastPCRAdjust = (s32 ) PCRAdjust; + +printk ("chan %d out %016llx in %016llx indiff %08x\n" , chan, OutPackets, InPackets, InPacketDiff); +printk ("cnt %d pcra %016llx pcraext %08x pcraextfrac %08x pcrcorr %08x pcri %016llx\n" , + mod->StateCounter, PCRAdjust, PCRAdjustExt, PCRAdjustExtFrac, PCRCorr, mod->PCRIncrement); +// Channel,OutPackets,InPackets,InPacketDiff,PCRAdjust,PCRAdjustExt,PCRAdjustExtFrac,PCRCorr, mod->PCRRunningCorr,mod->StateCounter )); +spin_unlock (&dma->lock); +} + +int ddbridge_mod_do_ioctl (struct file *file,unsigned int cmd,void *parg) +{ +struct dvb_device *dvbdev = file->private_data; +struct ddb_output *output = dvbdev->priv; +struct ddb *dev = output->port->dev; + +// unsigned long arg = (unsigned long) parg; +int ret =0 ; + +switch (cmd) { +case DVB_MOD_SET : + { +struct dvb_mod_params *mp = parg; + +if (mp->base_frequency != dev->mod_base.frequency) +if (set_base_frequency (dev, mp->base_frequency)) +return -EINVAL ; +mod_set_attenuator (dev, mp->attenuator); +break ; + } +case DVB_MOD_CHANNEL_SET :
drivers/media/pci/ddbridge/ddbridge-mod.c line 1022
Quoted 10 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +10
-0+ { +struct dvb_mod_channel_params *cp = parg; + +if (cp->modulation >QAM_256 ) +return -EINVAL ; + dev->mod[output->nr].modulation = cp->modulation; + dev->mod[output->nr].rate_inc = cp->rate_increment; +ddbwritel (dev, dev->mod[output->nr].rate_inc,CHANNEL_RATE_INCR (output->nr)); +break ; + }
Here, you have a new undocumented API. It should be properly documented.
Also, the IOCTL handling logic should, be implemented at the core, of course providing ways for ddbridge-mod to register their functions to select the modulation type and parameters to enable/disable the modulator, and to provide mpeg TS streams for it.
Quoted 11 lines
drivers/media/pci/ddbridge/ddbridge-mod.c new file +11
-0+default : + ret = -EINVAL ; +break ; + } +return ret; +} + +int ddbridge_mod_init (struct ddb *dev) +{ +return mod_init (dev,722000000 ); +}
Signature · 2 lines
Cheers, Mauro
Re: [PATCH 01/12] dvb-frontends: Support for DVB-C2 to DVB frontends
In reply to Mauro Carvalho ChehabQuoted 22 lines · Mauro Carvalho Chehab
Em Sun, 3 Nov 2013 01:24:25 +0100
Maik Broemme <[email protected]> escreveu:Quoted 19 lines
Added support for DVB-C2 to DVB frontends. It will be required by cxd2843 and tda18212dd (Digital Devices) frontends.
Signed-off-by Maik Broemme <[email protected]>--- include/uapi/linux/dvb/frontend.h | 1 + 1 file changed, 1 insertion(+)include/uapi/linux/dvb/frontend.h +1
-0@@ -410,6 +410,7 @@ typedef enum fe_delivery_system {SYS_DVBT2 ,SYS_TURBO ,SYS_DVBC_ANNEX_C , +SYS_DVBC2 , } fe_delivery_system_t;
Quoted 7 lines
include/uapi/linux/dvb/frontend.h typedef enum fe_delivery_system { · line 416
Quoted 1 line
include/uapi/linux/dvb/frontend.h +0
-0/* backward compatibility */ Please update also the documentation, at
Documentation/DocBook/media/dvb.Doesn't DVB-C2 provide any newer property? If so, please add it there as well, and at
frontend.h.
I asked about this on linux-media a week or so ago. The main question was concerning STREAM_ID. I asked if it would be fine to combine PLP and slice id (each 8 bit) into stream_id or if there should be a separate new property. And for which one, PLP or slice id?
Probably slice id, because stream_id is also used for PLP in T2? I combined them into stream_id for now (but that was after the 0.9.10 version of the dddvb package).
There are also many new qam types, etc. but, as I said back then, it was not urgent for me to add those because the Sony demod does not allow setting those. At least it is not documented how to do it.
Regards,
Ralph