V4L/DVB (13493): TeVii S470 and TBS 6920 fixes

 The new hardware design applied for this cards.
Silicon Labs C8051F300 microcontroller is used for LNB power control.
It connected to cx23885 GPIO pins:
 GPIO0 - P0.3 data
 GPIO1 - P0.2 reset
 GPIO2 - P0.1 clk
 GPIO3 - P0.0 busy
 Tevii S470 based on Montage Technology M88TS2020 digital satellite tuner
and M88DS3000 advanced DVB-S/S2 demodulator.

Signed-off-by: Igor M. Liplianin <liplianin@me.by>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

12 files changed, 1647 insertions, 29 deletions

diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index fdc7926cb2db..58aac018f109 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -201,6 +201,13 @@ config DVB_SI21XX
         help
           A DVB-S tuner module. Say Y when you want to support this frontend.
 
+config DVB_DS3000
+        tristate "Montage Tehnology DS3000 based"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+        help
+          A DVB-S/S2 tuner module. Say Y when you want to support this frontend.
+
 comment "DVB-T (terrestrial) frontends"
         depends on DVB_CORE
 
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile
index 390eec6d5d84..823482535d11 100644
--- a/drivers/media/dvb/frontends/Makefile
+++ b/drivers/media/dvb/frontends/Makefile
@@ -78,3 +78,4 @@ obj-$(CONFIG_DVB_STV090x) += stv090x.o
 obj-$(CONFIG_DVB_STV6110x) += stv6110x.o
 obj-$(CONFIG_DVB_ISL6423) += isl6423.o
 obj-$(CONFIG_DVB_EC100) += ec100.o
+obj-$(CONFIG_DVB_DS3000) += ds3000.o
diff --git a/drivers/media/dvb/frontends/ds3000.c b/drivers/media/dvb/frontends/ds3000.c
new file mode 100644
index 000000000000..cff3535566fe
--- /dev/null
+++ b/drivers/media/dvb/frontends/ds3000.c
@@ -0,0 +1,1367 @@
+/*
+    Montage Technology DS3000/TS2020 - DVBS/S2 Demodulator/Tuner driver
+    Copyright (C) 2009 Konstantin Dimitrov <kosio.dimitrov@gmail.com>
+
+    Copyright (C) 2009 TurboSight.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/firmware.h>
+
+#include "dvb_frontend.h"
+#include "ds3000.h"
+
+static int debug;
+
+#define dprintk(args...) \
+        do { \
+                if (debug) \
+                        printk(args); \
+        } while (0)
+
+/* as of March 2009 current DS3000 firmware version is 1.78 */
+/* DS3000 FW v1.78 MD5: a32d17910c4f370073f9346e71d34b80 */
+#define DS3000_DEFAULT_FIRMWARE "dvb-fe-ds3000.fw"
+
+#define DS3000_SAMPLE_RATE 96000 /* in kHz */
+#define DS3000_XTAL_FREQ   27000 /* in kHz */
+
+/* Register values to initialise the demod in DVB-S mode */
+static u8 ds3000_dvbs_init_tab[] = {
+        0x23, 0x05,
+        0x08, 0x03,
+        0x0c, 0x00,
+        0x21, 0x54,
+        0x25, 0x82,
+        0x27, 0x31,
+        0x30, 0x08,
+        0x31, 0x40,
+        0x32, 0x32,
+        0x33, 0x35,
+        0x35, 0xff,
+        0x3a, 0x00,
+        0x37, 0x10,
+        0x38, 0x10,
+        0x39, 0x02,
+        0x42, 0x60,
+        0x4a, 0x40,
+        0x4b, 0x04,
+        0x4d, 0x91,
+        0x5d, 0xc8,
+        0x50, 0x77,
+        0x51, 0x77,
+        0x52, 0x36,
+        0x53, 0x36,
+        0x56, 0x01,
+        0x63, 0x43,
+        0x64, 0x30,
+        0x65, 0x40,
+        0x68, 0x26,
+        0x69, 0x4c,
+        0x70, 0x20,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x40,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x60,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x80,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0xa0,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x1f,
+        0x76, 0x00,
+        0x77, 0xd1,
+        0x78, 0x0c,
+        0x79, 0x80,
+        0x7f, 0x04,
+        0x7c, 0x00,
+        0x80, 0x86,
+        0x81, 0xa6,
+        0x85, 0x04,
+        0xcd, 0xf4,
+        0x90, 0x33,
+        0xa0, 0x44,
+        0xc0, 0x18,
+        0xc3, 0x10,
+        0xc4, 0x08,
+        0xc5, 0x80,
+        0xc6, 0x80,
+        0xc7, 0x0a,
+        0xc8, 0x1a,
+        0xc9, 0x80,
+        0xfe, 0x92,
+        0xe0, 0xf8,
+        0xe6, 0x8b,
+        0xd0, 0x40,
+        0xf8, 0x20,
+        0xfa, 0x0f,
+        0xfd, 0x20,
+        0xad, 0x20,
+        0xae, 0x07,
+        0xb8, 0x00,
+};
+
+/* Register values to initialise the demod in DVB-S2 mode */
+static u8 ds3000_dvbs2_init_tab[] = {
+        0x23, 0x0f,
+        0x08, 0x07,
+        0x0c, 0x00,
+        0x21, 0x54,
+        0x25, 0x82,
+        0x27, 0x31,
+        0x30, 0x08,
+        0x31, 0x32,
+        0x32, 0x32,
+        0x33, 0x35,
+        0x35, 0xff,
+        0x3a, 0x00,
+        0x37, 0x10,
+        0x38, 0x10,
+        0x39, 0x02,
+        0x42, 0x60,
+        0x4a, 0x80,
+        0x4b, 0x04,
+        0x4d, 0x81,
+        0x5d, 0x88,
+        0x50, 0x36,
+        0x51, 0x36,
+        0x52, 0x36,
+        0x53, 0x36,
+        0x63, 0x60,
+        0x64, 0x10,
+        0x65, 0x10,
+        0x68, 0x04,
+        0x69, 0x29,
+        0x70, 0x20,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x40,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x60,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x80,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0xa0,
+        0x71, 0x70,
+        0x72, 0x04,
+        0x73, 0x00,
+        0x70, 0x1f,
+        0xa0, 0x44,
+        0xc0, 0x08,
+        0xc1, 0x10,
+        0xc2, 0x08,
+        0xc3, 0x10,
+        0xc4, 0x08,
+        0xc5, 0xf0,
+        0xc6, 0xf0,
+        0xc7, 0x0a,
+        0xc8, 0x1a,
+        0xc9, 0x80,
+        0xca, 0x23,
+        0xcb, 0x24,
+        0xce, 0x74,
+        0x90, 0x03,
+        0x76, 0x80,
+        0x77, 0x42,
+        0x78, 0x0a,
+        0x79, 0x80,
+        0xad, 0x40,
+        0xae, 0x07,
+        0x7f, 0xd4,
+        0x7c, 0x00,
+        0x80, 0xa8,
+        0x81, 0xda,
+        0x7c, 0x01,
+        0x80, 0xda,
+        0x81, 0xec,
+        0x7c, 0x02,
+        0x80, 0xca,
+        0x81, 0xeb,
+        0x7c, 0x03,
+        0x80, 0xba,
+        0x81, 0xdb,
+        0x85, 0x08,
+        0x86, 0x00,
+        0x87, 0x02,
+        0x89, 0x80,
+        0x8b, 0x44,
+        0x8c, 0xaa,
+        0x8a, 0x10,
+        0xba, 0x00,
+        0xf5, 0x04,
+        0xfe, 0x44,
+        0xd2, 0x32,
+        0xb8, 0x00,
+};
+
+/* DS3000 doesn't need some parameters as input and auto-detects them */
+/* save input from the application of those parameters */
+struct ds3000_tuning {
+        u32 frequency;
+        u32 symbol_rate;
+        fe_spectral_inversion_t inversion;
+        enum fe_code_rate fec;
+
+        /* input values */
+        u8 inversion_val;
+        fe_modulation_t delivery;
+        u8 rolloff;
+};
+
+struct ds3000_state {
+        struct i2c_adapter *i2c;
+        const struct ds3000_config *config;
+
+        struct dvb_frontend frontend;
+
+        struct ds3000_tuning dcur;
+        struct ds3000_tuning dnxt;
+
+        u8 skip_fw_load;
+
+        /* previous uncorrected block counter for DVB-S2 */
+        u16 prevUCBS2;
+};
+
+static int ds3000_writereg(struct ds3000_state *state, int reg, int data)
+{
+        u8 buf[] = { reg, data };
+        struct i2c_msg msg = { .addr = state->config->demod_address,
+                .flags = 0, .buf = buf, .len = 2 };
+        int err;
+
+        dprintk("%s: write reg 0x%02x, value 0x%02x\n", __func__, reg, data);
+
+        err = i2c_transfer(state->i2c, &msg, 1);
+        if (err != 1) {
+                printk(KERN_ERR "%s: writereg error(err == %i, reg == 0x%02x,"
+                         " value == 0x%02x)\n", __func__, err, reg, data);
+                return -EREMOTEIO;
+        }
+
+        return 0;
+}
+
+static int ds3000_tuner_writereg(struct ds3000_state *state, int reg, int data)
+{
+        u8 buf[] = { reg, data };
+        struct i2c_msg msg = { .addr = 0x60,
+                .flags = 0, .buf = buf, .len = 2 };
+        int err;
+
+        dprintk("%s: write reg 0x%02x, value 0x%02x\n", __func__, reg, data);
+
+        ds3000_writereg(state, 0x03, 0x11);
+        err = i2c_transfer(state->i2c, &msg, 1);
+        if (err != 1) {
+                printk("%s: writereg error(err == %i, reg == 0x%02x,"
+                         " value == 0x%02x)\n", __func__, err, reg, data);
+                return -EREMOTEIO;
+        }
+
+        return 0;
+}
+
+/* I2C write for 8k firmware load */
+static int ds3000_writeFW(struct ds3000_state *state, int reg,
+                                const u8 *data, u16 len)
+{
+        int i, ret = -EREMOTEIO;
+        struct i2c_msg msg;
+        u8 *buf;
+
+        buf = kmalloc(3, GFP_KERNEL);
+        if (buf == NULL) {
+                printk(KERN_ERR "Unable to kmalloc\n");
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        *(buf) = reg;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.buf = buf;
+        msg.len = 3;
+
+        for (i = 0; i < len; i += 2) {
+                memcpy(buf + 1, data + i, 2);
+
+                dprintk("%s: write reg 0x%02x, len = %d\n", __func__, reg, len);
+
+                ret = i2c_transfer(state->i2c, &msg, 1);
+                if (ret != 1) {
+                        printk(KERN_ERR "%s: write error(err == %i, "
+                                "reg == 0x%02x\n", __func__, ret, reg);
+                        ret = -EREMOTEIO;
+                }
+        }
+
+error:
+        kfree(buf);
+
+        return ret;
+}
+
+static int ds3000_readreg(struct ds3000_state *state, u8 reg)
+{
+        int ret;
+        u8 b0[] = { reg };
+        u8 b1[] = { 0 };
+        struct i2c_msg msg[] = {
+                {
+                        .addr = state->config->demod_address,
+                        .flags = 0,
+                        .buf = b0,
+                        .len = 1
+                }, {
+                        .addr = state->config->demod_address,
+                        .flags = I2C_M_RD,
+                        .buf = b1,
+                        .len = 1
+                }
+        };
+
+        ret = i2c_transfer(state->i2c, msg, 2);
+
+        if (ret != 2) {
+                printk(KERN_ERR "%s: reg=0x%x(error=%d)\n", __func__, reg, ret);
+                return ret;
+        }
+
+        dprintk("%s: read reg 0x%02x, value 0x%02x\n", __func__, reg, b1[0]);
+
+        return b1[0];
+}
+
+static int ds3000_tuner_readreg(struct ds3000_state *state, u8 reg)
+{
+        int ret;
+        u8 b0[] = { reg };
+        u8 b1[] = { 0 };
+        struct i2c_msg msg[] = {
+                {
+                        .addr = 0x60,
+                        .flags = 0,
+                        .buf = b0,
+                        .len = 1
+                }, {
+                        .addr = 0x60,
+                        .flags = I2C_M_RD,
+                        .buf = b1,
+                        .len = 1
+                }
+        };
+
+        ds3000_writereg(state, 0x03, 0x12);
+        ret = i2c_transfer(state->i2c, msg, 2);
+
+        if (ret != 2) {
+                printk(KERN_ERR "%s: reg=0x%x(error=%d)\n", __func__, reg, ret);
+                return ret;
+        }
+
+        dprintk("%s: read reg 0x%02x, value 0x%02x\n", __func__, reg, b1[0]);
+
+        return b1[0];
+}
+
+static int ds3000_set_inversion(struct ds3000_state *state,
+                                        fe_spectral_inversion_t inversion)
+{
+        dprintk("%s(%d)\n", __func__, inversion);
+
+        switch (inversion) {
+        case INVERSION_OFF:
+        case INVERSION_ON:
+        case INVERSION_AUTO:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        state->dnxt.inversion = inversion;
+
+        return 0;
+}
+
+static int ds3000_set_symbolrate(struct ds3000_state *state, u32 rate)
+{
+        int ret = 0;
+
+        dprintk("%s()\n", __func__);
+
+        dprintk("%s() symbol_rate = %d\n", __func__, state->dnxt.symbol_rate);
+
+        /*  check if symbol rate is within limits */
+        if ((state->dnxt.symbol_rate >
+                                state->frontend.ops.info.symbol_rate_max) ||
+            (state->dnxt.symbol_rate <
+                                state->frontend.ops.info.symbol_rate_min))
+                ret = -EOPNOTSUPP;
+
+        state->dnxt.symbol_rate = rate;
+
+        return ret;
+}
+
+static int ds3000_load_firmware(struct dvb_frontend *fe,
+                                        const struct firmware *fw);
+
+static int ds3000_firmware_ondemand(struct dvb_frontend *fe)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        const struct firmware *fw;
+        int ret = 0;
+
+        dprintk("%s()\n", __func__);
+
+        if (ds3000_readreg(state, 0xb2) <= 0)
+                return ret;
+
+        if (state->skip_fw_load)
+                return 0;
+        /* Load firmware */
+        /* request the firmware, this will block until someone uploads it */
+        printk(KERN_INFO "%s: Waiting for firmware upload (%s)...\n", __func__,
+                                DS3000_DEFAULT_FIRMWARE);
+        ret = request_firmware(&fw, DS3000_DEFAULT_FIRMWARE,
+                                state->i2c->dev.parent);
+        printk(KERN_INFO "%s: Waiting for firmware upload(2)...\n", __func__);
+        if (ret) {
+                printk(KERN_ERR "%s: No firmware uploaded (timeout or file not "
+                                "found?)\n", __func__);
+                return ret;
+        }
+
+        /* Make sure we don't recurse back through here during loading */
+        state->skip_fw_load = 1;
+
+        ret = ds3000_load_firmware(fe, fw);
+        if (ret)
+                printk("%s: Writing firmware to device failed\n", __func__);
+
+        release_firmware(fw);
+
+        dprintk("%s: Firmware upload %s\n", __func__,
+                        ret == 0 ? "complete" : "failed");
+
+        /* Ensure firmware is always loaded if required */
+        state->skip_fw_load = 0;
+
+        return ret;
+}
+
+static int ds3000_load_firmware(struct dvb_frontend *fe,
+                                        const struct firmware *fw)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+
+        dprintk("%s\n", __func__);
+        dprintk("Firmware is %zu bytes (%02x %02x .. %02x %02x)\n",
+                        fw->size,
+                        fw->data[0],
+                        fw->data[1],
+                        fw->data[fw->size - 2],
+                        fw->data[fw->size - 1]);
+
+        /* Begin the firmware load process */
+        ds3000_writereg(state, 0xb2, 0x01);
+        /* write the entire firmware */
+        ds3000_writeFW(state, 0xb0, fw->data, fw->size);
+        ds3000_writereg(state, 0xb2, 0x00);
+
+        return 0;
+}
+
+static void ds3000_dump_registers(struct dvb_frontend *fe)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        int x, y, reg = 0, val;
+
+        for (y = 0; y < 16; y++) {
+                dprintk("%s: %02x: ", __func__, y);
+                for (x = 0; x < 16; x++) {
+                        reg = (y << 4) + x;
+                        val = ds3000_readreg(state, reg);
+                        if (x != 15)
+                                dprintk("%02x ",  val);
+                        else
+                                dprintk("%02x\n", val);
+                }
+        }
+        dprintk("%s: -- DS3000 DUMP DONE --\n", __func__);
+}
+
+static int ds3000_read_status(struct dvb_frontend *fe, fe_status_t* status)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        int lock;
+
+        *status = 0;
+
+        switch (c->delivery_system) {
+        case SYS_DVBS:
+                lock = ds3000_readreg(state, 0xd1);
+                if ((lock & 0x07) == 0x07)
+                        *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
+                                FE_HAS_VITERBI | FE_HAS_SYNC |
+                                FE_HAS_LOCK;
+
+                break;
+        case SYS_DVBS2:
+                lock = ds3000_readreg(state, 0x0d);
+                if ((lock & 0x8f) == 0x8f)
+                        *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
+                                FE_HAS_VITERBI | FE_HAS_SYNC |
+                                FE_HAS_LOCK;
+
+                break;
+        default:
+                return 1;
+        }
+
+        dprintk("%s: status = 0x%02x\n", __func__, lock);
+
+        return 0;
+}
+
+#define FE_IS_TUNED (FE_HAS_SIGNAL + FE_HAS_LOCK)
+static int ds3000_is_tuned(struct dvb_frontend *fe)
+{
+        fe_status_t tunerstat;
+
+        ds3000_read_status(fe, &tunerstat);
+
+        return ((tunerstat & FE_IS_TUNED) == FE_IS_TUNED);
+}
+
+/* read DS3000 BER value */
+static int ds3000_read_ber(struct dvb_frontend *fe, u32* ber)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        u8 data;
+        u32 ber_reading, lpdc_frames;
+
+        dprintk("%s()\n", __func__);
+
+        switch (c->delivery_system) {
+        case SYS_DVBS:
+                /* set the number of bytes checked during
+                BER estimation */
+                ds3000_writereg(state, 0xf9, 0x04);
+                /* read BER estimation status */
+                data = ds3000_readreg(state, 0xf8);
+                /* check if BER estimation is ready */
+                if ((data & 0x10) == 0) {
+                        /* this is the number of error bits,
+                        to calculate the bit error rate
+                        divide to 8388608 */
+                        *ber = (ds3000_readreg(state, 0xf7) << 8) |
+                                ds3000_readreg(state, 0xf6);
+                        /* start counting error bits */
+                        /* need to be set twice
+                        otherwise it fails sometimes */
+                        data |= 0x10;
+                        ds3000_writereg(state, 0xf8, data);
+                        ds3000_writereg(state, 0xf8, data);
+                } else
+                        /* used to indicate that BER estimation
+                        is not ready, i.e. BER is unknown */
+                        *ber = 0xffffffff;
+                break;
+        case SYS_DVBS2:
+                /* read the number of LPDC decoded frames */
+                lpdc_frames = (ds3000_readreg(state, 0xd7) << 16) |
+                                (ds3000_readreg(state, 0xd6) << 8) |
+                                ds3000_readreg(state, 0xd5);
+                /* read the number of packets with bad CRC */
+                ber_reading = (ds3000_readreg(state, 0xf8) << 8) |
+                                ds3000_readreg(state, 0xf7);
+                if (lpdc_frames > 750) {
+                        /* clear LPDC frame counters */
+                        ds3000_writereg(state, 0xd1, 0x01);
+                        /* clear bad packets counter */
+                        ds3000_writereg(state, 0xf9, 0x01);
+                        /* enable bad packets counter */
+                        ds3000_writereg(state, 0xf9, 0x00);
+                        /* enable LPDC frame counters */
+                        ds3000_writereg(state, 0xd1, 0x00);
+                        *ber = ber_reading;
+                } else
+                        /* used to indicate that BER estimation is not ready,
+                        i.e. BER is unknown */
+                        *ber = 0xffffffff;
+                break;
+        default:
+                return 1;
+        }
+
+        return 0;
+}
+
+/* read TS2020 signal strength */
+static int ds3000_read_signal_strength(struct dvb_frontend *fe,
+                                                u16 *signal_strength)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        u16 sig_reading, sig_strength;
+        u8 rfgain, bbgain;
+
+        dprintk("%s()\n", __func__);
+
+        rfgain = ds3000_tuner_readreg(state, 0x3d) & 0x1f;
+        bbgain = ds3000_tuner_readreg(state, 0x21) & 0x1f;
+
+        if (rfgain > 15)
+                rfgain = 15;
+        if (bbgain > 13)
+                bbgain = 13;
+
+        sig_reading = rfgain * 2 + bbgain * 3;
+
+        sig_strength = 40 + (64 - sig_reading) * 50 / 64 ;
+
+        /* cook the value to be suitable for szap-s2 human readable output */
+        *signal_strength = sig_strength * 1000;
+
+        dprintk("%s: raw / cooked = 0x%04x / 0x%04x\n", __func__,
+                        sig_reading, *signal_strength);
+
+        return 0;
+}
+
+/* calculate DS3000 snr value in dB */
+static int ds3000_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        u8 snr_reading, snr_value;
+        u32 dvbs2_signal_reading, dvbs2_noise_reading, tmp;
+        static const u16 dvbs_snr_tab[] = { /* 20 x Table (rounded up) */
+                0x0000, 0x1b13, 0x2aea, 0x3627, 0x3ede, 0x45fe, 0x4c03,
+                0x513a, 0x55d4, 0x59f2, 0x5dab, 0x6111, 0x6431, 0x6717,
+                0x69c9, 0x6c4e, 0x6eac, 0x70e8, 0x7304, 0x7505
+        };
+        static const u16 dvbs2_snr_tab[] = { /* 80 x Table (rounded up) */
+                0x0000, 0x0bc2, 0x12a3, 0x1785, 0x1b4e, 0x1e65, 0x2103,
+                0x2347, 0x2546, 0x2710, 0x28ae, 0x2a28, 0x2b83, 0x2cc5,
+                0x2df1, 0x2f09, 0x3010, 0x3109, 0x31f4, 0x32d2, 0x33a6,
+                0x3470, 0x3531, 0x35ea, 0x369b, 0x3746, 0x37ea, 0x3888,
+                0x3920, 0x39b3, 0x3a42, 0x3acc, 0x3b51, 0x3bd3, 0x3c51,
+                0x3ccb, 0x3d42, 0x3db6, 0x3e27, 0x3e95, 0x3f00, 0x3f68,
+                0x3fcf, 0x4033, 0x4094, 0x40f4, 0x4151, 0x41ac, 0x4206,
+                0x425e, 0x42b4, 0x4308, 0x435b, 0x43ac, 0x43fc, 0x444a,
+                0x4497, 0x44e2, 0x452d, 0x4576, 0x45bd, 0x4604, 0x4649,
+                0x468e, 0x46d1, 0x4713, 0x4755, 0x4795, 0x47d4, 0x4813,
+                0x4851, 0x488d, 0x48c9, 0x4904, 0x493f, 0x4978, 0x49b1,
+                0x49e9, 0x4a20, 0x4a57
+        };
+
+        dprintk("%s()\n", __func__);
+
+        switch (c->delivery_system) {
+        case SYS_DVBS:
+                snr_reading = ds3000_readreg(state, 0xff);
+                snr_reading /= 8;
+                if (snr_reading == 0)
+                        *snr = 0x0000;
+                else {
+                        if (snr_reading > 20)
+                                snr_reading = 20;
+                        snr_value = dvbs_snr_tab[snr_reading - 1] * 10 / 23026;
+                        /* cook the value to be suitable for szap-s2
+                        human readable output */
+                        *snr = snr_value * 8 * 655;
+                }
+                dprintk("%s: raw / cooked = 0x%02x / 0x%04x\n", __func__,
+                                snr_reading, *snr);
+                break;
+        case SYS_DVBS2:
+                dvbs2_noise_reading = (ds3000_readreg(state, 0x8c) & 0x3f) +
+                                (ds3000_readreg(state, 0x8d) << 4);
+                dvbs2_signal_reading = ds3000_readreg(state, 0x8e);
+                tmp = dvbs2_signal_reading * dvbs2_signal_reading >> 1;
+                if (dvbs2_signal_reading == 0) {
+                        *snr = 0x0000;
+                        return 0;
+                }
+                if (dvbs2_noise_reading == 0) {
+                        snr_value = 0x0013;
+                        /* cook the value to be suitable for szap-s2
+                        human readable output */
+                        *snr = 0xffff;
+                        return 0;
+                }
+                if (tmp > dvbs2_noise_reading) {
+                        snr_reading = tmp / dvbs2_noise_reading;
+                        if (snr_reading > 80)
+                                snr_reading = 80;
+                        snr_value = dvbs2_snr_tab[snr_reading - 1] / 1000;
+                        /* cook the value to be suitable for szap-s2
+                        human readable output */
+                        *snr = snr_value * 5 * 655;
+                } else {
+                        snr_reading = dvbs2_noise_reading / tmp;
+                        if (snr_reading > 80)
+                                snr_reading = 80;
+                        *snr = -(dvbs2_snr_tab[snr_reading] / 1000);
+                }
+                dprintk("%s: raw / cooked = 0x%02x / 0x%04x\n", __func__,
+                                snr_reading, *snr);
+                break;
+        default:
+                return 1;
+        }
+
+        return 0;
+}
+
+/* read DS3000 uncorrected blocks */
+static int ds3000_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        u8 data;
+        u16 _ucblocks;
+
+        dprintk("%s()\n", __func__);
+
+        switch (c->delivery_system) {
+        case SYS_DVBS:
+                *ucblocks = (ds3000_readreg(state, 0xf5) << 8) |
+                                ds3000_readreg(state, 0xf4);
+                data = ds3000_readreg(state, 0xf8);
+                /* clear packet counters */
+                data &= ~0x20;
+                ds3000_writereg(state, 0xf8, data);
+                /* enable packet counters */
+                data |= 0x20;
+                ds3000_writereg(state, 0xf8, data);
+                break;
+        case SYS_DVBS2:
+                _ucblocks = (ds3000_readreg(state, 0xe2) << 8) |
+                                ds3000_readreg(state, 0xe1);
+                if (_ucblocks > state->prevUCBS2)
+                        *ucblocks = _ucblocks - state->prevUCBS2;
+                else
+                        *ucblocks = state->prevUCBS2 - _ucblocks;
+                state->prevUCBS2 = _ucblocks;
+                break;
+        default:
+                return 1;
+        }
+
+        return 0;
+}
+
+/* Overwrite the current tuning params, we are about to tune */
+static void ds3000_clone_params(struct dvb_frontend *fe)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        memcpy(&state->dcur, &state->dnxt, sizeof(state->dcur));
+}
+
+static int ds3000_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        u8 data;
+
+        dprintk("%s(%d)\n", __func__, tone);
+        if ((tone != SEC_TONE_ON) && (tone != SEC_TONE_OFF)) {
+                printk(KERN_ERR "%s: Invalid, tone=%d\n", __func__, tone);
+                return -EINVAL;
+        }
+
+        data = ds3000_readreg(state, 0xa2);
+        data &= ~0xc0;
+        ds3000_writereg(state, 0xa2, data);
+
+        switch (tone) {
+        case SEC_TONE_ON:
+                dprintk("%s: setting tone on\n", __func__);
+                data = ds3000_readreg(state, 0xa1);
+                data &= ~0x43;
+                data |= 0x04;
+                ds3000_writereg(state, 0xa1, data);
+                break;
+        case SEC_TONE_OFF:
+                dprintk("%s: setting tone off\n", __func__);
+                data = ds3000_readreg(state, 0xa2);
+                data |= 0x80;
+                ds3000_writereg(state, 0xa2, data);
+                break;
+        }
+
+        return 0;
+}
+
+static int ds3000_send_diseqc_msg(struct dvb_frontend *fe,
+                                struct dvb_diseqc_master_cmd *d)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        int i;
+        u8 data;
+
+        /* Dump DiSEqC message */
+        dprintk("%s(", __func__);
+        for (i = 0 ; i < d->msg_len;) {
+                dprintk("0x%02x", d->msg[i]);
+                if (++i < d->msg_len)
+                        dprintk(", ");
+        }
+
+        /* enable DiSEqC message send pin */
+        data = ds3000_readreg(state, 0xa2);
+        data &= ~0xc0;
+        ds3000_writereg(state, 0xa2, data);
+
+        /* DiSEqC message */
+        for (i = 0; i < d->msg_len; i++)
+                ds3000_writereg(state, 0xa3 + i, d->msg[i]);
+
+        data = ds3000_readreg(state, 0xa1);
+        /* clear DiSEqC message length and status,
+        enable DiSEqC message send */
+        data &= ~0xf8;
+        /* set DiSEqC mode, modulation active during 33 pulses,
+        set DiSEqC message length */
+        data |= ((d->msg_len - 1) << 3) | 0x07;
+        ds3000_writereg(state, 0xa1, data);
+
+        /* wait up to 150ms for DiSEqC transmission to complete */
+        for (i = 0; i < 15; i++) {
+                data = ds3000_readreg(state, 0xa1);
+                if ((data & 0x40) == 0)
+                        break;
+                msleep(10);
+        }
+
+        /* DiSEqC timeout after 150ms */
+        if (i == 15) {
+                data = ds3000_readreg(state, 0xa1);
+                data &= ~0x80;
+                data |= 0x40;
+                ds3000_writereg(state, 0xa1, data);
+
+                data = ds3000_readreg(state, 0xa2);
+                data &= ~0xc0;
+                data |= 0x80;
+                ds3000_writereg(state, 0xa2, data);
+
+                return 1;
+        }
+
+        data = ds3000_readreg(state, 0xa2);
+        data &= ~0xc0;
+        data |= 0x80;
+        ds3000_writereg(state, 0xa2, data);
+
+        return 0;
+}
+
+/* Send DiSEqC burst */
+static int ds3000_diseqc_send_burst(struct dvb_frontend *fe,
+                                        fe_sec_mini_cmd_t burst)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        int i;
+        u8 data;
+
+        dprintk("%s()\n", __func__);
+
+        data = ds3000_readreg(state, 0xa2);
+        data &= ~0xc0;
+        ds3000_writereg(state, 0xa2, data);
+
+        /* DiSEqC burst */
+        if (burst == SEC_MINI_A)
+                /* Unmodulated tone burst */
+                ds3000_writereg(state, 0xa1, 0x02);
+        else if (burst == SEC_MINI_B)
+                /* Modulated tone burst */
+                ds3000_writereg(state, 0xa1, 0x01);
+        else
+                return -EINVAL;
+
+        msleep(13);
+        for (i = 0; i < 5; i++) {
+                data = ds3000_readreg(state, 0xa1);
+                if ((data & 0x40) == 0)
+                        break;
+                msleep(1);
+        }
+
+        if (i == 5) {
+                data = ds3000_readreg(state, 0xa1);
+                data &= ~0x80;
+                data |= 0x40;
+                ds3000_writereg(state, 0xa1, data);
+
+                data = ds3000_readreg(state, 0xa2);
+                data &= ~0xc0;
+                data |= 0x80;
+                ds3000_writereg(state, 0xa2, data);
+
+                return 1;
+        }
+
+        data = ds3000_readreg(state, 0xa2);
+        data &= ~0xc0;
+        data |= 0x80;
+        ds3000_writereg(state, 0xa2, data);
+
+        return 0;
+}
+
+static void ds3000_release(struct dvb_frontend *fe)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        dprintk("%s\n", __func__);
+        kfree(state);
+}
+
+static struct dvb_frontend_ops ds3000_ops;
+
+struct dvb_frontend *ds3000_attach(const struct ds3000_config *config,
+                                    struct i2c_adapter *i2c)
+{
+        struct ds3000_state *state = NULL;
+        int ret;
+
+        dprintk("%s\n", __func__);
+
+        /* allocate memory for the internal state */
+        state = kmalloc(sizeof(struct ds3000_state), GFP_KERNEL);
+        if (state == NULL) {
+                printk(KERN_ERR "Unable to kmalloc\n");
+                goto error2;
+        }
+
+        /* setup the state */
+        memset(state, 0, sizeof(struct ds3000_state));
+
+        state->config = config;
+        state->i2c = i2c;
+        state->prevUCBS2 = 0;
+
+        /* check if the demod is present */
+        ret = ds3000_readreg(state, 0x00) & 0xfe;
+        if (ret != 0xe0) {
+                printk(KERN_ERR "Invalid probe, probably not a DS3000\n");
+                goto error3;
+        }
+
+        printk(KERN_INFO "DS3000 chip version: %d.%d attached.\n",
+                        ds3000_readreg(state, 0x02),
+                        ds3000_readreg(state, 0x01));
+
+        memcpy(&state->frontend.ops, &ds3000_ops,
+                        sizeof(struct dvb_frontend_ops));
+        state->frontend.demodulator_priv = state;
+        return &state->frontend;
+
+error3:
+        kfree(state);
+error2:
+        return NULL;
+}
+EXPORT_SYMBOL(ds3000_attach);
+
+static int ds3000_set_property(struct dvb_frontend *fe,
+        struct dtv_property *tvp)
+{
+        dprintk("%s(..)\n", __func__);
+        return 0;
+}
+
+static int ds3000_get_property(struct dvb_frontend *fe,
+        struct dtv_property *tvp)
+{
+        dprintk("%s(..)\n", __func__);
+        return 0;
+}
+
+static int ds3000_tune(struct dvb_frontend *fe,
+                                struct dvb_frontend_parameters *p)
+{
+        struct ds3000_state *state = fe->demodulator_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+
+        int ret = 0, retune, i;
+        u8 status, mlpf, mlpf_new, mlpf_max, mlpf_min, nlpf;
+        u16 value, ndiv;
+        u32 f3db;
+
+        dprintk("%s() ", __func__);
+
+        /* Load the firmware if required */
+        ret = ds3000_firmware_ondemand(fe);
+        if (ret != 0) {
+                printk(KERN_ERR "%s: Unable initialise the firmware\n",
+                                                                __func__);
+                return ret;
+        }
+
+        state->dnxt.delivery = c->modulation;
+        state->dnxt.frequency = c->frequency;
+        state->dnxt.rolloff = 2; /* fixme */
+        state->dnxt.fec = c->fec_inner;
+
+        ret = ds3000_set_inversion(state, p->inversion);
+        if (ret !=  0)
+                return ret;
+
+        ret = ds3000_set_symbolrate(state, c->symbol_rate);
+        if (ret !=  0)
+                return ret;
+
+        /* discard the 'current' tuning parameters and prepare to tune */
+        ds3000_clone_params(fe);
+
+        retune = 1;     /* try 1 times */
+        dprintk("%s:   retune = %d\n", __func__, retune);
+        dprintk("%s:   frequency   = %d\n", __func__, state->dcur.frequency);
+        dprintk("%s:   symbol_rate = %d\n", __func__, state->dcur.symbol_rate);
+        dprintk("%s:   FEC       = %d \n", __func__,
+                state->dcur.fec);
+        dprintk("%s:   Inversion   = %d\n", __func__, state->dcur.inversion);
+
+        do {
+                /* Reset status register */
+                status = 0;
+                /* Tune */
+                /* TS2020 init */
+                ds3000_tuner_writereg(state, 0x42, 0x73);
+                ds3000_tuner_writereg(state, 0x05, 0x01);
+                ds3000_tuner_writereg(state, 0x62, 0xf5);
+                /* unknown */
+                ds3000_tuner_writereg(state, 0x07, 0x02);
+                ds3000_tuner_writereg(state, 0x10, 0x00);
+                ds3000_tuner_writereg(state, 0x60, 0x79);
+                ds3000_tuner_writereg(state, 0x08, 0x01);
+                ds3000_tuner_writereg(state, 0x00, 0x01);
+                /* calculate and set freq divider */
+                if (state->dcur.frequency < 1146000) {
+                        ds3000_tuner_writereg(state, 0x10, 0x11);
+                        ndiv = ((state->dcur.frequency * (6 + 8) * 4) +
+                                        (DS3000_XTAL_FREQ / 2)) /
+                                        DS3000_XTAL_FREQ - 1024;
+                } else {
+                        ds3000_tuner_writereg(state, 0x10, 0x01);
+                        ndiv = ((state->dcur.frequency * (6 + 8) * 2) +
+                                        (DS3000_XTAL_FREQ / 2)) /
+                                        DS3000_XTAL_FREQ - 1024;
+                }
+
+                ds3000_tuner_writereg(state, 0x01, (ndiv & 0x0f00) >> 8);
+                ds3000_tuner_writereg(state, 0x02, ndiv & 0x00ff);
+
+                /* set pll */
+                ds3000_tuner_writereg(state, 0x03, 0x06);
+                ds3000_tuner_writereg(state, 0x51, 0x0f);
+                ds3000_tuner_writereg(state, 0x51, 0x1f);
+                ds3000_tuner_writereg(state, 0x50, 0x10);
+                ds3000_tuner_writereg(state, 0x50, 0x00);
+                msleep(5);
+
+                /* unknown */
+                ds3000_tuner_writereg(state, 0x51, 0x17);
+                ds3000_tuner_writereg(state, 0x51, 0x1f);
+                ds3000_tuner_writereg(state, 0x50, 0x08);
+                ds3000_tuner_writereg(state, 0x50, 0x00);
+                msleep(5);
+
+                value = ds3000_tuner_readreg(state, 0x3d);
+                value &= 0x0f;
+                if ((value > 4) && (value < 15)) {
+                        value -= 3;
+                        if (value < 4)
+                                value = 4;
+                        value = ((value << 3) | 0x01) & 0x79;
+                }
+
+                ds3000_tuner_writereg(state, 0x60, value);
+                ds3000_tuner_writereg(state, 0x51, 0x17);
+                ds3000_tuner_writereg(state, 0x51, 0x1f);
+                ds3000_tuner_writereg(state, 0x50, 0x08);
+                ds3000_tuner_writereg(state, 0x50, 0x00);
+
+                /* set low-pass filter period */
+                ds3000_tuner_writereg(state, 0x04, 0x2e);
+                ds3000_tuner_writereg(state, 0x51, 0x1b);
+                ds3000_tuner_writereg(state, 0x51, 0x1f);
+                ds3000_tuner_writereg(state, 0x50, 0x04);
+                ds3000_tuner_writereg(state, 0x50, 0x00);
+                msleep(5);
+
+                f3db = ((state->dcur.symbol_rate / 1000) << 2) / 5 + 2000;
+                if ((state->dcur.symbol_rate / 1000) < 5000)
+                        f3db += 3000;
+                if (f3db < 7000)
+                        f3db = 7000;
+                if (f3db > 40000)
+                        f3db = 40000;
+
+                /* set low-pass filter baseband */
+                value = ds3000_tuner_readreg(state, 0x26);
+                mlpf = 0x2e * 207 / ((value << 1) + 151);
+                mlpf_max = mlpf * 135 / 100;
+                mlpf_min = mlpf * 78 / 100;
+                if (mlpf_max > 63)
+                        mlpf_max = 63;
+
+                /* rounded to the closest integer */
+                nlpf = ((mlpf * f3db * 1000) + (2766 * DS3000_XTAL_FREQ / 2))
+                                / (2766 * DS3000_XTAL_FREQ);
+                if (nlpf > 23)
+                        nlpf = 23;
+                if (nlpf < 1)
+                        nlpf = 1;
+
+                /* rounded to the closest integer */
+                mlpf_new = ((DS3000_XTAL_FREQ * nlpf * 2766) +
+                                (1000 * f3db / 2)) / (1000 * f3db);
+
+                if (mlpf_new < mlpf_min) {
+                        nlpf++;
+                        mlpf_new = ((DS3000_XTAL_FREQ * nlpf * 2766) +
+                                        (1000 * f3db / 2)) / (1000 * f3db);
+                }
+
+                if (mlpf_new > mlpf_max)
+                        mlpf_new = mlpf_max;
+
+                ds3000_tuner_writereg(state, 0x04, mlpf_new);
+                ds3000_tuner_writereg(state, 0x06, nlpf);
+                ds3000_tuner_writereg(state, 0x51, 0x1b);
+                ds3000_tuner_writereg(state, 0x51, 0x1f);
+                ds3000_tuner_writereg(state, 0x50, 0x04);
+                ds3000_tuner_writereg(state, 0x50, 0x00);
+                msleep(5);
+
+                /* unknown */
+                ds3000_tuner_writereg(state, 0x51, 0x1e);
+                ds3000_tuner_writereg(state, 0x51, 0x1f);
+                ds3000_tuner_writereg(state, 0x50, 0x01);
+                ds3000_tuner_writereg(state, 0x50, 0x00);
+                msleep(60);
+
+                /* ds3000 global reset */
+                ds3000_writereg(state, 0x07, 0x80);
+                ds3000_writereg(state, 0x07, 0x00);
+                /* ds3000 build-in uC reset */
+                ds3000_writereg(state, 0xb2, 0x01);
+                /* ds3000 software reset */
+                ds3000_writereg(state, 0x00, 0x01);
+
+                switch (c->delivery_system) {
+                case SYS_DVBS:
+                        /* initialise the demod in DVB-S mode */
+                        for (i = 0; i < sizeof(ds3000_dvbs_init_tab); i += 2)
+                                ds3000_writereg(state,
+                                        ds3000_dvbs_init_tab[i],
+                                        ds3000_dvbs_init_tab[i + 1]);
+                        value = ds3000_readreg(state, 0xfe);
+                        value &= 0xc0;
+                        value |= 0x1b;
+                        ds3000_writereg(state, 0xfe, value);
+                        break;
+                case SYS_DVBS2:
+                        /* initialise the demod in DVB-S2 mode */
+                        for (i = 0; i < sizeof(ds3000_dvbs2_init_tab); i += 2)
+                                ds3000_writereg(state,
+                                        ds3000_dvbs2_init_tab[i],
+                                        ds3000_dvbs2_init_tab[i + 1]);
+                        ds3000_writereg(state, 0xfe, 0x54);
+                        break;
+                default:
+                        return 1;
+                }
+
+                /* enable 27MHz clock output */
+                ds3000_writereg(state, 0x29, 0x80);
+                /* enable ac coupling */
+                ds3000_writereg(state, 0x25, 0x8a);
+
+                /* enhance symbol rate performance */
+                if ((state->dcur.symbol_rate / 1000) <= 5000) {
+                        value = 29777 / (state->dcur.symbol_rate / 1000) + 1;
+                        if (value % 2 != 0)
+                                value++;
+                        ds3000_writereg(state, 0xc3, 0x0d);
+                        ds3000_writereg(state, 0xc8, value);
+                        ds3000_writereg(state, 0xc4, 0x10);
+                        ds3000_writereg(state, 0xc7, 0x0e);
+                } else if ((state->dcur.symbol_rate / 1000) <= 10000) {
+                        value = 92166 / (state->dcur.symbol_rate / 1000) + 1;
+                        if (value % 2 != 0)
+                                value++;
+                        ds3000_writereg(state, 0xc3, 0x07);
+                        ds3000_writereg(state, 0xc8, value);
+                        ds3000_writereg(state, 0xc4, 0x09);
+                        ds3000_writereg(state, 0xc7, 0x12);
+                } else if ((state->dcur.symbol_rate / 1000) <= 20000) {
+                        value = 64516 / (state->dcur.symbol_rate / 1000) + 1;
+                        ds3000_writereg(state, 0xc3, value);
+                        ds3000_writereg(state, 0xc8, 0x0e);
+                        ds3000_writereg(state, 0xc4, 0x07);
+                        ds3000_writereg(state, 0xc7, 0x18);
+                } else {
+                        value = 129032 / (state->dcur.symbol_rate / 1000) + 1;
+                        ds3000_writereg(state, 0xc3, value);
+                        ds3000_writereg(state, 0xc8, 0x0a);
+                        ds3000_writereg(state, 0xc4, 0x05);
+                        ds3000_writereg(state, 0xc7, 0x24);
+                }
+
+                /* normalized symbol rate rounded to the closest integer */
+                value = (((state->dcur.symbol_rate / 1000) << 16) +
+                                (DS3000_SAMPLE_RATE / 2)) / DS3000_SAMPLE_RATE;
+                ds3000_writereg(state, 0x61, value & 0x00ff);
+                ds3000_writereg(state, 0x62, (value & 0xff00) >> 8);
+
+                /* co-channel interference cancellation disabled */
+                ds3000_writereg(state, 0x56, 0x00);
+
+                /* equalizer disabled */
+                ds3000_writereg(state, 0x76, 0x00);
+
+                /*ds3000_writereg(state, 0x08, 0x03);
+                ds3000_writereg(state, 0xfd, 0x22);
+                ds3000_writereg(state, 0x08, 0x07);
+                ds3000_writereg(state, 0xfd, 0x42);
+                ds3000_writereg(state, 0x08, 0x07);*/
+
+                /* ds3000 out of software reset */
+                ds3000_writereg(state, 0x00, 0x00);
+                /* start ds3000 build-in uC */
+                ds3000_writereg(state, 0xb2, 0x00);
+
+                /* TODO: calculate and set carrier offset */
+
+                /* wait before retrying */
+                for (i = 0; i < 30 ; i++) {
+                        if (ds3000_is_tuned(fe)) {
+                                dprintk("%s: Tuned\n", __func__);
+                                ds3000_dump_registers(fe);
+                                goto tuned;
+                        }
+                        msleep(1);
+                }
+
+                dprintk("%s: Not tuned\n", __func__);
+                ds3000_dump_registers(fe);
+
+        } while (--retune);
+
+tuned:
+        return ret;
+}
+
+static enum dvbfe_algo ds3000_get_algo(struct dvb_frontend *fe)
+{
+        dprintk("%s()\n", __func__);
+        return DVBFE_ALGO_SW;
+}
+
+/*
+ * Initialise or wake up device
+ *
+ * Power config will reset and load initial firmware if required
+ */
+static int ds3000_initfe(struct dvb_frontend *fe)
+{
+        dprintk("%s()\n", __func__);
+        return 0;
+}
+
+/* Put device to sleep */
+static int ds3000_sleep(struct dvb_frontend *fe)
+{
+        dprintk("%s()\n", __func__);
+        return 0;
+}
+
+static struct dvb_frontend_ops ds3000_ops = {
+
+        .info = {
+                .name = "Montage Technology DS3000/TS2020",
+                .type = FE_QPSK,
+                .frequency_min = 950000,
+                .frequency_max = 2150000,
+                .frequency_stepsize = 1011, /* kHz for QPSK frontends */
+                .frequency_tolerance = 5000,
+                .symbol_rate_min = 1000000,
+                .symbol_rate_max = 45000000,
+                .caps = FE_CAN_INVERSION_AUTO |
+                        FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                        FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
+                        FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                        FE_CAN_2G_MODULATION |
+                        FE_CAN_QPSK | FE_CAN_RECOVER
+        },
+
+        .release = ds3000_release,
+
+        .init = ds3000_initfe,
+        .sleep = ds3000_sleep,
+        .read_status = ds3000_read_status,
+        .read_ber = ds3000_read_ber,
+        .read_signal_strength = ds3000_read_signal_strength,
+        .read_snr = ds3000_read_snr,
+        .read_ucblocks = ds3000_read_ucblocks,
+        .set_tone = ds3000_set_tone,
+        .diseqc_send_master_cmd = ds3000_send_diseqc_msg,
+        .diseqc_send_burst = ds3000_diseqc_send_burst,
+        .get_frontend_algo = ds3000_get_algo,
+
+        .set_property = ds3000_set_property,
+        .get_property = ds3000_get_property,
+        .set_frontend = ds3000_tune,
+};
+
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
+
+MODULE_DESCRIPTION("DVB Frontend module for Montage Technology "
+                        "DS3000/TS2020 hardware");
+MODULE_AUTHOR("Konstantin Dimitrov");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/ds3000.h b/drivers/media/dvb/frontends/ds3000.h
new file mode 100644
index 000000000000..67f67038740a
--- /dev/null
+++ b/drivers/media/dvb/frontends/ds3000.h
@@ -0,0 +1,45 @@
+/*
+    Montage Technology DS3000/TS2020 - DVBS/S2 Satellite demod/tuner driver
+    Copyright (C) 2009 Konstantin Dimitrov <kosio.dimitrov@gmail.com>
+
+    Copyright (C) 2009 TurboSight.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef DS3000_H
+#define DS3000_H
+
+#include <linux/dvb/frontend.h>
+
+struct ds3000_config {
+        /* the demodulator's i2c address */
+        u8 demod_address;
+};
+
+#if defined(CONFIG_DVB_DS3000) || \
+                        (defined(CONFIG_DVB_DS3000_MODULE) && defined(MODULE))
+extern struct dvb_frontend *ds3000_attach(const struct ds3000_config *config,
+                                        struct i2c_adapter *i2c);
+#else
+static inline
+struct dvb_frontend *ds3000_attach(const struct ds3000_config *config,
+                                        struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+#endif /* CONFIG_DVB_DS3000 */
+#endif /* DS3000_H */
diff --git a/drivers/media/video/cx23885/Kconfig b/drivers/media/video/cx23885/Kconfig
index fd3fc3e3198a..bcdda9a9aa96 100644
--- a/drivers/media/video/cx23885/Kconfig
+++ b/drivers/media/video/cx23885/Kconfig
@@ -18,7 +18,9 @@ config VIDEO_CX23885
         select DVB_TDA10048 if !DVB_FE_CUSTOMISE
         select DVB_LNBP21 if !DVB_FE_CUSTOMISE
         select DVB_STV6110 if !DVB_FE_CUSTOMISE
+        select DVB_CX24116 if !DVB_FE_CUSTOMISE
         select DVB_STV0900 if !DVB_FE_CUSTOMISE
+        select DVB_DS3000 if !DVB_FE_CUSTOMISE
         select MEDIA_TUNER_MT2131 if !MEDIA_TUNER_CUSTOMISE
         select MEDIA_TUNER_XC2028 if !MEDIA_TUNER_CUSTOMISE
         select MEDIA_TUNER_TDA8290 if !MEDIA_TUNER_CUSTOMISE
diff --git a/drivers/media/video/cx23885/Makefile b/drivers/media/video/cx23885/Makefile
index bb462589b53b..5787ae243631 100644
--- a/drivers/media/video/cx23885/Makefile
+++ b/drivers/media/video/cx23885/Makefile
@@ -1,7 +1,7 @@
 cx23885-objs    := cx23885-cards.o cx23885-video.o cx23885-vbi.o \
                     cx23885-core.o cx23885-i2c.o cx23885-dvb.o cx23885-417.o \
                     cx23885-ioctl.o cx23885-ir.o cx23885-input.o cx23888-ir.o \
-                    netup-init.o cimax2.o netup-eeprom.o
+                    netup-init.o cimax2.o netup-eeprom.o cx23885-f300.o
 
 obj-$(CONFIG_VIDEO_CX23885) += cx23885.o
 
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index 23302ddf4187..1ec48169277d 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -782,10 +782,14 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 cx_set(GP0_IO, 0x00040004);
                 break;
         case CX23885_BOARD_TBS_6920:
-        case CX23885_BOARD_TEVII_S470:
                 cx_write(MC417_CTL, 0x00000036);
                 cx_write(MC417_OEN, 0x00001000);
-                cx_write(MC417_RWD, 0x00001800);
+                cx_set(MC417_RWD, 0x00000002);
+                mdelay(200);
+                cx_clear(MC417_RWD, 0x00000800);
+                mdelay(200);
+                cx_set(MC417_RWD, 0x00000800);
+                mdelay(200);
                 break;
         case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
                 /* GPIO-0 INTA from CiMax1
@@ -1002,8 +1006,12 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 ts2->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts2->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
                 break;
-        case CX23885_BOARD_TEVII_S470:
         case CX23885_BOARD_TBS_6920:
+                ts1->gen_ctrl_val  = 0x4; /* Parallel */
+                ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
+                ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
+                break;
+        case CX23885_BOARD_TEVII_S470:
         case CX23885_BOARD_DVBWORLD_2005:
                 ts1->gen_ctrl_val  = 0x5; /* Parallel */
                 ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
diff --git a/drivers/media/video/cx23885/cx23885-core.c b/drivers/media/video/cx23885/cx23885-core.c
index e8eb4ec0c30a..04b12d27bc13 100644
--- a/drivers/media/video/cx23885/cx23885-core.c
+++ b/drivers/media/video/cx23885/cx23885-core.c
@@ -1871,6 +1871,26 @@ void cx23885_gpio_clear(struct cx23885_dev *dev, u32 mask)
                 printk(KERN_INFO "%s: Unsupported\n", dev->name);
 }
 
+u32 cx23885_gpio_get(struct cx23885_dev *dev, u32 mask)
+{
+        if (mask & 0x00000007)
+                return (cx_read(GP0_IO) >> 8) & mask & 0x7;
+
+        if (mask & 0x0007fff8) {
+                if (encoder_on_portb(dev) || encoder_on_portc(dev))
+                        printk(KERN_ERR
+                                "%s: Reading GPIO moving on encoder ports\n",
+                                dev->name);
+                return (cx_read(MC417_RWD) & ((mask & 0x7fff8) >> 3)) << 3;
+        }
+
+        /* TODO: 23-19 */
+        if (mask & 0x00f80000)
+                printk(KERN_INFO "%s: Unsupported\n", dev->name);
+
+        return 0;
+}
+
 void cx23885_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput)
 {
         if ((mask & 0x00000007) && asoutput)
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index bf24e86293c6..2607de134fa6 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -56,6 +56,8 @@
 #include "netup-init.h"
 #include "lgdt3305.h"
 #include "atbm8830.h"
+#include "ds3000.h"
+#include "cx23885-f300.h"
 
 static unsigned int debug;
 
@@ -427,26 +429,12 @@ static struct stv6110_config netup_stv6110_tunerconfig_b = {
         .gain = 8, /* +16 dB  - maximum gain */
 };
 
-static int tbs_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
-{
-        struct cx23885_tsport *port = fe->dvb->priv;
-        struct cx23885_dev *dev = port->dev;
-
-        if (voltage == SEC_VOLTAGE_18)
-                cx_write(MC417_RWD, 0x00001e00);/* GPIO-13 high */
-        else if (voltage == SEC_VOLTAGE_13)
-                cx_write(MC417_RWD, 0x00001a00);/* GPIO-13 low */
-        else
-                cx_write(MC417_RWD, 0x00001800);/* GPIO-12 low */
-        return 0;
-}
-
 static struct cx24116_config tbs_cx24116_config = {
-        .demod_address = 0x05,
+        .demod_address = 0x55,
 };
 
-static struct cx24116_config tevii_cx24116_config = {
-        .demod_address = 0x55,
+static struct ds3000_config tevii_ds3000_config = {
+        .demod_address = 0x68,
 };
 
 static struct cx24116_config dvbworld_cx24116_config = {
@@ -832,23 +820,23 @@ static int dvb_register(struct cx23885_tsport *port)
                 }
                 break;
         case CX23885_BOARD_TBS_6920:
-                i2c_bus = &dev->i2c_bus[0];
+                i2c_bus = &dev->i2c_bus[1];
 
                 fe0->dvb.frontend = dvb_attach(cx24116_attach,
-                        &tbs_cx24116_config,
-                        &i2c_bus->i2c_adap);
+                                        &tbs_cx24116_config,
+                                        &i2c_bus->i2c_adap);
                 if (fe0->dvb.frontend != NULL)
-                        fe0->dvb.frontend->ops.set_voltage = tbs_set_voltage;
+                        fe0->dvb.frontend->ops.set_voltage = f300_set_voltage;
 
                 break;
         case CX23885_BOARD_TEVII_S470:
                 i2c_bus = &dev->i2c_bus[1];
 
-                fe0->dvb.frontend = dvb_attach(cx24116_attach,
-                        &tevii_cx24116_config,
-                        &i2c_bus->i2c_adap);
+                fe0->dvb.frontend = dvb_attach(ds3000_attach,
+                                        &tevii_ds3000_config,
+                                        &i2c_bus->i2c_adap);
                 if (fe0->dvb.frontend != NULL)
-                        fe0->dvb.frontend->ops.set_voltage = tbs_set_voltage;
+                        fe0->dvb.frontend->ops.set_voltage = f300_set_voltage;
 
                 break;
         case CX23885_BOARD_DVBWORLD_2005:
diff --git a/drivers/media/video/cx23885/cx23885-f300.c b/drivers/media/video/cx23885/cx23885-f300.c
new file mode 100644
index 000000000000..93998f220986
--- /dev/null
+++ b/drivers/media/video/cx23885/cx23885-f300.c
@@ -0,0 +1,177 @@
+/*
+ * Driver for Silicon Labs C8051F300 microcontroller.
+ *
+ * It is used for LNB power control in TeVii S470,
+ * TBS 6920 PCIe DVB-S2 cards.
+ *
+ * Microcontroller connected to cx23885 GPIO pins:
+ * GPIO0 - data         - P0.3 F300
+ * GPIO1 - reset        - P0.2 F300
+ * GPIO2 - clk          - P0.1 F300
+ * GPIO3 - busy         - P0.0 F300
+ *
+ * Copyright (C) 2009 Igor M. Liplianin <liplianin@me.by>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "cx23885.h"
+
+#define F300_DATA       GPIO_0
+#define F300_RESET      GPIO_1
+#define F300_CLK        GPIO_2
+#define F300_BUSY       GPIO_3
+
+static void f300_set_line(struct cx23885_dev *dev, u32 line, u8 lvl)
+{
+        cx23885_gpio_enable(dev, line, 1);
+        if (lvl == 1)
+                cx23885_gpio_set(dev, line);
+        else
+                cx23885_gpio_clear(dev, line);
+}
+
+static u8 f300_get_line(struct cx23885_dev *dev, u32 line)
+{
+        cx23885_gpio_enable(dev, line, 0);
+
+        return cx23885_gpio_get(dev, line);
+}
+
+static void f300_send_byte(struct cx23885_dev *dev, u8 dta)
+{
+        u8 i;
+
+        for (i = 0; i < 8; i++) {
+                f300_set_line(dev, F300_CLK, 0);
+                udelay(30);
+                f300_set_line(dev, F300_DATA, (dta & 0x80) >> 7);/* msb first */
+                udelay(30);
+                dta <<= 1;
+                f300_set_line(dev, F300_CLK, 1);
+                udelay(30);
+        }
+}
+
+static u8 f300_get_byte(struct cx23885_dev *dev)
+{
+        u8 i, dta = 0;
+
+        for (i = 0; i < 8; i++) {
+                f300_set_line(dev, F300_CLK, 0);
+                udelay(30);
+                dta <<= 1;
+                f300_set_line(dev, F300_CLK, 1);
+                udelay(30);
+                dta |= f300_get_line(dev, F300_DATA);/* msb first */
+
+        }
+
+        return dta;
+}
+
+static u8 f300_xfer(struct dvb_frontend *fe, u8 *buf)
+{
+        struct cx23885_tsport *port = fe->dvb->priv;
+        struct cx23885_dev *dev = port->dev;
+        u8 i, temp, ret = 0;
+
+        temp = buf[0];
+        for (i = 0; i < buf[0]; i++)
+                temp += buf[i + 1];
+        temp = (~temp + 1);/* get check sum */
+        buf[1 + buf[0]] = temp;
+
+        f300_set_line(dev, F300_RESET, 1);
+        f300_set_line(dev, F300_CLK, 1);
+        udelay(30);
+        f300_set_line(dev, F300_DATA, 1);
+        msleep(1);
+
+        /* question: */
+        f300_set_line(dev, F300_RESET, 0);/* begin to send data */
+        msleep(1);
+
+        f300_send_byte(dev, 0xe0);/* the slave address is 0xe0, write */
+        msleep(1);
+
+        temp = buf[0];
+        temp += 2;
+        for (i = 0; i < temp; i++)
+                f300_send_byte(dev, buf[i]);
+
+        f300_set_line(dev, F300_RESET, 1);/* sent data over */
+        f300_set_line(dev, F300_DATA, 1);
+
+        /* answer: */
+        temp = 0;
+        for (i = 0; ((i < 8) & (temp == 0)); i++) {
+                msleep(1);
+                if (f300_get_line(dev, F300_BUSY) == 0)
+                        temp = 1;
+        }
+
+        if (i > 7) {
+                printk(KERN_ERR "%s: timeout, the slave no response\n",
+                                                                __func__);
+                ret = 1; /* timeout, the slave no response */
+        } else { /* the slave not busy, prepare for getting data */
+                f300_set_line(dev, F300_RESET, 0);/*ready...*/
+                msleep(1);
+                f300_send_byte(dev, 0xe1);/* 0xe1 is Read */
+                msleep(1);
+                temp = f300_get_byte(dev);/*get the data length */
+                if (temp > 14)
+                        temp = 14;
+
+                for (i = 0; i < (temp + 1); i++)
+                        f300_get_byte(dev);/* get data to empty buffer */
+
+                f300_set_line(dev, F300_RESET, 1);/* received data over */
+                f300_set_line(dev, F300_DATA, 1);
+        }
+
+        return ret;
+}
+
+int f300_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+        u8 buf[16];
+
+        buf[0] = 0x05;
+        buf[1] = 0x38;/* write port */
+        buf[2] = 0x01;/* A port, lnb power */
+
+        switch (voltage) {
+        case SEC_VOLTAGE_13:
+                buf[3] = 0x01;/* power on */
+                buf[4] = 0x02;/* B port, H/V */
+                buf[5] = 0x00;/*13V v*/
+                break;
+        case SEC_VOLTAGE_18:
+                buf[3] = 0x01;
+                buf[4] = 0x02;
+                buf[5] = 0x01;/* 18V h*/
+                break;
+        case SEC_VOLTAGE_OFF:
+                buf[3] = 0x00;/* power off */
+                buf[4] = 0x00;
+                buf[5] = 0x00;
+                break;
+        }
+
+        return f300_xfer(fe, buf);
+}
diff --git a/drivers/media/video/cx23885/cx23885-f300.h b/drivers/media/video/cx23885/cx23885-f300.h
new file mode 100644
index 000000000000..e73344c94963
--- /dev/null
+++ b/drivers/media/video/cx23885/cx23885-f300.h
@@ -0,0 +1,2 @@
+extern int f300_set_voltage(struct dvb_frontend *fe,
+                                fe_sec_voltage_t voltage);
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index 338320025529..fa744764dc8b 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -471,6 +471,7 @@ extern void cx23885_wakeup(struct cx23885_tsport *port,
 
 extern void cx23885_gpio_set(struct cx23885_dev *dev, u32 mask);
 extern void cx23885_gpio_clear(struct cx23885_dev *dev, u32 mask);
+extern u32 cx23885_gpio_get(struct cx23885_dev *dev, u32 mask);
 extern void cx23885_gpio_enable(struct cx23885_dev *dev, u32 mask,
         int asoutput);