Merge git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/v4l-dvb

* git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/v4l-dvb: (452 commits)
  V4L/DVB (7731): tuner-xc2028: fix signal strength calculus
  V4L/DVB (7730): tuner-xc2028: Fix SCODE load for MTS firmwares
  V4L/DVB (7729): Fix VIDIOCGAP corruption in ivtv
  V4L/DVB (7728): tea5761: bugzilla #10462: tea5761 autodetection code were broken
  V4L/DVB (7726): cx23885: Enable cx23417 support on the HVR1800
  V4L/DVB (7725): cx23885: Add generic cx23417 hardware encoder support
  V4L/DVB (7723): pvrusb2: Clean up input selection list generation in V4L interface
  V4L/DVB (7722): pvrusb2: Implement FM radio support for Gotview USB2.0 DVD 2
  V4L/DVB (7721): pvrusb2: Restructure cx23416 firmware loading to have a common exit point
  V4L/DVB (7720): pvrusb2: Fix bad error code on cx23416 firmware load failure
  V4L/DVB (7719): pvrusb2: Implement input selection enforcement
  V4L/DVB (7718): pvrusb2-dvb: update Kbuild selections
  V4L/DVB (7717): pvrusb2-dvb: add DVB-T support for Hauppauge pvrusb2 model 73xxx
  V4L/DVB (7716): pvrusb2: clean up global functions
  V4L/DVB (7715): pvrusb2: Clean out all use of __FUNCTION__
  V4L/DVB (7714): pvrusb2: Fix hang on module removal
  V4L/DVB (7713): pvrusb2: Implement cleaner DVB kernel thread shutdown
  V4L/DVB (7712): pvrusb2: Close connect/disconnect race
  V4L/DVB (7711): pvrusb2: Fix race on module unload
  V4L/DVB (7710): pvrusb2: Implement critical digital streaming quirk for onair devices
  ...

168 files changed, 5505 insertions, 1942 deletions

diff --git a/drivers/media/dvb/b2c2/Kconfig b/drivers/media/dvb/b2c2/Kconfig
index 3197aeb61d1f..6ec5afba1ca7 100644
--- a/drivers/media/dvb/b2c2/Kconfig
+++ b/drivers/media/dvb/b2c2/Kconfig
@@ -9,6 +9,11 @@ config DVB_B2C2_FLEXCOP
         select DVB_STV0297 if !DVB_FE_CUSTOMISE
         select DVB_BCM3510 if !DVB_FE_CUSTOMISE
         select DVB_LGDT330X if !DVB_FE_CUSTOMISE
+        select TUNER_SIMPLE if !DVB_FE_CUSTOMISE
+        select DVB_S5H1420 if !DVB_FE_CUSTOMISE
+        select DVB_TUNER_ITD1000 if !DVB_FE_CUSTOMISE
+        select DVB_ISL6421 if !DVB_FE_CUSTOMISE
+        select DVB_CX24123 if !DVB_FE_CUSTOMISE
         help
           Support for the digital TV receiver chip made by B2C2 Inc. included in
           Technisats PCI cards and USB boxes.
diff --git a/drivers/media/dvb/b2c2/Makefile b/drivers/media/dvb/b2c2/Makefile
index e97ff60a1eff..870e2848c296 100644
--- a/drivers/media/dvb/b2c2/Makefile
+++ b/drivers/media/dvb/b2c2/Makefile
@@ -2,6 +2,7 @@ b2c2-flexcop-objs = flexcop.o flexcop-fe-tuner.o flexcop-i2c.o \
         flexcop-sram.o flexcop-eeprom.o flexcop-misc.o flexcop-hw-filter.o
 obj-$(CONFIG_DVB_B2C2_FLEXCOP) += b2c2-flexcop.o
 
+
 ifneq ($(CONFIG_DVB_B2C2_FLEXCOP_PCI),)
 b2c2-flexcop-objs += flexcop-dma.o
 endif
@@ -13,3 +14,4 @@ b2c2-flexcop-usb-objs = flexcop-usb.o
 obj-$(CONFIG_DVB_B2C2_FLEXCOP_USB) += b2c2-flexcop-usb.o
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/
+EXTRA_CFLAGS += -Idrivers/media/video/
diff --git a/drivers/media/dvb/b2c2/flexcop-common.h b/drivers/media/dvb/b2c2/flexcop-common.h
index 5a6c4fe249e7..8ce06336e76f 100644
--- a/drivers/media/dvb/b2c2/flexcop-common.h
+++ b/drivers/media/dvb/b2c2/flexcop-common.h
@@ -44,6 +44,14 @@ struct flexcop_dma {
         u32 size; /* size of each address in bytes */
 };
 
+struct flexcop_i2c_adapter {
+        struct flexcop_device *fc;
+        struct i2c_adapter i2c_adap;
+
+        u8 no_base_addr;
+        flexcop_i2c_port_t port;
+};
+
 /* Control structure for data definitions that are common to
  * the B2C2-based PCI and USB devices.
  */
@@ -72,7 +80,7 @@ struct flexcop_device {
         struct dmx_frontend mem_frontend;
         int (*fe_sleep) (struct dvb_frontend *);
 
-        struct i2c_adapter i2c_adap;
+        struct flexcop_i2c_adapter fc_i2c_adap[3];
         struct mutex i2c_mutex;
         struct module *owner;
 
@@ -87,7 +95,8 @@ struct flexcop_device {
         int               (*write_ibi_reg) (struct flexcop_device *, flexcop_ibi_register, flexcop_ibi_value);
 
 
-        int (*i2c_request) (struct flexcop_device*, flexcop_access_op_t, flexcop_i2c_port_t, u8 chipaddr, u8 addr, u8 *buf, u16 len);
+        int (*i2c_request) (struct flexcop_i2c_adapter*,
+                flexcop_access_op_t, u8 chipaddr, u8 addr, u8 *buf, u16 len);
         int (*stream_control) (struct flexcop_device*, int);
 
         int (*get_mac_addr) (struct flexcop_device *fc, int extended);
@@ -128,8 +137,8 @@ int flexcop_eeprom_check_mac_addr(struct flexcop_device *fc, int extended);
  * one. We have it in flexcop-i2c.c, because it is going via the actual
  * I2C-channel of the flexcop.
  */
-int flexcop_i2c_request(struct flexcop_device*, flexcop_access_op_t,
-                        flexcop_i2c_port_t, u8 chipaddr, u8 addr, u8 *buf, u16 len);
+int flexcop_i2c_request(struct flexcop_i2c_adapter*, flexcop_access_op_t,
+        u8 chipaddr, u8 addr, u8 *buf, u16 len);
 
 /* from flexcop-sram.c */
 int flexcop_sram_set_dest(struct flexcop_device *fc, flexcop_sram_dest_t dest, flexcop_sram_dest_target_t target);
diff --git a/drivers/media/dvb/b2c2/flexcop-dma.c b/drivers/media/dvb/b2c2/flexcop-dma.c
index 6f592bc32d22..a91ed28f03a4 100644
--- a/drivers/media/dvb/b2c2/flexcop-dma.c
+++ b/drivers/media/dvb/b2c2/flexcop-dma.c
@@ -112,7 +112,7 @@ static int flexcop_dma_remap(struct flexcop_device *fc,
 {
         flexcop_ibi_register r = (dma_idx & FC_DMA_1) ? dma1_00c : dma2_01c;
         flexcop_ibi_value v = fc->read_ibi_reg(fc,r);
-        deb_info("%s\n",__FUNCTION__);
+        deb_info("%s\n",__func__);
         v.dma_0xc.remap_enable = onoff;
         fc->write_ibi_reg(fc,r,v);
         return 0;
@@ -162,7 +162,7 @@ int flexcop_dma_config_timer(struct flexcop_device *fc,
 
         flexcop_dma_remap(fc,dma_idx,0);
 
-        deb_info("%s\n",__FUNCTION__);
+        deb_info("%s\n",__func__);
         v.dma_0x4_write.dmatimer = cycles;
         fc->write_ibi_reg(fc,r,v);
         return 0;
diff --git a/drivers/media/dvb/b2c2/flexcop-eeprom.c b/drivers/media/dvb/b2c2/flexcop-eeprom.c
index bbcf070a178d..8a8ae8a3e6ba 100644
--- a/drivers/media/dvb/b2c2/flexcop-eeprom.c
+++ b/drivers/media/dvb/b2c2/flexcop-eeprom.c
@@ -114,15 +114,18 @@ static int flexcop_eeprom_request(struct flexcop_device *fc, flexcop_access_op_t
 {
         int i,ret = 0;
         u8 chipaddr =  0x50 | ((addr >> 8) & 3);
-        for (i = 0; i < retries; i++)
-                if ((ret = fc->i2c_request(fc,op,FC_I2C_PORT_EEPROM,chipaddr,addr & 0xff,buf,len)) == 0)
+        for (i = 0; i < retries; i++) {
+                ret = fc->i2c_request(&fc->fc_i2c_adap[1], op, chipaddr,
+                        addr & 0xff, buf, len);
+                if (ret == 0)
                         break;
+        }
         return ret;
 }
 
 static int flexcop_eeprom_lrc_read(struct flexcop_device *fc, u16 addr, u8 *buf, u16 len, int retries)
 {
-        int ret = flexcop_eeprom_request(fc,FC_READ,addr,buf,len,retries);
+        int ret = flexcop_eeprom_request(fc, FC_READ, addr, buf, len, retries);
         if (ret == 0)
                 if (calc_lrc(buf, len - 1) != buf[len - 1])
                         ret = -EINVAL;
diff --git a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
index 0378fd646591..7b0ea3bdfafb 100644
--- a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
+++ b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
@@ -5,6 +5,8 @@
  *
  * see flexcop.c for copyright information.
  */
+#include <media/tuner.h>
+
 #include "flexcop.h"
 
 #include "stv0299.h"
@@ -15,6 +17,15 @@
 #include "mt312.h"
 #include "lgdt330x.h"
 #include "dvb-pll.h"
+#include "tuner-simple.h"
+
+#include "s5h1420.h"
+#include "itd1000.h"
+
+#include "cx24123.h"
+#include "cx24113.h"
+
+#include "isl6421.h"
 
 /* lnb control */
 
@@ -180,13 +191,13 @@ static int samsung_tbmu24112_tuner_set_params(struct dvb_frontend* fe, struct dv
         buf[2] = 0x84;  /* 0xC4 */
         buf[3] = 0x08;
 
-        if (params->frequency < 1500000) buf[3] |= 0x10;
+        if (params->frequency < 1500000)
+                buf[3] |= 0x10;
 
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
-        if (i2c_transfer(&fc->i2c_adap, &msg, 1) != 1) {
+        if (i2c_transfer(&fc->fc_i2c_adap[0].i2c_adap, &msg, 1) != 1)
                 return -EIO;
-        }
         return 0;
 }
 
@@ -241,7 +252,7 @@ static struct stv0299_config samsung_tbmu24112_config = {
         .mclk = 88000000UL,
         .invert = 0,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_LK,
+        .lock_output = STV0299_LOCKOUTPUT_LK,
         .volt13_op0_op1 = STV0299_VOLT13_OP1,
         .min_delay_ms = 100,
         .set_symbol_rate = samsung_tbmu24112_set_symbol_rate,
@@ -337,7 +348,7 @@ static int skystar23_samsung_tbdu18132_tuner_set_params(struct dvb_frontend* fe,
 
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
-        if (i2c_transfer(&fc->i2c_adap, &msg, 1) != 1)
+        if (i2c_transfer(&fc->fc_i2c_adap[0].i2c_adap, &msg, 1) != 1)
                 return -EIO;
         return 0;
 }
@@ -386,10 +397,11 @@ static int alps_tdee4_stv0297_tuner_set_params(struct dvb_frontend* fe,
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 0);
         deb_tuner("tuner buffer for %d Hz: %x %x %x %x\n",fep->frequency, buf[0],buf[1],buf[2],buf[3]);
-        ret = fc->i2c_request(fc, FC_WRITE, FC_I2C_PORT_TUNER, 0x61, buf[0], &buf[1], 3);
+        ret = fc->i2c_request(&fc->fc_i2c_adap[2],
+                FC_WRITE, 0x61, buf[0], &buf[1], 3);
         deb_tuner("tuner write returned: %d\n",ret);
 
-        return 0;
+        return ret;
 }
 
 static u8 alps_tdee4_stv0297_inittab[] = {
@@ -472,56 +484,159 @@ static struct stv0297_config alps_tdee4_stv0297_config = {
 //      .pll_set = alps_tdee4_stv0297_pll_set,
 };
 
+
+/* SkyStar2 rev2.7 (a/u) */
+static struct s5h1420_config skystar2_rev2_7_s5h1420_config = {
+        .demod_address = 0x53,
+        .invert = 1,
+        .repeated_start_workaround = 1,
+};
+
+static struct itd1000_config skystar2_rev2_7_itd1000_config = {
+        .i2c_address = 0x61,
+};
+
+/* SkyStar2 rev2.8 */
+static struct cx24123_config skystar2_rev2_8_cx24123_config = {
+        .demod_address = 0x55,
+        .dont_use_pll = 1,
+        .agc_callback = cx24113_agc_callback,
+};
+
+static const struct cx24113_config skystar2_rev2_8_cx24113_config = {
+        .i2c_addr = 0x54,
+        .xtal_khz = 10111,
+};
+
 /* try to figure out the frontend, each card/box can have on of the following list */
 int flexcop_frontend_init(struct flexcop_device *fc)
 {
         struct dvb_frontend_ops *ops;
+        struct i2c_adapter *i2c = &fc->fc_i2c_adap[0].i2c_adap;
+        struct i2c_adapter *i2c_tuner;
+
+        /* enable no_base_addr - no repeated start when reading */
+        fc->fc_i2c_adap[0].no_base_addr = 1;
+        fc->fe = dvb_attach(s5h1420_attach, &skystar2_rev2_7_s5h1420_config, i2c);
+        if (fc->fe != NULL) {
+                flexcop_ibi_value r108;
+                i2c_tuner = s5h1420_get_tuner_i2c_adapter(fc->fe);
+                ops = &fc->fe->ops;
+
+                fc->fe_sleep = ops->sleep;
+                ops->sleep   = flexcop_sleep;
+
+                fc->dev_type = FC_SKY_REV27;
+
+                /* enable no_base_addr - no repeated start when reading */
+                fc->fc_i2c_adap[2].no_base_addr = 1;
+                if (dvb_attach(isl6421_attach, fc->fe, &fc->fc_i2c_adap[2].i2c_adap, 0x08, 1, 1) == NULL)
+                        err("ISL6421 could NOT be attached");
+                else
+                        info("ISL6421 successfully attached");
+
+                /* the ITD1000 requires a lower i2c clock - it slows down the stuff for everyone - but is it a problem ? */
+                r108.raw = 0x00000506;
+                fc->write_ibi_reg(fc, tw_sm_c_108, r108);
+                if (i2c_tuner) {
+                        if (dvb_attach(itd1000_attach, fc->fe, i2c_tuner, &skystar2_rev2_7_itd1000_config) == NULL)
+                                err("ITD1000 could NOT be attached");
+                        else
+                                info("ITD1000 successfully attached");
+                }
+                goto fe_found;
+        }
+        fc->fc_i2c_adap[0].no_base_addr = 0; /* for the next devices we need it again */
+
+        /* try the sky v2.8 (cx24123, isl6421) */
+        fc->fe = dvb_attach(cx24123_attach,
+                &skystar2_rev2_8_cx24123_config, i2c);
+        if (fc->fe != NULL) {
+                i2c_tuner = cx24123_get_tuner_i2c_adapter(fc->fe);
+                if (i2c_tuner != NULL) {
+                        if (dvb_attach(cx24113_attach, fc->fe,
+                                        &skystar2_rev2_8_cx24113_config,
+                                        i2c_tuner) == NULL)
+                                err("CX24113 could NOT be attached");
+                        else
+                                info("CX24113 successfully attached");
+                }
+
+                fc->dev_type = FC_SKY_REV28;
+
+                fc->fc_i2c_adap[2].no_base_addr = 1;
+                if (dvb_attach(isl6421_attach, fc->fe,
+                       &fc->fc_i2c_adap[2].i2c_adap, 0x08, 0, 0) == NULL)
+                        err("ISL6421 could NOT be attached");
+                else
+                        info("ISL6421 successfully attached");
+
+                /* TODO on i2c_adap[1] addr 0x11 (EEPROM) there seems to be an
+                 * IR-receiver (PIC16F818) - but the card has no input for
+                 * that ??? */
+
+                goto fe_found;
+    }
 
         /* try the sky v2.6 (stv0299/Samsung tbmu24112(sl1935)) */
-        if ((fc->fe = dvb_attach(stv0299_attach, &samsung_tbmu24112_config, &fc->i2c_adap)) != NULL) {
+        fc->fe = dvb_attach(stv0299_attach, &samsung_tbmu24112_config, i2c);
+        if (fc->fe != NULL) {
                 ops = &fc->fe->ops;
 
                 ops->tuner_ops.set_params = samsung_tbmu24112_tuner_set_params;
 
                 ops->set_voltage = flexcop_set_voltage;
 
-                fc->fe_sleep             = ops->sleep;
-                ops->sleep               = flexcop_sleep;
+                fc->fe_sleep = ops->sleep;
+                ops->sleep = flexcop_sleep;
+
+                fc->dev_type = FC_SKY;
+                goto fe_found;
+        }
 
-                fc->dev_type          = FC_SKY;
-                info("found the stv0299 at i2c address: 0x%02x",samsung_tbmu24112_config.demod_address);
-        } else
         /* try the air dvb-t (mt352/Samsung tdtc9251dh0(??)) */
-        if ((fc->fe = dvb_attach(mt352_attach, &samsung_tdtc9251dh0_config, &fc->i2c_adap)) != NULL ) {
-                fc->dev_type          = FC_AIR_DVB;
+        fc->fe = dvb_attach(mt352_attach, &samsung_tdtc9251dh0_config, i2c);
+        if (fc->fe != NULL) {
+                fc->dev_type = FC_AIR_DVB;
                 fc->fe->ops.tuner_ops.calc_regs = samsung_tdtc9251dh0_calc_regs;
-                info("found the mt352 at i2c address: 0x%02x",samsung_tdtc9251dh0_config.demod_address);
-        } else
+                goto fe_found;
+        }
+
         /* try the air atsc 2nd generation (nxt2002) */
-        if ((fc->fe = dvb_attach(nxt200x_attach, &samsung_tbmv_config, &fc->i2c_adap)) != NULL) {
-                fc->dev_type          = FC_AIR_ATSC2;
+        fc->fe = dvb_attach(nxt200x_attach, &samsung_tbmv_config, i2c);
+        if (fc->fe != NULL) {
+                fc->dev_type = FC_AIR_ATSC2;
                 dvb_attach(dvb_pll_attach, fc->fe, 0x61, NULL, DVB_PLL_SAMSUNG_TBMV);
-                info("found the nxt2002 at i2c address: 0x%02x",samsung_tbmv_config.demod_address);
-        } else
-        /* try the air atsc 3nd generation (lgdt3303) */
-        if ((fc->fe = dvb_attach(lgdt330x_attach, &air2pc_atsc_hd5000_config, &fc->i2c_adap)) != NULL) {
-                fc->dev_type          = FC_AIR_ATSC3;
-                dvb_attach(dvb_pll_attach, fc->fe, 0x61, &fc->i2c_adap, DVB_PLL_LG_TDVS_H06XF);
-                info("found the lgdt3303 at i2c address: 0x%02x",air2pc_atsc_hd5000_config.demod_address);
-        } else
+                goto fe_found;
+        }
+
+        fc->fe = dvb_attach(lgdt330x_attach, &air2pc_atsc_hd5000_config, i2c);
+        if (fc->fe != NULL) {
+                fc->dev_type = FC_AIR_ATSC3;
+                dvb_attach(simple_tuner_attach, fc->fe, i2c, 0x61,
+                                TUNER_LG_TDVS_H06XF);
+                goto fe_found;
+        }
+
         /* try the air atsc 1nd generation (bcm3510)/panasonic ct10s */
-        if ((fc->fe = dvb_attach(bcm3510_attach, &air2pc_atsc_first_gen_config, &fc->i2c_adap)) != NULL) {
-                fc->dev_type          = FC_AIR_ATSC1;
-                info("found the bcm3510 at i2c address: 0x%02x",air2pc_atsc_first_gen_config.demod_address);
-        } else
+        fc->fe = dvb_attach(bcm3510_attach, &air2pc_atsc_first_gen_config, i2c);
+        if (fc->fe != NULL) {
+                fc->dev_type = FC_AIR_ATSC1;
+                goto fe_found;
+        }
+
         /* try the cable dvb (stv0297) */
-        if ((fc->fe = dvb_attach(stv0297_attach, &alps_tdee4_stv0297_config, &fc->i2c_adap)) != NULL) {
-                fc->dev_type                        = FC_CABLE;
+        fc->fe = dvb_attach(stv0297_attach, &alps_tdee4_stv0297_config, i2c);
+        if (fc->fe != NULL) {
+                fc->dev_type = FC_CABLE;
                 fc->fe->ops.tuner_ops.set_params = alps_tdee4_stv0297_tuner_set_params;
-                info("found the stv0297 at i2c address: 0x%02x",alps_tdee4_stv0297_config.demod_address);
-        } else
+                goto fe_found;
+        }
+
         /* try the sky v2.3 (vp310/Samsung tbdu18132(tsa5059)) */
-        if ((fc->fe = dvb_attach(vp310_mt312_attach, &skystar23_samsung_tbdu18132_config, &fc->i2c_adap)) != NULL) {
+        fc->fe = dvb_attach(vp310_mt312_attach,
+                &skystar23_samsung_tbdu18132_config, i2c);
+        if (fc->fe != NULL) {
                 ops = &fc->fe->ops;
 
                 ops->tuner_ops.set_params = skystar23_samsung_tbdu18132_tuner_set_params;
@@ -535,19 +650,21 @@ int flexcop_frontend_init(struct flexcop_device *fc)
                 ops->sleep                  = flexcop_sleep;
 
                 fc->dev_type                = FC_SKY_OLD;
-                info("found the vp310 (aka mt312) at i2c address: 0x%02x",skystar23_samsung_tbdu18132_config.demod_address);
+                goto fe_found;
         }
 
-        if (fc->fe == NULL) {
-                err("no frontend driver found for this B2C2/FlexCop adapter");
-                return -ENODEV;
-        } else {
-                if (dvb_register_frontend(&fc->dvb_adapter, fc->fe)) {
-                        err("frontend registration failed!");
-                        dvb_frontend_detach(fc->fe);
-                        fc->fe = NULL;
-                        return -EINVAL;
-                }
+        err("no frontend driver found for this B2C2/FlexCop adapter");
+        return -ENODEV;
+
+fe_found:
+        info("found '%s' .", fc->fe->ops.info.name);
+        if (dvb_register_frontend(&fc->dvb_adapter, fc->fe)) {
+                err("frontend registration failed!");
+                ops = &fc->fe->ops;
+                if (ops->release != NULL)
+                        ops->release(fc->fe);
+                fc->fe = NULL;
+                return -EINVAL;
         }
         fc->init_state |= FC_STATE_FE_INIT;
         return 0;
diff --git a/drivers/media/dvb/b2c2/flexcop-i2c.c b/drivers/media/dvb/b2c2/flexcop-i2c.c
index 6bf858a436c9..55973eaf3711 100644
--- a/drivers/media/dvb/b2c2/flexcop-i2c.c
+++ b/drivers/media/dvb/b2c2/flexcop-i2c.c
@@ -9,6 +9,8 @@
 
 #define FC_MAX_I2C_RETRIES 100000
 
+/* #define DUMP_I2C_MESSAGES */
+
 static int flexcop_i2c_operation(struct flexcop_device *fc, flexcop_ibi_value *r100)
 {
         int i;
@@ -38,30 +40,25 @@ static int flexcop_i2c_operation(struct flexcop_device *fc, flexcop_ibi_value *r
         return -EREMOTEIO;
 }
 
-static int flexcop_i2c_read4(struct flexcop_device *fc, flexcop_ibi_value r100, u8 *buf)
+static int flexcop_i2c_read4(struct flexcop_i2c_adapter *i2c,
+        flexcop_ibi_value r100, u8 *buf)
 {
         flexcop_ibi_value r104;
         int len = r100.tw_sm_c_100.total_bytes, /* remember total_bytes is buflen-1 */
                 ret;
 
-        if ((ret = flexcop_i2c_operation(fc,&r100)) != 0) {
-                /* The Cablestar needs a different kind of i2c-transfer (does not
-                 * support "Repeat Start"):
-                 * wait for the ACK failure,
-                 * and do a subsequent read with the Bit 30 enabled
-                 */
-                r100.tw_sm_c_100.no_base_addr_ack_error = 1;
-                if ((ret = flexcop_i2c_operation(fc,&r100)) != 0) {
-                        deb_i2c("no_base_addr read failed. %d\n",ret);
-                        return ret;
-                }
+        r100.tw_sm_c_100.no_base_addr_ack_error = i2c->no_base_addr;
+        ret = flexcop_i2c_operation(i2c->fc, &r100);
+        if (ret != 0) {
+                deb_i2c("read failed. %d\n", ret);
+                return ret;
         }
 
         buf[0] = r100.tw_sm_c_100.data1_reg;
 
         if (len > 0) {
-                r104 = fc->read_ibi_reg(fc,tw_sm_c_104);
-                deb_i2c("read: r100: %08x, r104: %08x\n",r100.raw,r104.raw);
+                r104 = i2c->fc->read_ibi_reg(i2c->fc, tw_sm_c_104);
+                deb_i2c("read: r100: %08x, r104: %08x\n", r100.raw, r104.raw);
 
                 /* there is at least one more byte, otherwise we wouldn't be here */
                 buf[1] = r104.tw_sm_c_104.data2_reg;
@@ -85,17 +82,22 @@ static int flexcop_i2c_write4(struct flexcop_device *fc, flexcop_ibi_value r100,
         r104.tw_sm_c_104.data3_reg = len > 1 ? buf[2] : 0;
         r104.tw_sm_c_104.data4_reg = len > 2 ? buf[3] : 0;
 
-        deb_i2c("write: r100: %08x, r104: %08x\n",r100.raw,r104.raw);
+        deb_i2c("write: r100: %08x, r104: %08x\n", r100.raw, r104.raw);
 
         /* write the additional i2c data before doing the actual i2c operation */
-        fc->write_ibi_reg(fc,tw_sm_c_104,r104);
-        return flexcop_i2c_operation(fc,&r100);
+        fc->write_ibi_reg(fc, tw_sm_c_104, r104);
+        return flexcop_i2c_operation(fc, &r100);
 }
 
-int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
-                flexcop_i2c_port_t port, u8 chipaddr, u8 addr, u8 *buf, u16 len)
+int flexcop_i2c_request(struct flexcop_i2c_adapter *i2c,
+        flexcop_access_op_t op, u8 chipaddr, u8 addr, u8 *buf, u16 len)
 {
         int ret;
+
+#ifdef DUMP_I2C_MESSAGES
+        int i;
+#endif
+
         u16 bytes_to_transfer;
         flexcop_ibi_value r100;
 
@@ -103,7 +105,25 @@ int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
         r100.raw = 0;
         r100.tw_sm_c_100.chipaddr = chipaddr;
         r100.tw_sm_c_100.twoWS_rw = op;
-        r100.tw_sm_c_100.twoWS_port_reg = port;
+        r100.tw_sm_c_100.twoWS_port_reg = i2c->port;
+
+#ifdef DUMP_I2C_MESSAGES
+        printk(KERN_DEBUG "%d ", i2c->port);
+        if (op == FC_READ)
+                printk("rd(");
+        else
+                printk("wr(");
+
+        printk("%02x): %02x ", chipaddr, addr);
+#endif
+
+        /* in that case addr is the only value ->
+         * we write it twice as baseaddr and val0
+         * BBTI is doing it like that for ISL6421 at least */
+        if (i2c->no_base_addr && len == 0 && op == FC_WRITE) {
+                buf = &addr;
+                len = 1;
+        }
 
         while (len != 0) {
                 bytes_to_transfer = len > 4 ? 4 : len;
@@ -112,9 +132,14 @@ int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
                 r100.tw_sm_c_100.baseaddr = addr;
 
                 if (op == FC_READ)
-                        ret = flexcop_i2c_read4(fc, r100, buf);
+                        ret = flexcop_i2c_read4(i2c, r100, buf);
                 else
-                        ret = flexcop_i2c_write4(fc,r100, buf);
+                        ret = flexcop_i2c_write4(i2c->fc, r100, buf);
+
+#ifdef DUMP_I2C_MESSAGES
+                for (i = 0; i < bytes_to_transfer; i++)
+                        printk("%02x ", buf[i]);
+#endif
 
                 if (ret < 0)
                         return ret;
@@ -122,7 +147,11 @@ int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
                 buf  += bytes_to_transfer;
                 addr += bytes_to_transfer;
                 len  -= bytes_to_transfer;
-        };
+        }
+
+#ifdef DUMP_I2C_MESSAGES
+        printk("\n");
+#endif
 
         return 0;
 }
@@ -132,7 +161,7 @@ EXPORT_SYMBOL(flexcop_i2c_request);
 /* master xfer callback for demodulator */
 static int flexcop_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
 {
-        struct flexcop_device *fc = i2c_get_adapdata(i2c_adap);
+        struct flexcop_i2c_adapter *i2c = i2c_get_adapdata(i2c_adap);
         int i, ret = 0;
 
         /* Some drivers use 1 byte or 0 byte reads as probes, which this
@@ -142,34 +171,29 @@ static int flexcop_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs
         if (num == 1 && msgs[0].flags == I2C_M_RD && msgs[0].len <= 1)
                 return 1;
 
-        if (mutex_lock_interruptible(&fc->i2c_mutex))
+        if (mutex_lock_interruptible(&i2c->fc->i2c_mutex))
                 return -ERESTARTSYS;
 
-        /* reading */
-        if (num == 2 &&
-                msgs[0].flags == 0 &&
-                msgs[1].flags == I2C_M_RD &&
-                msgs[0].buf != NULL &&
-                msgs[1].buf != NULL) {
-
-                ret = fc->i2c_request(fc, FC_READ, FC_I2C_PORT_DEMOD, msgs[0].addr, msgs[0].buf[0], msgs[1].buf, msgs[1].len);
-
-        } else for (i = 0; i < num; i++) { /* writing command */
-                if (msgs[i].flags != 0 || msgs[i].buf == NULL || msgs[i].len < 2) {
-                        ret = -EINVAL;
+        for (i = 0; i < num; i++) {
+                /* reading */
+                if (i+1 < num && (msgs[i+1].flags == I2C_M_RD)) {
+                        ret = i2c->fc->i2c_request(i2c, FC_READ, msgs[i].addr,
+                                msgs[i].buf[0], msgs[i+1].buf, msgs[i+1].len);
+                        i++; /* skip the following message */
+                } else /* writing */
+                        ret = i2c->fc->i2c_request(i2c, FC_WRITE, msgs[i].addr,
+                                msgs[i].buf[0], &msgs[i].buf[1],
+                                msgs[i].len - 1);
+                if (ret < 0) {
+                        err("i2c master_xfer failed");
                         break;
                 }
-
-                ret = fc->i2c_request(fc, FC_WRITE, FC_I2C_PORT_DEMOD, msgs[i].addr, msgs[i].buf[0], &msgs[i].buf[1], msgs[i].len - 1);
         }
 
-        if (ret < 0)
-                err("i2c master_xfer failed");
-        else
-                ret = num;
-
-        mutex_unlock(&fc->i2c_mutex);
+        mutex_unlock(&i2c->fc->i2c_mutex);
 
+        if (ret == 0)
+                ret = num;
         return ret;
 }
 
@@ -189,28 +213,68 @@ int flexcop_i2c_init(struct flexcop_device *fc)
 
         mutex_init(&fc->i2c_mutex);
 
-        memset(&fc->i2c_adap, 0, sizeof(struct i2c_adapter));
-        strncpy(fc->i2c_adap.name, "B2C2 FlexCop device",
-                sizeof(fc->i2c_adap.name));
-
-        i2c_set_adapdata(&fc->i2c_adap,fc);
+        fc->fc_i2c_adap[0].fc = fc;
+        fc->fc_i2c_adap[1].fc = fc;
+        fc->fc_i2c_adap[2].fc = fc;
+
+        fc->fc_i2c_adap[0].port = FC_I2C_PORT_DEMOD;
+        fc->fc_i2c_adap[1].port = FC_I2C_PORT_EEPROM;
+        fc->fc_i2c_adap[2].port = FC_I2C_PORT_TUNER;
+
+        strncpy(fc->fc_i2c_adap[0].i2c_adap.name,
+                "B2C2 FlexCop I2C to demod", I2C_NAME_SIZE);
+        strncpy(fc->fc_i2c_adap[1].i2c_adap.name,
+                "B2C2 FlexCop I2C to eeprom", I2C_NAME_SIZE);
+        strncpy(fc->fc_i2c_adap[2].i2c_adap.name,
+                "B2C2 FlexCop I2C to tuner", I2C_NAME_SIZE);
+
+        i2c_set_adapdata(&fc->fc_i2c_adap[0].i2c_adap, &fc->fc_i2c_adap[0]);
+        i2c_set_adapdata(&fc->fc_i2c_adap[1].i2c_adap, &fc->fc_i2c_adap[1]);
+        i2c_set_adapdata(&fc->fc_i2c_adap[2].i2c_adap, &fc->fc_i2c_adap[2]);
+
+        fc->fc_i2c_adap[0].i2c_adap.class =
+                fc->fc_i2c_adap[1].i2c_adap.class =
+                fc->fc_i2c_adap[2].i2c_adap.class = I2C_CLASS_TV_DIGITAL;
+        fc->fc_i2c_adap[0].i2c_adap.algo =
+                fc->fc_i2c_adap[1].i2c_adap.algo =
+                fc->fc_i2c_adap[2].i2c_adap.algo = &flexcop_algo;
+        fc->fc_i2c_adap[0].i2c_adap.algo_data =
+                fc->fc_i2c_adap[1].i2c_adap.algo_data =
+                fc->fc_i2c_adap[2].i2c_adap.algo_data = NULL;
+        fc->fc_i2c_adap[0].i2c_adap.dev.parent =
+                fc->fc_i2c_adap[1].i2c_adap.dev.parent =
+                fc->fc_i2c_adap[2].i2c_adap.dev.parent = fc->dev;
+
+        ret = i2c_add_adapter(&fc->fc_i2c_adap[0].i2c_adap);
+        if (ret < 0)
+                return ret;
 
-        fc->i2c_adap.class          = I2C_CLASS_TV_DIGITAL;
-        fc->i2c_adap.algo       = &flexcop_algo;
-        fc->i2c_adap.algo_data  = NULL;
-        fc->i2c_adap.dev.parent = fc->dev;
+        ret = i2c_add_adapter(&fc->fc_i2c_adap[1].i2c_adap);
+        if (ret < 0)
+                goto adap_1_failed;
 
-        if ((ret = i2c_add_adapter(&fc->i2c_adap)) < 0)
-                return ret;
+        ret = i2c_add_adapter(&fc->fc_i2c_adap[2].i2c_adap);
+        if (ret < 0)
+                goto adap_2_failed;
 
         fc->init_state |= FC_STATE_I2C_INIT;
         return 0;
+
+adap_2_failed:
+        i2c_del_adapter(&fc->fc_i2c_adap[1].i2c_adap);
+adap_1_failed:
+        i2c_del_adapter(&fc->fc_i2c_adap[0].i2c_adap);
+
+        return ret;
 }
 
 void flexcop_i2c_exit(struct flexcop_device *fc)
 {
-        if (fc->init_state & FC_STATE_I2C_INIT)
-                i2c_del_adapter(&fc->i2c_adap);
+        if (fc->init_state & FC_STATE_I2C_INIT) {
+                i2c_del_adapter(&fc->fc_i2c_adap[2].i2c_adap);
+                i2c_del_adapter(&fc->fc_i2c_adap[1].i2c_adap);
+                i2c_del_adapter(&fc->fc_i2c_adap[0].i2c_adap);
+        }
 
         fc->init_state &= ~FC_STATE_I2C_INIT;
 }
diff --git a/drivers/media/dvb/b2c2/flexcop-misc.c b/drivers/media/dvb/b2c2/flexcop-misc.c
index 167583bf0621..93d20e56f909 100644
--- a/drivers/media/dvb/b2c2/flexcop-misc.c
+++ b/drivers/media/dvb/b2c2/flexcop-misc.c
@@ -52,6 +52,8 @@ static const char *flexcop_device_names[] = {
         "Sky2PC/SkyStar 2 DVB-S (old version)",
         "Cable2PC/CableStar 2 DVB-C",
         "Air2PC/AirStar 2 ATSC 3rd generation (HD5000)",
+        "Sky2PC/SkyStar 2 DVB-S rev 2.7a/u",
+        "Sky2PC/SkyStar 2 DVB-S rev 2.8",
 };
 
 static const char *flexcop_bus_names[] = {
diff --git a/drivers/media/dvb/b2c2/flexcop-pci.c b/drivers/media/dvb/b2c2/flexcop-pci.c
index 01af4d237eb1..5b30dfc7846b 100644
--- a/drivers/media/dvb/b2c2/flexcop-pci.c
+++ b/drivers/media/dvb/b2c2/flexcop-pci.c
@@ -32,7 +32,7 @@ MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ watchdog (currently jus
 #define deb_irq(args...)   dprintk(0x08,args)
 #define deb_chk(args...)   dprintk(0x10,args)
 
-static int debug = 0;
+static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debug level (1=info,2=regs,4=TS,8=irqdma (|-able))." DEBSTATUS);
 
diff --git a/drivers/media/dvb/b2c2/flexcop-reg.h b/drivers/media/dvb/b2c2/flexcop-reg.h
index 491f9bd6e195..7599fccc1a5b 100644
--- a/drivers/media/dvb/b2c2/flexcop-reg.h
+++ b/drivers/media/dvb/b2c2/flexcop-reg.h
@@ -25,6 +25,8 @@ typedef enum {
         FC_SKY_OLD,
         FC_CABLE,
         FC_AIR_ATSC3,
+        FC_SKY_REV27,
+        FC_SKY_REV28,
 } flexcop_device_type_t;
 
 typedef enum {
diff --git a/drivers/media/dvb/b2c2/flexcop-sram.c b/drivers/media/dvb/b2c2/flexcop-sram.c
index 01570ec80962..cda69528548a 100644
--- a/drivers/media/dvb/b2c2/flexcop-sram.c
+++ b/drivers/media/dvb/b2c2/flexcop-sram.c
@@ -90,7 +90,7 @@ static void flexcop_sram_write(struct adapter *adapter, u32 bank, u32 addr, u8 *
                 };
 
                 if (retries == 0)
-                        printk("%s: SRAM timeout\n", __FUNCTION__);
+                        printk("%s: SRAM timeout\n", __func__);
 
                 write_reg_dw(adapter, 0x700, command);
 
@@ -115,7 +115,7 @@ static void flex_sram_read(struct adapter *adapter, u32 bank, u32 addr, u8 *buf,
                 };
 
                 if (retries == 0)
-                        printk("%s: SRAM timeout\n", __FUNCTION__);
+                        printk("%s: SRAM timeout\n", __func__);
 
                 write_reg_dw(adapter, 0x700, command);
 
@@ -127,7 +127,7 @@ static void flex_sram_read(struct adapter *adapter, u32 bank, u32 addr, u8 *buf,
                 };
 
                 if (retries == 0)
-                        printk("%s: SRAM timeout\n", __FUNCTION__);
+                        printk("%s: SRAM timeout\n", __func__);
 
                 value = read_reg_dw(adapter, 0x700) >> 0x10;
 
@@ -240,13 +240,13 @@ static void sram_init(struct adapter *adapter)
 
                 adapter->dw_sram_type = tmp & 0x30000;
 
-                ddprintk("%s: dw_sram_type = %x\n", __FUNCTION__, adapter->dw_sram_type);
+                ddprintk("%s: dw_sram_type = %x\n", __func__, adapter->dw_sram_type);
 
         } else {
 
                 adapter->dw_sram_type = 0x10000;
 
-                ddprintk("%s: dw_sram_type = %x\n", __FUNCTION__, adapter->dw_sram_type);
+                ddprintk("%s: dw_sram_type = %x\n", __func__, adapter->dw_sram_type);
         }
 
         /* return value is never used? */
@@ -257,7 +257,7 @@ static int sram_test_location(struct adapter *adapter, u32 mask, u32 addr)
 {
         u8 tmp1, tmp2;
 
-        dprintk("%s: mask = %x, addr = %x\n", __FUNCTION__, mask, addr);
+        dprintk("%s: mask = %x, addr = %x\n", __func__, mask, addr);
 
         sram_set_size(adapter, mask);
         sram_init(adapter);
@@ -275,7 +275,7 @@ static int sram_test_location(struct adapter *adapter, u32 mask, u32 addr)
         sram_read(adapter, addr, &tmp2, 1);
         sram_read(adapter, addr, &tmp2, 1);
 
-        dprintk("%s: wrote 0xa5, read 0x%2x\n", __FUNCTION__, tmp2);
+        dprintk("%s: wrote 0xa5, read 0x%2x\n", __func__, tmp2);
 
         if (tmp2 != 0xa5)
                 return 0;
@@ -293,7 +293,7 @@ static int sram_test_location(struct adapter *adapter, u32 mask, u32 addr)
         sram_read(adapter, addr, &tmp2, 1);
         sram_read(adapter, addr, &tmp2, 1);
 
-        dprintk("%s: wrote 0x5a, read 0x%2x\n", __FUNCTION__, tmp2);
+        dprintk("%s: wrote 0x5a, read 0x%2x\n", __func__, tmp2);
 
         if (tmp2 != 0x5a)
                 return 0;
@@ -340,7 +340,7 @@ static int flexcop_sram_detect(struct flexcop_device *fc)
 
         tmp3 = read_reg_dw(adapter, 0x71c);
 
-        dprintk("%s: tmp3 = %x\n", __FUNCTION__, tmp3);
+        dprintk("%s: tmp3 = %x\n", __func__, tmp3);
 
         write_reg_dw(adapter, 0x71c, tmp2);
 
@@ -351,7 +351,7 @@ static int flexcop_sram_detect(struct flexcop_device *fc)
                 sram_init(adapter);
                 write_reg_dw(adapter, 0x208, tmp);
 
-                dprintk("%s: sram size = 32K\n", __FUNCTION__);
+                dprintk("%s: sram size = 32K\n", __func__);
 
                 return 32;
         }
@@ -361,7 +361,7 @@ static int flexcop_sram_detect(struct flexcop_device *fc)
                 sram_init(adapter);
                 write_reg_dw(adapter, 0x208, tmp);
 
-                dprintk("%s: sram size = 128K\n", __FUNCTION__);
+                dprintk("%s: sram size = 128K\n", __func__);
 
                 return 128;
         }
@@ -371,7 +371,7 @@ static int flexcop_sram_detect(struct flexcop_device *fc)
                 sram_init(adapter);
                 write_reg_dw(adapter, 0x208, tmp);
 
-                dprintk("%s: sram size = 64K\n", __FUNCTION__);
+                dprintk("%s: sram size = 64K\n", __func__);
 
                 return 64;
         }
@@ -381,7 +381,7 @@ static int flexcop_sram_detect(struct flexcop_device *fc)
                 sram_init(adapter);
                 write_reg_dw(adapter, 0x208, tmp);
 
-                dprintk("%s: sram size = 32K\n", __FUNCTION__);
+                dprintk("%s: sram size = 32K\n", __func__);
 
                 return 32;
         }
@@ -390,7 +390,7 @@ static int flexcop_sram_detect(struct flexcop_device *fc)
         sram_init(adapter);
         write_reg_dw(adapter, 0x208, tmp);
 
-        dprintk("%s: SRAM detection failed. Set to 32K \n", __FUNCTION__);
+        dprintk("%s: SRAM detection failed. Set to 32K \n", __func__);
 
         return 0;
 }
diff --git a/drivers/media/dvb/b2c2/flexcop-usb.c b/drivers/media/dvb/b2c2/flexcop-usb.c
index 87fb75f0d1cf..449fb5c3d0b1 100644
--- a/drivers/media/dvb/b2c2/flexcop-usb.c
+++ b/drivers/media/dvb/b2c2/flexcop-usb.c
@@ -211,10 +211,11 @@ static int flexcop_usb_utility_req(struct flexcop_usb *fc_usb, int set,
 #endif
 
 /* usb i2c stuff */
-static int flexcop_usb_i2c_req(struct flexcop_usb *fc_usb,
+static int flexcop_usb_i2c_req(struct flexcop_i2c_adapter *i2c,
                 flexcop_usb_request_t req, flexcop_usb_i2c_function_t func,
-                flexcop_i2c_port_t port, u8 chipaddr, u8 addr, u8 *buf, u8 buflen)
+                u8 chipaddr, u8 addr, u8 *buf, u8 buflen)
 {
+        struct flexcop_usb *fc_usb = i2c->fc->bus_specific;
         u16 wValue, wIndex;
         int nWaitTime,pipe,len;
 //      u8 dwRequestType;
@@ -242,7 +243,7 @@ static int flexcop_usb_i2c_req(struct flexcop_usb *fc_usb,
                         deb_info("unsupported function for i2c_req %x\n",func);
                         return -EINVAL;
         }
-        wValue = (func << 8 ) | (port << 4);
+        wValue = (func << 8) | (i2c->port << 4);
         wIndex = (chipaddr << 8 ) | addr;
 
         deb_i2c("i2c %2d: %02x %02x %02x %02x %02x %02x\n",func,request_type,req,
@@ -274,13 +275,15 @@ static int flexcop_usb_write_ibi_reg(struct flexcop_device *fc, flexcop_ibi_regi
         return flexcop_usb_readwrite_dw(fc,reg, &val.raw, 0);
 }
 
-static int flexcop_usb_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
-                flexcop_i2c_port_t port, u8 chipaddr, u8 addr, u8 *buf, u16 len)
+static int flexcop_usb_i2c_request(struct flexcop_i2c_adapter *i2c,
+        flexcop_access_op_t op, u8 chipaddr, u8 addr, u8 *buf, u16 len)
 {
         if (op == FC_READ)
-                return flexcop_usb_i2c_req(fc->bus_specific,B2C2_USB_I2C_REQUEST,USB_FUNC_I2C_READ,port,chipaddr,addr,buf,len);
+                return flexcop_usb_i2c_req(i2c, B2C2_USB_I2C_REQUEST,
+                        USB_FUNC_I2C_READ, chipaddr, addr, buf, len);
         else
-                return flexcop_usb_i2c_req(fc->bus_specific,B2C2_USB_I2C_REQUEST,USB_FUNC_I2C_WRITE,port,chipaddr,addr,buf,len);
+                return flexcop_usb_i2c_req(i2c, B2C2_USB_I2C_REQUEST,
+                        USB_FUNC_I2C_WRITE, chipaddr, addr, buf, len);
 }
 
 static void flexcop_usb_process_frame(struct flexcop_usb *fc_usb, u8 *buffer, int buffer_length)
diff --git a/drivers/media/dvb/b2c2/flexcop.c b/drivers/media/dvb/b2c2/flexcop.c
index 2ddafd071c97..5f79c8dc3836 100644
--- a/drivers/media/dvb/b2c2/flexcop.c
+++ b/drivers/media/dvb/b2c2/flexcop.c
@@ -49,6 +49,8 @@ module_param_named(debug, b2c2_flexcop_debug,  int, 0644);
 MODULE_PARM_DESC(debug, "set debug level (1=info,2=tuner,4=i2c,8=ts,16=sram,32=reg (|-able))." DEBSTATUS);
 #undef DEBSTATUS
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 /* global zero for ibi values */
 flexcop_ibi_value ibi_zero;
 
@@ -66,8 +68,10 @@ static int flexcop_dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 
 static int flexcop_dvb_init(struct flexcop_device *fc)
 {
-        int ret;
-        if ((ret = dvb_register_adapter(&fc->dvb_adapter,"FlexCop Digital TV device",fc->owner,fc->dev)) < 0) {
+        int ret = dvb_register_adapter(&fc->dvb_adapter,
+                                       "FlexCop Digital TV device", fc->owner,
+                                       fc->dev, adapter_nr);
+        if (ret < 0) {
                 err("error registering DVB adapter");
                 return ret;
         }
@@ -257,6 +261,12 @@ int flexcop_device_initialize(struct flexcop_device *fc)
         if ((ret = flexcop_dvb_init(fc)))
                 goto error;
 
+        /* i2c has to be done before doing EEProm stuff -
+         * because the EEProm is accessed via i2c */
+        ret = flexcop_i2c_init(fc);
+        if (ret)
+                goto error;
+
         /* do the MAC address reading after initializing the dvb_adapter */
         if (fc->get_mac_addr(fc, 0) == 0) {
                 u8 *b = fc->dvb_adapter.proposed_mac;
@@ -266,10 +276,6 @@ int flexcop_device_initialize(struct flexcop_device *fc)
         } else
                 warn("reading of MAC address failed.\n");
 
-
-        if ((ret = flexcop_i2c_init(fc)))
-                goto error;
-
         if ((ret = flexcop_frontend_init(fc)))
                 goto error;
 
diff --git a/drivers/media/dvb/bt8xx/Kconfig b/drivers/media/dvb/bt8xx/Kconfig
index ea666174e988..902c762e0b7f 100644
--- a/drivers/media/dvb/bt8xx/Kconfig
+++ b/drivers/media/dvb/bt8xx/Kconfig
@@ -7,8 +7,8 @@ config DVB_BT8XX
         select DVB_CX24110 if !DVB_FE_CUSTOMISE
         select DVB_OR51211 if !DVB_FE_CUSTOMISE
         select DVB_LGDT330X if !DVB_FE_CUSTOMISE
-        select DVB_PLL if !DVB_FE_CUSTOMISE
         select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select TUNER_SIMPLE if !DVB_FE_CUSTOMISE
         select FW_LOADER
         help
           Support for PCI cards based on the Bt8xx PCI bridge. Examples are
diff --git a/drivers/media/dvb/bt8xx/Makefile b/drivers/media/dvb/bt8xx/Makefile
index 84cf70504d17..9d3e68b5d6eb 100644
--- a/drivers/media/dvb/bt8xx/Makefile
+++ b/drivers/media/dvb/bt8xx/Makefile
@@ -1,3 +1,6 @@
 obj-$(CONFIG_DVB_BT8XX) += bt878.o dvb-bt8xx.o dst.o dst_ca.o
 
-EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/video/bt8xx -Idrivers/media/dvb/frontends
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
+EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+EXTRA_CFLAGS += -Idrivers/media/video/bt8xx
+EXTRA_CFLAGS += -Idrivers/media/video
diff --git a/drivers/media/dvb/bt8xx/dst.c b/drivers/media/dvb/bt8xx/dst.c
index 307ff35bdf13..75711bde23ad 100644
--- a/drivers/media/dvb/bt8xx/dst.c
+++ b/drivers/media/dvb/bt8xx/dst.c
@@ -1290,7 +1290,7 @@ static int dst_get_signal(struct dst_state *state)
 {
         int retval;
         u8 get_signal[] = { 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb };
-        //dprintk("%s: Getting Signal strength and other parameters\n", __FUNCTION__);
+        //dprintk("%s: Getting Signal strength and other parameters\n", __func__);
         if ((state->diseq_flags & ATTEMPT_TUNE) == 0) {
                 state->decode_lock = state->decode_strength = state->decode_snr = 0;
                 return 0;
diff --git a/drivers/media/dvb/bt8xx/dst_ca.c b/drivers/media/dvb/bt8xx/dst_ca.c
index 50bc32a8bd55..0258451423ad 100644
--- a/drivers/media/dvb/bt8xx/dst_ca.c
+++ b/drivers/media/dvb/bt8xx/dst_ca.c
@@ -36,13 +36,13 @@
 #define dprintk(x, y, z, format, arg...) do {                                           \
         if (z) {                                                                        \
                 if      ((x > DST_CA_ERROR) && (x > y))                                 \
-                        printk(KERN_ERR "%s: " format "\n", __FUNCTION__ , ##arg);      \
+                        printk(KERN_ERR "%s: " format "\n", __func__ , ##arg);  \
                 else if ((x > DST_CA_NOTICE) && (x > y))                                \
-                        printk(KERN_NOTICE "%s: " format "\n", __FUNCTION__ , ##arg);   \
+                        printk(KERN_NOTICE "%s: " format "\n", __func__ , ##arg);       \
                 else if ((x > DST_CA_INFO) && (x > y))                                  \
-                        printk(KERN_INFO "%s: " format "\n", __FUNCTION__ , ##arg);     \
+                        printk(KERN_INFO "%s: " format "\n", __func__ , ##arg); \
                 else if ((x > DST_CA_DEBUG) && (x > y))                                 \
-                        printk(KERN_DEBUG "%s: " format "\n", __FUNCTION__ , ##arg);    \
+                        printk(KERN_DEBUG "%s: " format "\n", __func__ , ##arg);        \
         } else {                                                                        \
                 if (x > y)                                                              \
                         printk(format, ## arg);                                         \
@@ -162,7 +162,7 @@ static int ca_get_app_info(struct dst_state *state)
         dprintk(verbose, DST_CA_INFO, 1, " ================================ CI Module Application Info ======================================");
         dprintk(verbose, DST_CA_INFO, 1, " Application Type=[%d], Application Vendor=[%d], Vendor Code=[%d]\n%s: Application info=[%s]",
                 state->messages[7], (state->messages[8] << 8) | state->messages[9],
-                (state->messages[10] << 8) | state->messages[11], __FUNCTION__, (char *)(&state->messages[12]));
+                (state->messages[10] << 8) | state->messages[11], __func__, (char *)(&state->messages[12]));
         dprintk(verbose, DST_CA_INFO, 1, " ==================================================================================================");
 
         // Transform dst message to correct application_info message
diff --git a/drivers/media/dvb/bt8xx/dvb-bt8xx.c b/drivers/media/dvb/bt8xx/dvb-bt8xx.c
index dedd30a8356b..6afbfbbef0ce 100644
--- a/drivers/media/dvb/bt8xx/dvb-bt8xx.c
+++ b/drivers/media/dvb/bt8xx/dvb-bt8xx.c
@@ -40,10 +40,12 @@ static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define dprintk( args... ) \
-        do \
+        do { \
                 if (debug) printk(KERN_DEBUG args); \
-        while (0)
+        } while (0)
 
 #define IF_FREQUENCYx6 217    /* 6 * 36.16666666667MHz */
 
@@ -609,8 +611,9 @@ static void frontend_init(struct dvb_bt8xx_card *card, u32 type)
                 lgdt330x_reset(card);
                 card->fe = dvb_attach(lgdt330x_attach, &tdvs_tua6034_config, card->i2c_adapter);
                 if (card->fe != NULL) {
-                        dvb_attach(dvb_pll_attach, card->fe, 0x61,
-                                   card->i2c_adapter, DVB_PLL_LG_TDVS_H06XF);
+                        dvb_attach(simple_tuner_attach, card->fe,
+                                   card->i2c_adapter, 0x61,
+                                   TUNER_LG_TDVS_H06XF);
                         dprintk ("dvb_bt8xx: lgdt330x detected\n");
                 }
                 break;
@@ -670,7 +673,7 @@ static void frontend_init(struct dvb_bt8xx_card *card, u32 type)
                 state->dst_ca = NULL;
                 /*      DST is not a frontend, attaching the ASIC       */
                 if (dvb_attach(dst_attach, state, &card->dvb_adapter) == NULL) {
-                        printk("%s: Could not find a Twinhan DST.\n", __FUNCTION__);
+                        printk("%s: Could not find a Twinhan DST.\n", __func__);
                         break;
                 }
                 /*      Attach other DST peripherals if any             */
@@ -692,8 +695,9 @@ static void frontend_init(struct dvb_bt8xx_card *card, u32 type)
         case BTTV_BOARD_PC_HDTV:
                 card->fe = dvb_attach(or51211_attach, &or51211_config, card->i2c_adapter);
                 if (card->fe != NULL)
-                        dvb_attach(dvb_pll_attach, card->fe, 0x61,
-                                   card->i2c_adapter, DVB_PLL_FCV1236D);
+                        dvb_attach(simple_tuner_attach, card->fe,
+                                   card->i2c_adapter, 0x61,
+                                   TUNER_PHILIPS_FCV1236D);
                 break;
         }
 
@@ -715,7 +719,10 @@ static int __devinit dvb_bt8xx_load_card(struct dvb_bt8xx_card *card, u32 type)
 {
         int result;
 
-        if ((result = dvb_register_adapter(&card->dvb_adapter, card->card_name, THIS_MODULE, &card->bt->dev->dev)) < 0) {
+        result = dvb_register_adapter(&card->dvb_adapter, card->card_name,
+                                      THIS_MODULE, &card->bt->dev->dev,
+                                      adapter_nr);
+        if (result < 0) {
                 printk("dvb_bt8xx: dvb_register_adapter failed (errno = %d)\n", result);
                 return result;
         }
diff --git a/drivers/media/dvb/bt8xx/dvb-bt8xx.h b/drivers/media/dvb/bt8xx/dvb-bt8xx.h
index 436880e68672..4499ed2ac0ed 100644
--- a/drivers/media/dvb/bt8xx/dvb-bt8xx.h
+++ b/drivers/media/dvb/bt8xx/dvb-bt8xx.h
@@ -38,7 +38,7 @@
 #include "or51211.h"
 #include "lgdt330x.h"
 #include "zl10353.h"
-#include "dvb-pll.h"
+#include "tuner-simple.h"
 
 struct dvb_bt8xx_card {
         struct mutex lock;
diff --git a/drivers/media/dvb/cinergyT2/cinergyT2.c b/drivers/media/dvb/cinergyT2/cinergyT2.c
index db08b0a8888a..f5010e8671b8 100644
--- a/drivers/media/dvb/cinergyT2/cinergyT2.c
+++ b/drivers/media/dvb/cinergyT2/cinergyT2.c
@@ -58,11 +58,13 @@ static int debug;
 module_param_named(debug, debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define dprintk(level, args...)                                         \
 do {                                                                    \
         if ((debug & level)) {                                          \
                 printk("%s: %s(): ", KBUILD_MODNAME,                    \
-                       __FUNCTION__);                                   \
+                       __func__);                                       \
                 printk(args); }                                         \
 } while (0)
 
@@ -938,7 +940,10 @@ static int cinergyt2_probe (struct usb_interface *intf,
                 return -ENOMEM;
         }
 
-        if ((err = dvb_register_adapter(&cinergyt2->adapter, DRIVER_NAME, THIS_MODULE, &cinergyt2->udev->dev)) < 0) {
+        err = dvb_register_adapter(&cinergyt2->adapter, DRIVER_NAME,
+                                   THIS_MODULE, &cinergyt2->udev->dev,
+                                   adapter_nr);
+        if (err < 0) {
                 kfree(cinergyt2);
                 return err;
         }
diff --git a/drivers/media/dvb/dvb-core/demux.h b/drivers/media/dvb/dvb-core/demux.h
index 0c1d87c5227a..b0d347daae47 100644
--- a/drivers/media/dvb/dvb-core/demux.h
+++ b/drivers/media/dvb/dvb-core/demux.h
@@ -80,6 +80,8 @@ enum dmx_success {
 #define TS_PAYLOAD_ONLY 2   /* in case TS_PACKET is set, only send the TS
                                payload (<=184 bytes per packet) to callback */
 #define TS_DECODER      4   /* send stream to built-in decoder (if present) */
+#define TS_DEMUX        8   /* in case TS_PACKET is set, send the TS to
+                               the demux device, not to the dvr device */
 
 /* PES type for filters which write to built-in decoder */
 /* these should be kept identical to the types in dmx.h */
diff --git a/drivers/media/dvb/dvb-core/dmxdev.c b/drivers/media/dvb/dvb-core/dmxdev.c
index f94bc31e3b33..df5bef6a2517 100644
--- a/drivers/media/dvb/dvb-core/dmxdev.c
+++ b/drivers/media/dvb/dvb-core/dmxdev.c
@@ -126,7 +126,7 @@ static int dvb_dvr_open(struct inode *inode, struct file *file)
         struct dmxdev *dmxdev = dvbdev->priv;
         struct dmx_frontend *front;
 
-        dprintk("function : %s\n", __FUNCTION__);
+        dprintk("function : %s\n", __func__);
 
         if (mutex_lock_interruptible(&dmxdev->mutex))
                 return -ERESTARTSYS;
@@ -259,6 +259,39 @@ static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count,
         return ret;
 }
 
+static int dvb_dvr_set_buffer_size(struct dmxdev *dmxdev,
+                                      unsigned long size)
+{
+        struct dvb_ringbuffer *buf = &dmxdev->dvr_buffer;
+        void *newmem;
+        void *oldmem;
+
+        dprintk("function : %s\n", __func__);
+
+        if (buf->size == size)
+                return 0;
+        if (!size)
+                return -EINVAL;
+
+        newmem = vmalloc(size);
+        if (!newmem)
+                return -ENOMEM;
+
+        oldmem = buf->data;
+
+        spin_lock_irq(&dmxdev->lock);
+        buf->data = newmem;
+        buf->size = size;
+
+        /* reset and not flush in case the buffer shrinks */
+        dvb_ringbuffer_reset(buf);
+        spin_unlock_irq(&dmxdev->lock);
+
+        vfree(oldmem);
+
+        return 0;
+}
+
 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter
                                                *dmxdevfilter, int state)
 {
@@ -271,28 +304,32 @@ static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter,
                                       unsigned long size)
 {
         struct dvb_ringbuffer *buf = &dmxdevfilter->buffer;
-        void *mem;
+        void *newmem;
+        void *oldmem;
 
         if (buf->size == size)
                 return 0;
+        if (!size)
+                return -EINVAL;
         if (dmxdevfilter->state >= DMXDEV_STATE_GO)
                 return -EBUSY;
+
+        newmem = vmalloc(size);
+        if (!newmem)
+                return -ENOMEM;
+
+        oldmem = buf->data;
+
         spin_lock_irq(&dmxdevfilter->dev->lock);
-        mem = buf->data;
-        buf->data = NULL;
+        buf->data = newmem;
         buf->size = size;
-        dvb_ringbuffer_flush(buf);
+
+        /* reset and not flush in case the buffer shrinks */
+        dvb_ringbuffer_reset(buf);
         spin_unlock_irq(&dmxdevfilter->dev->lock);
-        vfree(mem);
 
-        if (buf->size) {
-                mem = vmalloc(dmxdevfilter->buffer.size);
-                if (!mem)
-                        return -ENOMEM;
-                spin_lock_irq(&dmxdevfilter->dev->lock);
-                buf->data = mem;
-                spin_unlock_irq(&dmxdevfilter->dev->lock);
-        }
+        vfree(oldmem);
+
         return 0;
 }
 
@@ -374,7 +411,8 @@ static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len,
                 return 0;
         }
 
-        if (dmxdevfilter->params.pes.output == DMX_OUT_TAP)
+        if (dmxdevfilter->params.pes.output == DMX_OUT_TAP
+            || dmxdevfilter->params.pes.output == DMX_OUT_TSDEMUX_TAP)
                 buffer = &dmxdevfilter->buffer;
         else
                 buffer = &dmxdevfilter->dev->dvr_buffer;
@@ -550,7 +588,7 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
                                                                    dvb_dmxdev_section_callback);
                         if (ret < 0) {
                                 printk("DVB (%s): could not alloc feed\n",
-                                       __FUNCTION__);
+                                       __func__);
                                 return ret;
                         }
 
@@ -558,7 +596,7 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
                                               (para->flags & DMX_CHECK_CRC) ? 1 : 0);
                         if (ret < 0) {
                                 printk("DVB (%s): could not set feed\n",
-                                       __FUNCTION__);
+                                       __func__);
                                 dvb_dmxdev_feed_restart(filter);
                                 return ret;
                         }
@@ -620,9 +658,10 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 
                 if (otype == DMX_OUT_TS_TAP)
                         ts_type |= TS_PACKET;
-
-                if (otype == DMX_OUT_TAP)
-                        ts_type |= TS_PAYLOAD_ONLY | TS_PACKET;
+                else if (otype == DMX_OUT_TSDEMUX_TAP)
+                        ts_type |= TS_PACKET | TS_DEMUX;
+                else if (otype == DMX_OUT_TAP)
+                        ts_type |= TS_PACKET | TS_DEMUX | TS_PAYLOAD_ONLY;
 
                 ret = dmxdev->demux->allocate_ts_feed(dmxdev->demux,
                                                       tsfeed,
@@ -732,7 +771,7 @@ static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev,
                                  struct dmxdev_filter *dmxdevfilter,
                                  struct dmx_sct_filter_params *params)
 {
-        dprintk("function : %s\n", __FUNCTION__);
+        dprintk("function : %s\n", __func__);
 
         dvb_dmxdev_filter_stop(dmxdevfilter);
 
@@ -1007,6 +1046,7 @@ static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
 {
         struct dvb_device *dvbdev = file->private_data;
         struct dmxdev *dmxdev = dvbdev->priv;
+        unsigned long arg = (unsigned long)parg;
         int ret;
 
         if (mutex_lock_interruptible(&dmxdev->mutex))
@@ -1014,8 +1054,7 @@ static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
         case DMX_SET_BUFFER_SIZE:
-                // FIXME: implement
-                ret = 0;
+                ret = dvb_dvr_set_buffer_size(dmxdev, arg);
                 break;
 
         default:
@@ -1038,7 +1077,7 @@ static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait)
         struct dmxdev *dmxdev = dvbdev->priv;
         unsigned int mask = 0;
 
-        dprintk("function : %s\n", __FUNCTION__);
+        dprintk("function : %s\n", __func__);
 
         poll_wait(file, &dmxdev->dvr_buffer.queue, wait);
 
diff --git a/drivers/media/dvb/dvb-core/dvb_ca_en50221.c b/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
index 89437fdab8be..8cbdb0ec67e2 100644
--- a/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
+++ b/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
@@ -250,7 +250,7 @@ static int dvb_ca_en50221_wait_if_status(struct dvb_ca_private *ca, int slot,
         unsigned long timeout;
         unsigned long start;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* loop until timeout elapsed */
         start = jiffies;
@@ -263,7 +263,7 @@ static int dvb_ca_en50221_wait_if_status(struct dvb_ca_private *ca, int slot,
 
                 /* if we got the flags, it was successful! */
                 if (res & waitfor) {
-                        dprintk("%s succeeded timeout:%lu\n", __FUNCTION__, jiffies - start);
+                        dprintk("%s succeeded timeout:%lu\n", __func__, jiffies - start);
                         return 0;
                 }
 
@@ -276,7 +276,7 @@ static int dvb_ca_en50221_wait_if_status(struct dvb_ca_private *ca, int slot,
                 msleep(1);
         }
 
-        dprintk("%s failed timeout:%lu\n", __FUNCTION__, jiffies - start);
+        dprintk("%s failed timeout:%lu\n", __func__, jiffies - start);
 
         /* if we get here, we've timed out */
         return -ETIMEDOUT;
@@ -297,7 +297,7 @@ static int dvb_ca_en50221_link_init(struct dvb_ca_private *ca, int slot)
         int buf_size;
         u8 buf[2];
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* we'll be determining these during this function */
         ca->slot_info[slot].da_irq_supported = 0;
@@ -549,7 +549,7 @@ static int dvb_ca_en50221_set_configoption(struct dvb_ca_private *ca, int slot)
 {
         int configoption;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* set the config option */
         ca->pub->write_attribute_mem(ca->pub, slot,
@@ -587,7 +587,7 @@ static int dvb_ca_en50221_read_data(struct dvb_ca_private *ca, int slot, u8 * eb
         u8 buf[HOST_LINK_BUF_SIZE];
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* check if we have space for a link buf in the rx_buffer */
         if (ebuf == NULL) {
@@ -708,7 +708,7 @@ static int dvb_ca_en50221_write_data(struct dvb_ca_private *ca, int slot, u8 * b
         int status;
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
 
         // sanity check
@@ -785,7 +785,7 @@ EXPORT_SYMBOL(dvb_ca_en50221_camchange_irq);
  */
 static int dvb_ca_en50221_slot_shutdown(struct dvb_ca_private *ca, int slot)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         ca->pub->slot_shutdown(ca->pub, slot);
         ca->slot_info[slot].slot_state = DVB_CA_SLOTSTATE_NONE;
@@ -892,7 +892,7 @@ void dvb_ca_en50221_frda_irq(struct dvb_ca_en50221 *pubca, int slot)
 static void dvb_ca_en50221_thread_wakeup(struct dvb_ca_private *ca)
 {
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         ca->wakeup = 1;
         mb();
@@ -964,7 +964,7 @@ static int dvb_ca_en50221_thread(void *data)
         int pktcount;
         void *rxbuf;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* choose the correct initial delay */
         dvb_ca_en50221_thread_update_delay(ca);
@@ -1172,7 +1172,7 @@ static int dvb_ca_en50221_io_do_ioctl(struct inode *inode, struct file *file,
         int err = 0;
         int slot;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         switch (cmd) {
         case CA_RESET:
@@ -1266,7 +1266,7 @@ static ssize_t dvb_ca_en50221_io_write(struct file *file,
         unsigned long timeout;
         int written;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* Incoming packet has a 2 byte header. hdr[0] = slot_id, hdr[1] = connection_id */
         if (count < 2)
@@ -1401,7 +1401,7 @@ static ssize_t dvb_ca_en50221_io_read(struct file *file, char __user * buf,
         int pktlen;
         int dispose = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* Outgoing packet has a 2 byte header. hdr[0] = slot_id, hdr[1] = connection_id */
         if (count < 2)
@@ -1490,7 +1490,7 @@ static int dvb_ca_en50221_io_open(struct inode *inode, struct file *file)
         int err;
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (!try_module_get(ca->pub->owner))
                 return -EIO;
@@ -1534,7 +1534,7 @@ static int dvb_ca_en50221_io_release(struct inode *inode, struct file *file)
         struct dvb_ca_private *ca = dvbdev->priv;
         int err;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* mark the CA device as closed */
         ca->open = 0;
@@ -1564,7 +1564,7 @@ static unsigned int dvb_ca_en50221_io_poll(struct file *file, poll_table * wait)
         int slot;
         int result = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (dvb_ca_en50221_io_read_condition(ca, &result, &slot) == 1) {
                 mask |= POLLIN;
@@ -1626,7 +1626,7 @@ int dvb_ca_en50221_init(struct dvb_adapter *dvb_adapter,
         struct dvb_ca_private *ca = NULL;
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (slot_count < 1)
                 return -EINVAL;
@@ -1704,7 +1704,7 @@ void dvb_ca_en50221_release(struct dvb_ca_en50221 *pubca)
         struct dvb_ca_private *ca = pubca->private;
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* shutdown the thread if there was one */
         kthread_stop(ca->thread);
diff --git a/drivers/media/dvb/dvb-core/dvb_demux.c b/drivers/media/dvb/dvb-core/dvb_demux.c
index 7959020f9317..934e15fffc56 100644
--- a/drivers/media/dvb/dvb-core/dvb_demux.c
+++ b/drivers/media/dvb/dvb-core/dvb_demux.c
@@ -368,7 +368,7 @@ static inline void dvb_dmx_swfilter_packet_type(struct dvb_demux_feed *feed,
 #define DVR_FEED(f)                                                     \
         (((f)->type == DMX_TYPE_TS) &&                                  \
         ((f)->feed.ts.is_filtering) &&                                  \
-        (((f)->ts_type & (TS_PACKET|TS_PAYLOAD_ONLY)) == TS_PACKET))
+        (((f)->ts_type & (TS_PACKET | TS_DEMUX)) == TS_PACKET))
 
 static void dvb_dmx_swfilter_packet(struct dvb_demux *demux, const u8 *buf)
 {
@@ -553,7 +553,7 @@ static void dvb_demux_feed_add(struct dvb_demux_feed *feed)
         spin_lock_irq(&feed->demux->lock);
         if (dvb_demux_feed_find(feed)) {
                 printk(KERN_ERR "%s: feed already in list (type=%x state=%x pid=%x)\n",
-                       __FUNCTION__, feed->type, feed->state, feed->pid);
+                       __func__, feed->type, feed->state, feed->pid);
                 goto out;
         }
 
@@ -567,7 +567,7 @@ static void dvb_demux_feed_del(struct dvb_demux_feed *feed)
         spin_lock_irq(&feed->demux->lock);
         if (!(dvb_demux_feed_find(feed))) {
                 printk(KERN_ERR "%s: feed not in list (type=%x state=%x pid=%x)\n",
-                       __FUNCTION__, feed->type, feed->state, feed->pid);
+                       __func__, feed->type, feed->state, feed->pid);
                 goto out;
         }
 
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.c b/drivers/media/dvb/dvb-core/dvb_frontend.c
index 925cfa6221ad..2dddd08c5445 100644
--- a/drivers/media/dvb/dvb-core/dvb_frontend.c
+++ b/drivers/media/dvb/dvb-core/dvb_frontend.c
@@ -135,7 +135,7 @@ static void dvb_frontend_add_event(struct dvb_frontend *fe, fe_status_t status)
         struct dvb_frontend_event *e;
         int wp;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (mutex_lock_interruptible (&events->mtx))
                 return;
@@ -171,7 +171,7 @@ static int dvb_frontend_get_event(struct dvb_frontend *fe,
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
         struct dvb_fe_events *events = &fepriv->events;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (events->overflow) {
                 events->overflow = 0;
@@ -237,7 +237,7 @@ static void dvb_frontend_swzigzag_update_delay(struct dvb_frontend_private *fepr
 {
         int q2;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (locked)
                 (fepriv->quality) = (fepriv->quality * 220 + 36*256) / 256;
@@ -329,7 +329,7 @@ static int dvb_frontend_swzigzag_autotune(struct dvb_frontend *fe, int check_wra
 
         dprintk("%s: drift:%i inversion:%i auto_step:%i "
                 "auto_sub_step:%i started_auto_step:%i\n",
-                __FUNCTION__, fepriv->lnb_drift, fepriv->inversion,
+                __func__, fepriv->lnb_drift, fepriv->inversion,
                 fepriv->auto_step, fepriv->auto_sub_step, fepriv->started_auto_step);
 
         /* set the frontend itself */
@@ -511,7 +511,7 @@ static int dvb_frontend_thread(void *data)
         fe_status_t s;
         struct dvb_frontend_parameters *params;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         fepriv->check_wrapped = 0;
         fepriv->quality = 0;
@@ -597,7 +597,7 @@ static void dvb_frontend_stop(struct dvb_frontend *fe)
 {
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         fepriv->exit = 1;
         mb();
@@ -665,7 +665,7 @@ static int dvb_frontend_start(struct dvb_frontend *fe)
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
         struct task_struct *fe_thread;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (fepriv->thread) {
                 if (!fepriv->exit)
@@ -763,7 +763,7 @@ static int dvb_frontend_ioctl(struct inode *inode, struct file *file,
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
         int err = -EOPNOTSUPP;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (fepriv->exit)
                 return -ENODEV;
@@ -895,7 +895,7 @@ static int dvb_frontend_ioctl(struct inode *inode, struct file *file,
                         int i;
                         u8 last = 1;
                         if (dvb_frontend_debug)
-                                printk("%s switch command: 0x%04lx\n", __FUNCTION__, cmd);
+                                printk("%s switch command: 0x%04lx\n", __func__, cmd);
                         do_gettimeofday(&nexttime);
                         if (dvb_frontend_debug)
                                 memcpy(&tv[0], &nexttime, sizeof(struct timeval));
@@ -919,7 +919,7 @@ static int dvb_frontend_ioctl(struct inode *inode, struct file *file,
                         }
                         if (dvb_frontend_debug) {
                                 printk("%s(%d): switch delay (should be 32k followed by all 8k\n",
-                                        __FUNCTION__, fe->dvb->num);
+                                        __func__, fe->dvb->num);
                                 for (i = 1; i < 10; i++)
                                         printk("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i]));
                         }
@@ -1037,7 +1037,7 @@ static unsigned int dvb_frontend_poll(struct file *file, struct poll_table_struc
         struct dvb_frontend *fe = dvbdev->priv;
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         poll_wait (file, &fepriv->events.wait_queue, wait);
 
@@ -1054,7 +1054,7 @@ static int dvb_frontend_open(struct inode *inode, struct file *file)
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
         int ret;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) {
                 if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0)
@@ -1095,7 +1095,7 @@ static int dvb_frontend_release(struct inode *inode, struct file *file)
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
         int ret;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if ((file->f_flags & O_ACCMODE) != O_RDONLY)
                 fepriv->release_jiffies = jiffies;
@@ -1135,7 +1135,7 @@ int dvb_register_frontend(struct dvb_adapter* dvb,
                 .kernel_ioctl = dvb_frontend_ioctl
         };
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (mutex_lock_interruptible(&frontend_mutex))
                 return -ERESTARTSYS;
@@ -1169,7 +1169,7 @@ EXPORT_SYMBOL(dvb_register_frontend);
 int dvb_unregister_frontend(struct dvb_frontend* fe)
 {
         struct dvb_frontend_private *fepriv = fe->frontend_priv;
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         mutex_lock(&frontend_mutex);
         dvb_frontend_stop (fe);
diff --git a/drivers/media/dvb/dvb-core/dvb_net.c b/drivers/media/dvb/dvb-core/dvb_net.c
index 4c8b62e2c035..56d871cfd7fc 100644
--- a/drivers/media/dvb/dvb-core/dvb_net.c
+++ b/drivers/media/dvb/dvb-core/dvb_net.c
@@ -354,7 +354,7 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
 #ifdef ULE_DEBUG
         /* The code inside ULE_DEBUG keeps a history of the last 100 TS cells processed. */
         static unsigned char ule_hist[100*TS_SZ];
-        static unsigned char *ule_where = ule_hist, ule_dump = 0;
+        static unsigned char *ule_where = ule_hist, ule_dump;
 #endif
 
         /* For all TS cells in current buffer.
@@ -965,17 +965,17 @@ static int dvb_net_feed_start(struct net_device *dev)
         struct dmx_demux *demux = priv->demux;
         unsigned char *mac = (unsigned char *) dev->dev_addr;
 
-        dprintk("%s: rx_mode %i\n", __FUNCTION__, priv->rx_mode);
+        dprintk("%s: rx_mode %i\n", __func__, priv->rx_mode);
         mutex_lock(&priv->mutex);
         if (priv->tsfeed || priv->secfeed || priv->secfilter || priv->multi_secfilter[0])
-                printk("%s: BUG %d\n", __FUNCTION__, __LINE__);
+                printk("%s: BUG %d\n", __func__, __LINE__);
 
         priv->secfeed=NULL;
         priv->secfilter=NULL;
         priv->tsfeed = NULL;
 
         if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {
-                dprintk("%s: alloc secfeed\n", __FUNCTION__);
+                dprintk("%s: alloc secfeed\n", __func__);
                 ret=demux->allocate_section_feed(demux, &priv->secfeed,
                                          dvb_net_sec_callback);
                 if (ret<0) {
@@ -993,38 +993,38 @@ static int dvb_net_feed_start(struct net_device *dev)
                 }
 
                 if (priv->rx_mode != RX_MODE_PROMISC) {
-                        dprintk("%s: set secfilter\n", __FUNCTION__);
+                        dprintk("%s: set secfilter\n", __func__);
                         dvb_net_filter_sec_set(dev, &priv->secfilter, mac, mask_normal);
                 }
 
                 switch (priv->rx_mode) {
                 case RX_MODE_MULTI:
                         for (i = 0; i < priv->multi_num; i++) {
-                                dprintk("%s: set multi_secfilter[%d]\n", __FUNCTION__, i);
+                                dprintk("%s: set multi_secfilter[%d]\n", __func__, i);
                                 dvb_net_filter_sec_set(dev, &priv->multi_secfilter[i],
                                                        priv->multi_macs[i], mask_normal);
                         }
                         break;
                 case RX_MODE_ALL_MULTI:
                         priv->multi_num=1;
-                        dprintk("%s: set multi_secfilter[0]\n", __FUNCTION__);
+                        dprintk("%s: set multi_secfilter[0]\n", __func__);
                         dvb_net_filter_sec_set(dev, &priv->multi_secfilter[0],
                                                mac_allmulti, mask_allmulti);
                         break;
                 case RX_MODE_PROMISC:
                         priv->multi_num=0;
-                        dprintk("%s: set secfilter\n", __FUNCTION__);
+                        dprintk("%s: set secfilter\n", __func__);
                         dvb_net_filter_sec_set(dev, &priv->secfilter, mac, mask_promisc);
                         break;
                 }
 
-                dprintk("%s: start filtering\n", __FUNCTION__);
+                dprintk("%s: start filtering\n", __func__);
                 priv->secfeed->start_filtering(priv->secfeed);
         } else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {
                 struct timespec timeout = { 0, 10000000 }; // 10 msec
 
                 /* we have payloads encapsulated in TS */
-                dprintk("%s: alloc tsfeed\n", __FUNCTION__);
+                dprintk("%s: alloc tsfeed\n", __func__);
                 ret = demux->allocate_ts_feed(demux, &priv->tsfeed, dvb_net_ts_callback);
                 if (ret < 0) {
                         printk("%s: could not allocate ts feed\n", dev->name);
@@ -1048,7 +1048,7 @@ static int dvb_net_feed_start(struct net_device *dev)
                         goto error;
                 }
 
-                dprintk("%s: start filtering\n", __FUNCTION__);
+                dprintk("%s: start filtering\n", __func__);
                 priv->tsfeed->start_filtering(priv->tsfeed);
         } else
                 ret = -EINVAL;
@@ -1063,17 +1063,17 @@ static int dvb_net_feed_stop(struct net_device *dev)
         struct dvb_net_priv *priv = dev->priv;
         int i, ret = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         mutex_lock(&priv->mutex);
         if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {
                 if (priv->secfeed) {
                         if (priv->secfeed->is_filtering) {
-                                dprintk("%s: stop secfeed\n", __FUNCTION__);
+                                dprintk("%s: stop secfeed\n", __func__);
                                 priv->secfeed->stop_filtering(priv->secfeed);
                         }
 
                         if (priv->secfilter) {
-                                dprintk("%s: release secfilter\n", __FUNCTION__);
+                                dprintk("%s: release secfilter\n", __func__);
                                 priv->secfeed->release_filter(priv->secfeed,
                                                               priv->secfilter);
                                 priv->secfilter=NULL;
@@ -1082,7 +1082,7 @@ static int dvb_net_feed_stop(struct net_device *dev)
                         for (i=0; i<priv->multi_num; i++) {
                                 if (priv->multi_secfilter[i]) {
                                         dprintk("%s: release multi_filter[%d]\n",
-                                                __FUNCTION__, i);
+                                                __func__, i);
                                         priv->secfeed->release_filter(priv->secfeed,
                                                                       priv->multi_secfilter[i]);
                                         priv->multi_secfilter[i] = NULL;
@@ -1096,7 +1096,7 @@ static int dvb_net_feed_stop(struct net_device *dev)
         } else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {
                 if (priv->tsfeed) {
                         if (priv->tsfeed->is_filtering) {
-                                dprintk("%s: stop tsfeed\n", __FUNCTION__);
+                                dprintk("%s: stop tsfeed\n", __func__);
                                 priv->tsfeed->stop_filtering(priv->tsfeed);
                         }
                         priv->demux->release_ts_feed(priv->demux, priv->tsfeed);
diff --git a/drivers/media/dvb/dvb-core/dvb_ringbuffer.c b/drivers/media/dvb/dvb-core/dvb_ringbuffer.c
index ac9d93cf83c6..872985b7912d 100644
--- a/drivers/media/dvb/dvb-core/dvb_ringbuffer.c
+++ b/drivers/media/dvb/dvb-core/dvb_ringbuffer.c
@@ -90,7 +90,11 @@ void dvb_ringbuffer_flush(struct dvb_ringbuffer *rbuf)
         rbuf->error = 0;
 }
 
-
+void dvb_ringbuffer_reset(struct dvb_ringbuffer *rbuf)
+{
+        rbuf->pread = rbuf->pwrite = 0;
+        rbuf->error = 0;
+}
 
 void dvb_ringbuffer_flush_spinlock_wakeup(struct dvb_ringbuffer *rbuf)
 {
diff --git a/drivers/media/dvb/dvb-core/dvb_ringbuffer.h b/drivers/media/dvb/dvb-core/dvb_ringbuffer.h
index d97714e75736..890826262966 100644
--- a/drivers/media/dvb/dvb-core/dvb_ringbuffer.h
+++ b/drivers/media/dvb/dvb-core/dvb_ringbuffer.h
@@ -69,6 +69,7 @@ struct dvb_ringbuffer {
 **     to lock read or write operations.
 **     Two or more readers must be locked against each other.
 **     Flushing the buffer counts as a read operation.
+**     Resetting the buffer counts as a read and write operation.
 **     Two or more writers must be locked against each other.
 */
 
@@ -85,6 +86,13 @@ extern ssize_t dvb_ringbuffer_free(struct dvb_ringbuffer *rbuf);
 extern ssize_t dvb_ringbuffer_avail(struct dvb_ringbuffer *rbuf);
 
 
+/*
+** Reset the read and write pointers to zero and flush the buffer
+** This counts as a read and write operation
+*/
+extern void dvb_ringbuffer_reset(struct dvb_ringbuffer *rbuf);
+
+
 /* read routines & macros */
 /* ---------------------- */
 /* flush buffer */
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 18738faecbbc..8b56d929f7fd 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -49,7 +49,6 @@ static const char * const dnames[] = {
         "net", "osd"
 };
 
-#define DVB_MAX_ADAPTERS        8
 #define DVB_MAX_IDS             4
 #define nums2minor(num,type,id) ((num << 6) | (id << 4) | type)
 #define MAX_DVB_MINORS          (DVB_MAX_ADAPTERS*64)
@@ -97,7 +96,7 @@ static int dvb_device_open(struct inode *inode, struct file *file)
 }
 
 
-static struct file_operations dvb_device_fops =
+static const struct file_operations dvb_device_fops =
 {
         .owner =        THIS_MODULE,
         .open =         dvb_device_open,
@@ -196,7 +195,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
         if ((id = dvbdev_get_free_id (adap, type)) < 0){
                 mutex_unlock(&dvbdev_register_lock);
                 *pdvbdev = NULL;
-                printk(KERN_ERR "%s: couldn't find free device id\n", __FUNCTION__);
+                printk(KERN_ERR "%s: couldn't find free device id\n", __func__);
                 return -ENFILE;
         }
 
@@ -235,7 +234,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
                                "dvb%d.%s%d", adap->num, dnames[type], id);
         if (IS_ERR(clsdev)) {
                 printk(KERN_ERR "%s: failed to create device dvb%d.%s%d (%ld)\n",
-                       __FUNCTION__, adap->num, dnames[type], id, PTR_ERR(clsdev));
+                       __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
                 return PTR_ERR(clsdev);
         }
 
@@ -262,18 +261,25 @@ void dvb_unregister_device(struct dvb_device *dvbdev)
 }
 EXPORT_SYMBOL(dvb_unregister_device);
 
+static int dvbdev_check_free_adapter_num(int num)
+{
+        struct list_head *entry;
+        list_for_each(entry, &dvb_adapter_list) {
+                struct dvb_adapter *adap;
+                adap = list_entry(entry, struct dvb_adapter, list_head);
+                if (adap->num == num)
+                        return 0;
+        }
+        return 1;
+}
 
 static int dvbdev_get_free_adapter_num (void)
 {
         int num = 0;
 
         while (num < DVB_MAX_ADAPTERS) {
-                struct dvb_adapter *adap;
-                list_for_each_entry(adap, &dvb_adapter_list, list_head)
-                        if (adap->num == num)
-                                goto skip;
-                return num;
-skip:
+                if (dvbdev_check_free_adapter_num(num))
+                        return num;
                 num++;
         }
 
@@ -281,13 +287,28 @@ skip:
 }
 
 
-int dvb_register_adapter(struct dvb_adapter *adap, const char *name, struct module *module, struct device *device)
+int dvb_register_adapter(struct dvb_adapter *adap, const char *name,
+                         struct module *module, struct device *device,
+                         short *adapter_nums)
 {
-        int num;
+        int i, num;
 
         mutex_lock(&dvbdev_register_lock);
 
-        if ((num = dvbdev_get_free_adapter_num ()) < 0) {
+        for (i = 0; i < DVB_MAX_ADAPTERS; ++i) {
+                num = adapter_nums[i];
+                if (num >= 0  &&  num < DVB_MAX_ADAPTERS) {
+                /* use the one the driver asked for */
+                        if (dvbdev_check_free_adapter_num(num))
+                                break;
+                } else {
+                        num = dvbdev_get_free_adapter_num();
+                        break;
+                }
+                num = -1;
+        }
+
+        if (num < 0) {
                 mutex_unlock(&dvbdev_register_lock);
                 return -ENFILE;
         }
diff --git a/drivers/media/dvb/dvb-core/dvbdev.h b/drivers/media/dvb/dvb-core/dvbdev.h
index 6dff10ebf470..5f9a737c6de1 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.h
+++ b/drivers/media/dvb/dvb-core/dvbdev.h
@@ -31,6 +31,10 @@
 
 #define DVB_MAJOR 212
 
+#define DVB_MAX_ADAPTERS 8
+
+#define DVB_UNSET (-1)
+
 #define DVB_DEVICE_VIDEO      0
 #define DVB_DEVICE_AUDIO      1
 #define DVB_DEVICE_SEC        2
@@ -41,6 +45,11 @@
 #define DVB_DEVICE_NET        7
 #define DVB_DEVICE_OSD        8
 
+#define DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr) \
+        static short adapter_nr[] = \
+                {[0 ... (DVB_MAX_ADAPTERS - 1)] = DVB_UNSET }; \
+        module_param_array(adapter_nr, short, NULL, 0444); \
+        MODULE_PARM_DESC(adapter_nr, "DVB adapter numbers")
 
 struct dvb_adapter {
         int num;
@@ -78,7 +87,9 @@ struct dvb_device {
 };
 
 
-extern int dvb_register_adapter (struct dvb_adapter *adap, const char *name, struct module *module, struct device *device);
+extern int dvb_register_adapter(struct dvb_adapter *adap, const char *name,
+                                struct module *module, struct device *device,
+                                short *adapter_nums);
 extern int dvb_unregister_adapter (struct dvb_adapter *adap);
 
 extern int dvb_register_device (struct dvb_adapter *adap,
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
index d73934dd4c57..3c8493d2026d 100644
--- a/drivers/media/dvb/dvb-usb/Kconfig
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -105,6 +105,7 @@ config DVB_USB_CXUSB
         select DVB_LGDT330X if !DVB_FE_CUSTOMISE
         select DVB_MT352 if !DVB_FE_CUSTOMISE
         select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select TUNER_SIMPLE if !DVB_FE_CUSTOMISE
         help
           Say Y here to support the Conexant USB2.0 hybrid reference design.
           Currently, only DVB and ATSC modes are supported, analog mode
diff --git a/drivers/media/dvb/dvb-usb/a800.c b/drivers/media/dvb/dvb-usb/a800.c
index a6c5f19f680d..dc8c8784caa8 100644
--- a/drivers/media/dvb/dvb-usb/a800.c
+++ b/drivers/media/dvb/dvb-usb/a800.c
@@ -18,6 +18,9 @@
 static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (rc=1 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define deb_rc(args...)   dprintk(debug,0x01,args)
 
 static int a800_power_ctrl(struct dvb_usb_device *d, int onoff)
@@ -94,7 +97,8 @@ static struct dvb_usb_device_properties a800_properties;
 static int a800_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf,&a800_properties,THIS_MODULE,NULL);
+        return dvb_usb_device_init(intf, &a800_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 /* do not change the order of the ID table */
diff --git a/drivers/media/dvb/dvb-usb/af9005.c b/drivers/media/dvb/dvb-usb/af9005.c
index e7f76f515b4f..cfe71feefcad 100644
--- a/drivers/media/dvb/dvb-usb/af9005.c
+++ b/drivers/media/dvb/dvb-usb/af9005.c
@@ -39,6 +39,8 @@ int dvb_usb_af9005_dump_eeprom = 0;
 module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0);
 MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom.");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 /* remote control decoder */
 int (*rc_decode) (struct dvb_usb_device * d, u8 * data, int len, u32 * event,
                   int *state);
@@ -1020,7 +1022,8 @@ static struct dvb_usb_device_properties af9005_properties;
 static int af9005_usb_probe(struct usb_interface *intf,
                             const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf, &af9005_properties, THIS_MODULE, NULL);
+        return dvb_usb_device_init(intf, &af9005_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 static struct usb_device_id af9005_usb_table[] = {
diff --git a/drivers/media/dvb/dvb-usb/au6610.c b/drivers/media/dvb/dvb-usb/au6610.c
index f3ff81314696..2ccb90fa60c8 100644
--- a/drivers/media/dvb/dvb-usb/au6610.c
+++ b/drivers/media/dvb/dvb-usb/au6610.c
@@ -19,6 +19,8 @@ static int dvb_usb_au6610_debug;
 module_param_named(debug, dvb_usb_au6610_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static int au6610_usb_msg(struct dvb_usb_device *d, u8 operation, u8 addr,
                           u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
 {
@@ -163,7 +165,9 @@ static int au6610_probe(struct usb_interface *intf,
         if (intf->num_altsetting < AU6610_ALTSETTING_COUNT)
                 return -ENODEV;
 
-        if ((ret = dvb_usb_device_init(intf, &au6610_properties, THIS_MODULE, &d)) == 0) {
+        ret = dvb_usb_device_init(intf, &au6610_properties, THIS_MODULE, &d,
+                                  adapter_nr);
+        if (ret == 0) {
                 alt = usb_altnum_to_altsetting(intf, AU6610_ALTSETTING);
 
                 if (alt == NULL) {
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c
index c58365005ac1..720fcd1c3c1d 100644
--- a/drivers/media/dvb/dvb-usb/cxusb.c
+++ b/drivers/media/dvb/dvb-usb/cxusb.c
@@ -23,6 +23,8 @@
  *
  * see Documentation/dvb/README.dvb-usb for more information
  */
+#include <media/tuner.h>
+
 #include "cxusb.h"
 
 #include "cx22702.h"
@@ -31,12 +33,15 @@
 #include "mt352_priv.h"
 #include "zl10353.h"
 #include "tuner-xc2028.h"
-#include "tuner-xc2028-types.h"
+#include "tuner-simple.h"
 
 /* debug */
 static int dvb_usb_cxusb_debug;
 module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define deb_info(args...)   dprintk(dvb_usb_cxusb_debug,0x01,args)
 #define deb_i2c(args...)    if (d->udev->descriptor.idVendor == USB_VID_MEDION) \
                                 dprintk(dvb_usb_cxusb_debug,0x01,args)
@@ -450,8 +455,9 @@ static struct mt352_config cxusb_mt352_xc3028_config = {
 /* Callbacks for DVB USB */
 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
 {
-        dvb_attach(dvb_pll_attach, adap->fe, 0x61, &adap->dev->i2c_adap,
-                   DVB_PLL_FMD1216ME);
+        dvb_attach(simple_tuner_attach, adap->fe,
+                   &adap->dev->i2c_adap, 0x61,
+                   TUNER_PHILIPS_FMD1216ME_MK3);
         return 0;
 }
 
@@ -477,8 +483,8 @@ static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
 
 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
 {
-        dvb_attach(dvb_pll_attach, adap->fe, 0x61, &adap->dev->i2c_adap,
-                   DVB_PLL_LG_TDVS_H06XF);
+        dvb_attach(simple_tuner_attach, adap->fe,
+                   &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
         return 0;
 }
 
@@ -488,14 +494,14 @@ static int dvico_bluebird_xc2028_callback(void *ptr, int command, int arg)
 
         switch (command) {
         case XC2028_TUNER_RESET:
-                deb_info("%s: XC2028_TUNER_RESET %d\n", __FUNCTION__, arg);
+                deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
                 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
                 break;
         case XC2028_RESET_CLK:
-                deb_info("%s: XC2028_RESET_CLK %d\n", __FUNCTION__, arg);
+                deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
                 break;
         default:
-                deb_info("%s: unknown command %d, arg %d\n", __FUNCTION__,
+                deb_info("%s: unknown command %d, arg %d\n", __func__,
                          command, arg);
                 return -EINVAL;
         }
@@ -509,13 +515,12 @@ static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
         struct xc2028_config      cfg = {
                 .i2c_adap  = &adap->dev->i2c_adap,
                 .i2c_addr  = 0x61,
-                .video_dev = adap->dev,
                 .callback  = dvico_bluebird_xc2028_callback,
         };
         static struct xc2028_ctrl ctl = {
                 .fname       = "xc3028-dvico-au-01.fw",
                 .max_len     = 64,
-                .scode_table = ZARLINK456,
+                .scode_table = XC3028_FE_ZARLINK456,
         };
 
         fe = dvb_attach(xc2028_attach, adap->fe, &cfg);
@@ -720,16 +725,24 @@ static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_prope
 static int cxusb_probe(struct usb_interface *intf,
                        const struct usb_device_id *id)
 {
-        if (dvb_usb_device_init(intf,&cxusb_medion_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_lgh064f_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_dee1601_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_lgz201_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_dtt7579_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_dualdig4_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_nano2_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&cxusb_bluebird_nano2_needsfirmware_properties,THIS_MODULE,NULL) == 0) {
+        if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf,
+                                &cxusb_bluebird_nano2_needsfirmware_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
                 return 0;
-        }
 
         return -EINVAL;
 }
diff --git a/drivers/media/dvb/dvb-usb/dib0700.h b/drivers/media/dvb/dvb-usb/dib0700.h
index 4a903ea95896..66d4dc6ba46f 100644
--- a/drivers/media/dvb/dvb-usb/dib0700.h
+++ b/drivers/media/dvb/dvb-usb/dib0700.h
@@ -37,6 +37,7 @@ struct dib0700_state {
         u8 channel_state;
         u16 mt2060_if1[2];
         u8 rc_toggle;
+        u8 rc_counter;
         u8 is_dib7000pc;
 };
 
@@ -44,12 +45,15 @@ extern int dib0700_set_gpio(struct dvb_usb_device *, enum dib07x0_gpios gpio, u8
 extern int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3);
 extern int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen);
 extern int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw);
+extern int dib0700_rc_setup(struct dvb_usb_device *d);
 extern int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff);
 extern struct i2c_algorithm dib0700_i2c_algo;
 extern int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
                         struct dvb_usb_device_description **desc, int *cold);
 
 extern int dib0700_device_count;
+extern int dvb_usb_dib0700_ir_proto;
 extern struct dvb_usb_device_properties dib0700_devices[];
 extern struct usb_device_id dib0700_usb_id_table[];
+
 #endif
diff --git a/drivers/media/dvb/dvb-usb/dib0700_core.c b/drivers/media/dvb/dvb-usb/dib0700_core.c
index c9857d5c6982..595a04696c87 100644
--- a/drivers/media/dvb/dvb-usb/dib0700_core.c
+++ b/drivers/media/dvb/dvb-usb/dib0700_core.c
@@ -13,10 +13,12 @@ int dvb_usb_dib0700_debug;
 module_param_named(debug,dvb_usb_dib0700_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS);
 
-static int dvb_usb_dib0700_ir_proto = 1;
+int dvb_usb_dib0700_ir_proto = 1;
 module_param(dvb_usb_dib0700_ir_proto, int, 0644);
 MODULE_PARM_DESC(dvb_usb_dib0700_ir_proto, "set ir protocol (0=NEC, 1=RC5 (default), 2=RC6).");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 /* expecting rx buffer: request data[0] data[1] ... data[2] */
 static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen)
 {
@@ -261,7 +263,7 @@ int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
         return dib0700_ctrl_wr(adap->dev, b, 4);
 }
 
-static int dib0700_rc_setup(struct dvb_usb_device *d)
+int dib0700_rc_setup(struct dvb_usb_device *d)
 {
         u8 rc_setup[3] = {REQUEST_SET_RC, dvb_usb_dib0700_ir_proto, 0};
         int i = dib0700_ctrl_wr(d, rc_setup, 3);
@@ -279,7 +281,8 @@ static int dib0700_probe(struct usb_interface *intf,
         struct dvb_usb_device *dev;
 
         for (i = 0; i < dib0700_device_count; i++)
-                if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE, &dev) == 0)
+                if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE,
+                                        &dev, adapter_nr) == 0)
                 {
                         dib0700_rc_setup(dev);
                         return 0;
diff --git a/drivers/media/dvb/dvb-usb/dib0700_devices.c b/drivers/media/dvb/dvb-usb/dib0700_devices.c
index e7093826e975..6477fc66cc23 100644
--- a/drivers/media/dvb/dvb-usb/dib0700_devices.c
+++ b/drivers/media/dvb/dvb-usb/dib0700_devices.c
@@ -13,6 +13,7 @@
 #include "dib7000p.h"
 #include "mt2060.h"
 #include "mt2266.h"
+#include "tuner-xc2028.h"
 #include "dib0070.h"
 
 static int force_lna_activation;
@@ -297,10 +298,156 @@ static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;;
 }
 
+/* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
+struct dibx000_agc_config xc3028_agc_config = {
+        BAND_VHF | BAND_UHF,       /* band_caps */
+
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
+         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
+         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
+        (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
+
+        712,    /* inv_gain */
+        21,     /* time_stabiliz */
+
+        0,      /* alpha_level */
+        118,    /* thlock */
+
+        0,      /* wbd_inv */
+        2867,   /* wbd_ref */
+        0,      /* wbd_sel */
+        2,      /* wbd_alpha */
+
+        0,      /* agc1_max */
+        0,      /* agc1_min */
+        39718,  /* agc2_max */
+        9930,   /* agc2_min */
+        0,      /* agc1_pt1 */
+        0,      /* agc1_pt2 */
+        0,      /* agc1_pt3 */
+        0,      /* agc1_slope1 */
+        0,      /* agc1_slope2 */
+        0,      /* agc2_pt1 */
+        128,    /* agc2_pt2 */
+        29,     /* agc2_slope1 */
+        29,     /* agc2_slope2 */
+
+        17,     /* alpha_mant */
+        27,     /* alpha_exp */
+        23,     /* beta_mant */
+        51,     /* beta_exp */
+
+        1,      /* perform_agc_softsplit */
+};
+
+/* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
+struct dibx000_bandwidth_config xc3028_bw_config = {
+        60000, 30000, /* internal, sampling */
+        1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
+        0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
+                          modulo */
+        (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
+        (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
+        20452225, /* timf */
+        30000000, /* xtal_hz */
+};
+
+static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
+        .output_mpeg2_in_188_bytes = 1,
+        .tuner_is_baseband = 1,
+
+        .agc_config_count = 1,
+        .agc = &xc3028_agc_config,
+        .bw  = &xc3028_bw_config,
+
+        .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+};
+
+static int stk7700ph_xc3028_callback(void *ptr, int command, int arg)
+{
+        struct dvb_usb_adapter *adap = ptr;
+
+        switch (command) {
+        case XC2028_TUNER_RESET:
+                /* Send the tuner in then out of reset */
+                dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
+                dib7000p_set_gpio(adap->fe, 8, 0, 1);
+                break;
+        case XC2028_RESET_CLK:
+                break;
+        default:
+                err("%s: unknown command %d, arg %d\n", __func__,
+                        command, arg);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
+        .fname = XC2028_DEFAULT_FIRMWARE,
+        .max_len = 64,
+        .demod = XC3028_FE_DIBCOM52,
+};
+
+static struct xc2028_config stk7700ph_xc3028_config = {
+        .i2c_addr = 0x61,
+        .callback = stk7700ph_xc3028_callback,
+        .ctrl = &stk7700ph_xc3028_ctrl,
+};
+
+static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
+
+        if (desc->idVendor  == USB_VID_PINNACLE &&
+            desc->idProduct == USB_PID_PINNACLE_EXPRESSCARD_320CX)
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        else
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+        msleep(10);
+
+        dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                &stk7700ph_dib7700_xc3028_config);
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+                &stk7700ph_dib7700_xc3028_config);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *tun_i2c;
+
+        tun_i2c = dib7000p_get_i2c_master(adap->fe,
+                DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        stk7700ph_xc3028_config.i2c_adap = tun_i2c;
+        stk7700ph_xc3028_config.video_dev = adap;
+
+        return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
+                == NULL ? -ENODEV : 0;
+}
+
 #define DEFAULT_RC_INTERVAL 150
 
 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
 
+/* Number of keypresses to ignore before start repeating */
+#define RC_REPEAT_DELAY 2
+
 static int dib0700_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
 {
         u8 key[4];
@@ -314,18 +461,67 @@ static int dib0700_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
                 err("RC Query Failed");
                 return -1;
         }
+
+        /* losing half of KEY_0 events from Philipps rc5 remotes.. */
         if (key[0]==0 && key[1]==0 && key[2]==0 && key[3]==0) return 0;
-        if (key[3-1]!=st->rc_toggle) {
+
+        /* info("%d: %2X %2X %2X %2X",dvb_usb_dib0700_ir_proto,(int)key[3-2],(int)key[3-3],(int)key[3-1],(int)key[3]);  */
+
+        dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
+
+        switch (dvb_usb_dib0700_ir_proto) {
+        case 0: {
+                /* NEC protocol sends repeat code as 0 0 0 FF */
+                if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
+                    (key[3] == 0xFF)) {
+                        st->rc_counter++;
+                        if (st->rc_counter > RC_REPEAT_DELAY) {
+                                *event = d->last_event;
+                                *state = REMOTE_KEY_PRESSED;
+                                st->rc_counter = RC_REPEAT_DELAY;
+                        }
+                        return 0;
+                }
                 for (i=0;i<d->props.rc_key_map_size; i++) {
                         if (keymap[i].custom == key[3-2] && keymap[i].data == key[3-3]) {
+                                st->rc_counter = 0;
+                                *event = keymap[i].event;
+                                *state = REMOTE_KEY_PRESSED;
+                                d->last_event = keymap[i].event;
+                                return 0;
+                        }
+                }
+                break;
+        }
+        default: {
+                /* RC-5 protocol changes toggle bit on new keypress */
+                for (i = 0; i < d->props.rc_key_map_size; i++) {
+                        if (keymap[i].custom == key[3-2] && keymap[i].data == key[3-3]) {
+                                if (d->last_event == keymap[i].event &&
+                                        key[3-1] == st->rc_toggle) {
+                                        st->rc_counter++;
+                                        /* prevents unwanted double hits */
+                                        if (st->rc_counter > RC_REPEAT_DELAY) {
+                                                *event = d->last_event;
+                                                *state = REMOTE_KEY_PRESSED;
+                                                st->rc_counter = RC_REPEAT_DELAY;
+                                        }
+
+                                        return 0;
+                                }
+                                st->rc_counter = 0;
                                 *event = keymap[i].event;
                                 *state = REMOTE_KEY_PRESSED;
-                                st->rc_toggle=key[3-1];
+                                st->rc_toggle = key[3-1];
+                                d->last_event = keymap[i].event;
                                 return 0;
                         }
                 }
-                err("Unknown remote controller key : %2X %2X",(int)key[3-2],(int)key[3-3]);
+                break;
         }
+        }
+        err("Unknown remote controller key: %2X %2X %2X %2X", (int) key[3-2], (int) key[3-3], (int) key[3-1], (int) key[3]);
+        d->last_event = 0;
         return 0;
 }
 
@@ -794,6 +990,10 @@ static struct dib7000p_config dib7070p_dib7000p_config = {
 /* STK7070P */
 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 {
+        if (adap->dev->udev->descriptor.idVendor  == USB_VID_PINNACLE &&
+        adap->dev->udev->descriptor.idProduct == USB_PID_PINNACLE_PCTV72E)
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        else
         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
@@ -808,9 +1008,11 @@ static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
         msleep(10);
         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
 
-        dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, &dib7070p_dib7000p_config);
+        dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                &dib7070p_dib7000p_config);
 
-        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &dib7070p_dib7000p_config);
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+                &dib7070p_dib7000p_config);
         return adap->fe == NULL ? -ENODEV : 0;
 }
 
@@ -878,34 +1080,43 @@ static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
 /* DVB-USB and USB stuff follows */
 struct usb_device_id dib0700_usb_id_table[] = {
 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
-                { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
-
-                { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
-                { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
-                { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
-                { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
-                { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
-                { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
-                { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
+        { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
+        { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
+        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
-                { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
-                { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
-                { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
-                { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
+        { USB_DEVICE(USB_VID_TERRATEC,
+                        USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
-                { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
-                { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
-                { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
-                { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
+        { USB_DEVICE(USB_VID_PINNACLE,
+                        USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
+        { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
-                { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
-                { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
-                { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
-                { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
-/* 25 */        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
-                { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
-                { 0 }           /* Terminating entry */
+        { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
+        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
+        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
+        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
+/* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
+/* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
+        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
+        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
+        { 0 }           /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
 
@@ -969,7 +1180,7 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                                 { NULL },
                         },
                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
-                                { &dib0700_usb_id_table[8], NULL },
+                                { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
                                 { NULL },
                         },
                         {   "AVerMedia AVerTV DVB-T Express",
@@ -1069,12 +1280,16 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                         },
                 },
 
-                .num_device_descs = 1,
+                .num_device_descs = 2,
                 .devices = {
                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
                                 { &dib0700_usb_id_table[23], NULL },
                                 { NULL },
                         },
+                        {   "Yuan EC372S",
+                                { &dib0700_usb_id_table[31], NULL },
+                                { NULL },
+                        }
                 }
         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
 
@@ -1090,7 +1305,7 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                         },
                 },
 
-                .num_device_descs = 6,
+                .num_device_descs = 9,
                 .devices = {
                         {   "DiBcom STK7070P reference design",
                                 { &dib0700_usb_id_table[15], NULL },
@@ -1116,6 +1331,18 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                                 { &dib0700_usb_id_table[26], NULL },
                                 { NULL },
                         },
+                        {   "Pinnacle PCTV 72e",
+                                { &dib0700_usb_id_table[29], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 73e",
+                                { &dib0700_usb_id_table[30], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy T USB XXS",
+                                { &dib0700_usb_id_table[33], NULL },
+                                { NULL },
+                        },
                 },
 
                 .rc_interval      = DEFAULT_RC_INTERVAL,
@@ -1155,6 +1382,40 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                                 { NULL },
                         }
                 }
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = stk7700ph_frontend_attach,
+                                .tuner_attach     = stk7700ph_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv = sizeof(struct
+                                                dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 3,
+                .devices = {
+                        {   "Terratec Cinergy HT USB XE",
+                                { &dib0700_usb_id_table[27], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle Expresscard 320cx",
+                                { &dib0700_usb_id_table[28], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy HT Express",
+                                { &dib0700_usb_id_table[32], NULL },
+                                { NULL },
+                        },
+                },
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_key_map       = dib0700_rc_keys,
+                .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
+                .rc_query         = dib0700_rc_query
         },
 };
 
diff --git a/drivers/media/dvb/dvb-usb/dibusb-mb.c b/drivers/media/dvb/dvb-usb/dibusb-mb.c
index 043cadae0859..eeef50bff4f9 100644
--- a/drivers/media/dvb/dvb-usb/dibusb-mb.c
+++ b/drivers/media/dvb/dvb-usb/dibusb-mb.c
@@ -14,6 +14,8 @@
  */
 #include "dibusb.h"
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static int dib3000mb_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 {
         struct dvb_usb_adapter *adap = fe->dvb->priv;
@@ -107,10 +109,14 @@ static struct dvb_usb_device_properties artec_t1_usb2_properties;
 static int dibusb_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        if (dvb_usb_device_init(intf,&dibusb1_1_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&dibusb1_1_an2235_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&dibusb2_0b_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&artec_t1_usb2_properties,THIS_MODULE,NULL) == 0)
+        if (0 == dvb_usb_device_init(intf, &dibusb1_1_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &dibusb1_1_an2235_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &dibusb2_0b_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &artec_t1_usb2_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
                 return 0;
 
         return -EINVAL;
diff --git a/drivers/media/dvb/dvb-usb/dibusb-mc.c b/drivers/media/dvb/dvb-usb/dibusb-mc.c
index e7ea3e753d6d..059cec955318 100644
--- a/drivers/media/dvb/dvb-usb/dibusb-mc.c
+++ b/drivers/media/dvb/dvb-usb/dibusb-mc.c
@@ -14,13 +14,16 @@
  */
 #include "dibusb.h"
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 /* USB Driver stuff */
 static struct dvb_usb_device_properties dibusb_mc_properties;
 
 static int dibusb_mc_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf,&dibusb_mc_properties,THIS_MODULE,NULL);
+        return dvb_usb_device_init(intf, &dibusb_mc_properties, THIS_MODULE,
+                                   NULL, adapter_nr);
 }
 
 /* do not change the order of the ID table */
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c
index 3acbda4aa27e..b545cf3eab2e 100644
--- a/drivers/media/dvb/dvb-usb/digitv.c
+++ b/drivers/media/dvb/dvb-usb/digitv.c
@@ -20,6 +20,9 @@
 static int dvb_usb_digitv_debug;
 module_param_named(debug,dvb_usb_digitv_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define deb_rc(args...)   dprintk(dvb_usb_digitv_debug,0x01,args)
 
 static int digitv_ctrl_msg(struct dvb_usb_device *d,
@@ -256,8 +259,9 @@ static int digitv_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
         struct dvb_usb_device *d;
-        int ret;
-        if ((ret = dvb_usb_device_init(intf,&digitv_properties,THIS_MODULE,&d)) == 0) {
+        int ret = dvb_usb_device_init(intf, &digitv_properties, THIS_MODULE, &d,
+                                      adapter_nr);
+        if (ret == 0) {
                 u8 b[4] = { 0 };
 
                 if (d != NULL) { /* do that only when the firmware is loaded */
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.c b/drivers/media/dvb/dvb-usb/dtt200u.c
index d86cf9bee91c..81a6cbf60160 100644
--- a/drivers/media/dvb/dvb-usb/dtt200u.c
+++ b/drivers/media/dvb/dvb-usb/dtt200u.c
@@ -18,6 +18,8 @@ int dvb_usb_dtt200u_debug;
 module_param_named(debug,dvb_usb_dtt200u_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2 (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static int dtt200u_power_ctrl(struct dvb_usb_device *d, int onoff)
 {
         u8 b = SET_INIT;
@@ -101,11 +103,16 @@ static struct dvb_usb_device_properties wt220u_miglia_properties;
 static int dtt200u_usb_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        if (dvb_usb_device_init(intf,&dtt200u_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&wt220u_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&wt220u_fc_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&wt220u_zl0353_properties,THIS_MODULE,NULL) == 0 ||
-                dvb_usb_device_init(intf,&wt220u_miglia_properties,THIS_MODULE,NULL) == 0)
+        if (0 == dvb_usb_device_init(intf, &dtt200u_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_fc_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_zl0353_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_miglia_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
                 return 0;
 
         return -ENODEV;
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-common.h b/drivers/media/dvb/dvb-usb/dvb-usb-common.h
index 35ab68f6dcf6..6b7b2a89242e 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-common.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-common.h
@@ -40,7 +40,8 @@ extern int dvb_usb_adapter_stream_exit(struct dvb_usb_adapter *adap);
 extern int dvb_usb_i2c_init(struct dvb_usb_device *);
 extern int dvb_usb_i2c_exit(struct dvb_usb_device *);
 
-extern int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap);
+extern int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap,
+                                    short *adapter_nums);
 extern int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap);
 extern int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap);
 extern int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap);
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c b/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c
index 4561a672da92..ce8cd0c5d831 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c
@@ -77,12 +77,13 @@ static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
         return dvb_usb_ctrl_feed(dvbdmxfeed,0);
 }
 
-int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap)
+int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap, short *adapter_nums)
 {
-        int ret;
+        int ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name,
+                                       adap->dev->owner, &adap->dev->udev->dev,
+                                       adapter_nums);
 
-        if ((ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name,
-                        adap->dev->owner, &adap->dev->udev->dev)) < 0) {
+        if (ret < 0) {
                 deb_info("dvb_register_adapter failed: error %d", ret);
                 goto err;
         }
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
index aa4844ef875e..34245d1b7dd9 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
@@ -40,14 +40,15 @@
 #define USB_VID_MSI                             0x0db0
 #define USB_VID_OPERA1                          0x695c
 #define USB_VID_PINNACLE                        0x2304
+#define USB_VID_TECHNOTREND                     0x0b48
 #define USB_VID_TERRATEC                        0x0ccd
 #define USB_VID_VISIONPLUS                      0x13d3
 #define USB_VID_TWINHAN                         0x1822
 #define USB_VID_ULTIMA_ELECTRONIC               0x05d8
 #define USB_VID_UNIWILL                         0x1584
 #define USB_VID_WIDEVIEW                        0x14aa
-/* dom : pour gigabyte u7000 */
 #define USB_VID_GIGABYTE                        0x1044
+#define USB_VID_YUAN                            0x1164
 
 
 /* Product IDs */
@@ -134,10 +135,17 @@
 #define USB_PID_AVERMEDIA_EXPRESS                       0xb568
 #define USB_PID_AVERMEDIA_VOLAR                         0xa807
 #define USB_PID_AVERMEDIA_VOLAR_2                       0xb808
+#define USB_PID_TECHNOTREND_CONNECT_S2400               0x3006
 #define USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY        0x005a
+#define USB_PID_TERRATEC_CINERGY_HT_USB_XE              0x0058
+#define USB_PID_TERRATEC_CINERGY_HT_EXPRESS             0x0060
+#define USB_PID_TERRATEC_CINERGY_T_XXS                  0x0078
+#define USB_PID_PINNACLE_EXPRESSCARD_320CX              0x022e
 #define USB_PID_PINNACLE_PCTV2000E                      0x022c
 #define USB_PID_PINNACLE_PCTV_DVB_T_FLASH               0x0228
 #define USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T      0x0229
+#define USB_PID_PINNACLE_PCTV72E                        0x0236
+#define USB_PID_PINNACLE_PCTV73E                        0x0237
 #define USB_PID_PCTV_200E                               0x020e
 #define USB_PID_PCTV_400E                               0x020f
 #define USB_PID_PCTV_450E                               0x0222
@@ -172,6 +180,7 @@
 #define USB_PID_WINFAST_DTV_DONGLE_COLD                 0x6025
 #define USB_PID_WINFAST_DTV_DONGLE_WARM                 0x6026
 #define USB_PID_WINFAST_DTV_DONGLE_STK7700P             0x6f00
+#define USB_PID_WINFAST_DTV_DONGLE_STK7700P_2           0x6f01
 #define USB_PID_GENPIX_8PSK_REV_1_COLD                  0x0200
 #define USB_PID_GENPIX_8PSK_REV_1_WARM                  0x0201
 #define USB_PID_GENPIX_8PSK_REV_2                       0x0202
@@ -183,9 +192,9 @@
 #define USB_PID_OPERA1_WARM                             0x3829
 #define USB_PID_LIFEVIEW_TV_WALKER_TWIN_COLD            0x0514
 #define USB_PID_LIFEVIEW_TV_WALKER_TWIN_WARM            0x0513
-/* dom pour gigabyte u7000 */
 #define USB_PID_GIGABYTE_U7000                          0x7001
 #define USB_PID_ASUS_U3000                              0x171f
 #define USB_PID_ASUS_U3100                              0x173f
+#define USB_PID_YUAN_EC372S                             0x1edc
 
 #endif
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-init.c b/drivers/media/dvb/dvb-usb/dvb-usb-init.c
index cdd717c3fe45..e331db8c77b2 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-init.c
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-init.c
@@ -26,7 +26,7 @@ static int dvb_usb_force_pid_filter_usage;
 module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage, int, 0444);
 MODULE_PARM_DESC(force_pid_filter_usage, "force all dvb-usb-devices to use a PID filter, if any (default: 0).");
 
-static int dvb_usb_adapter_init(struct dvb_usb_device *d)
+static int dvb_usb_adapter_init(struct dvb_usb_device *d, short *adapter_nrs)
 {
         struct dvb_usb_adapter *adap;
         int ret,n;
@@ -72,7 +72,7 @@ static int dvb_usb_adapter_init(struct dvb_usb_device *d)
                 }
 
                 if ((ret = dvb_usb_adapter_stream_init(adap)) ||
-                        (ret = dvb_usb_adapter_dvb_init(adap)) ||
+                        (ret = dvb_usb_adapter_dvb_init(adap, adapter_nrs)) ||
                         (ret = dvb_usb_adapter_frontend_init(adap))) {
                         return ret;
                 }
@@ -122,7 +122,7 @@ static int dvb_usb_exit(struct dvb_usb_device *d)
         return 0;
 }
 
-static int dvb_usb_init(struct dvb_usb_device *d)
+static int dvb_usb_init(struct dvb_usb_device *d, short *adapter_nums)
 {
         int ret = 0;
 
@@ -143,7 +143,7 @@ static int dvb_usb_init(struct dvb_usb_device *d)
         dvb_usb_device_power_ctrl(d, 1);
 
         if ((ret = dvb_usb_i2c_init(d)) ||
-                (ret = dvb_usb_adapter_init(d))) {
+                (ret = dvb_usb_adapter_init(d, adapter_nums))) {
                 dvb_usb_exit(d);
                 return ret;
         }
@@ -213,8 +213,10 @@ int dvb_usb_device_power_ctrl(struct dvb_usb_device *d, int onoff)
 /*
  * USB
  */
-int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_device_properties
-                *props, struct module *owner,struct dvb_usb_device **du)
+int dvb_usb_device_init(struct usb_interface *intf,
+                        struct dvb_usb_device_properties *props,
+                        struct module *owner, struct dvb_usb_device **du,
+                        short *adapter_nums)
 {
         struct usb_device *udev = interface_to_usbdev(intf);
         struct dvb_usb_device *d = NULL;
@@ -254,7 +256,7 @@ int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_device_proper
         if (du != NULL)
                 *du = d;
 
-        ret = dvb_usb_init(d);
+        ret = dvb_usb_init(d, adapter_nums);
 
         if (ret == 0)
                 info("%s successfully initialized and connected.",desc->name);
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h
index d1b3c7b81fff..b1de0f7e26e8 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb.h
@@ -372,7 +372,10 @@ struct dvb_usb_device {
         void *priv;
 };
 
-extern int dvb_usb_device_init(struct usb_interface *, struct dvb_usb_device_properties *, struct module *, struct dvb_usb_device **);
+extern int dvb_usb_device_init(struct usb_interface *,
+                               struct dvb_usb_device_properties *,
+                               struct module *, struct dvb_usb_device **,
+                               short *adapter_nums);
 extern void dvb_usb_device_exit(struct usb_interface *);
 
 /* the generic read/write method for device control */
diff --git a/drivers/media/dvb/dvb-usb/gl861.c b/drivers/media/dvb/dvb-usb/gl861.c
index 6b99d9f4d5b3..0a8ac64a4e33 100644
--- a/drivers/media/dvb/dvb-usb/gl861.c
+++ b/drivers/media/dvb/dvb-usb/gl861.c
@@ -16,6 +16,8 @@ static int dvb_usb_gl861_debug;
 module_param_named(debug,dvb_usb_gl861_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static int gl861_i2c_msg(struct dvb_usb_device *d, u8 addr,
                          u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
 {
@@ -140,7 +142,9 @@ static int gl861_probe(struct usb_interface *intf,
         if (intf->num_altsetting < 2)
                 return -ENODEV;
 
-        if ((ret = dvb_usb_device_init(intf, &gl861_properties, THIS_MODULE, &d)) == 0) {
+        ret = dvb_usb_device_init(intf, &gl861_properties, THIS_MODULE, &d,
+                                  adapter_nr);
+        if (ret == 0) {
                 alt = usb_altnum_to_altsetting(intf, 0);
 
                 if (alt == NULL) {
diff --git a/drivers/media/dvb/dvb-usb/gp8psk-fe.c b/drivers/media/dvb/dvb-usb/gp8psk-fe.c
index e37142d9271a..262a858c3068 100644
--- a/drivers/media/dvb/dvb-usb/gp8psk-fe.c
+++ b/drivers/media/dvb/dvb-usb/gp8psk-fe.c
@@ -152,7 +152,7 @@ static int gp8psk_fe_send_diseqc_msg (struct dvb_frontend* fe,
 {
         struct gp8psk_fe_state *st = fe->demodulator_priv;
 
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
 
         if (gp8psk_usb_out_op(st->d,SEND_DISEQC_COMMAND, m->msg[0], 0,
                         m->msg, m->msg_len)) {
@@ -167,7 +167,7 @@ static int gp8psk_fe_send_diseqc_burst (struct dvb_frontend* fe,
         struct gp8psk_fe_state *st = fe->demodulator_priv;
         u8 cmd;
 
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
 
         /* These commands are certainly wrong */
         cmd = (burst == SEC_MINI_A) ? 0x00 : 0x01;
diff --git a/drivers/media/dvb/dvb-usb/gp8psk.c b/drivers/media/dvb/dvb-usb/gp8psk.c
index 83e8535014c6..9a942afaf0af 100644
--- a/drivers/media/dvb/dvb-usb/gp8psk.c
+++ b/drivers/media/dvb/dvb-usb/gp8psk.c
@@ -22,6 +22,8 @@ int dvb_usb_gp8psk_debug;
 module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
 {
         int ret = 0,try = 0;
@@ -190,7 +192,8 @@ static int gp8psk_usb_probe(struct usb_interface *intf,
 {
         int ret;
         struct usb_device *udev = interface_to_usbdev(intf);
-        ret =  dvb_usb_device_init(intf,&gp8psk_properties,THIS_MODULE,NULL);
+        ret = dvb_usb_device_init(intf, &gp8psk_properties,
+                                  THIS_MODULE, NULL, adapter_nr);
         if (ret == 0) {
                 info("found Genpix USB device pID = %x (hex)",
                         le16_to_cpu(udev->descriptor.idProduct));
diff --git a/drivers/media/dvb/dvb-usb/m920x.c b/drivers/media/dvb/dvb-usb/m920x.c
index a956bc503a4c..a12e6f784fda 100644
--- a/drivers/media/dvb/dvb-usb/m920x.c
+++ b/drivers/media/dvb/dvb-usb/m920x.c
@@ -22,6 +22,8 @@ static int dvb_usb_m920x_debug;
 module_param_named(debug,dvb_usb_m920x_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static int m920x_set_filter(struct dvb_usb_device *d, int type, int idx, int pid);
 
 static inline int m920x_read(struct usb_device *udev, u8 request, u16 value,
@@ -477,7 +479,7 @@ static struct qt1010_config m920x_qt1010_config = {
 /* Callbacks for DVB USB */
 static int m920x_mt352_frontend_attach(struct dvb_usb_adapter *adap)
 {
-        deb("%s\n",__FUNCTION__);
+        deb("%s\n",__func__);
 
         if ((adap->fe = dvb_attach(mt352_attach,
                                    &m920x_mt352_config,
@@ -489,7 +491,7 @@ static int m920x_mt352_frontend_attach(struct dvb_usb_adapter *adap)
 
 static int m920x_tda10046_08_frontend_attach(struct dvb_usb_adapter *adap)
 {
-        deb("%s\n",__FUNCTION__);
+        deb("%s\n",__func__);
 
         if ((adap->fe = dvb_attach(tda10046_attach,
                                    &m920x_tda10046_08_config,
@@ -501,7 +503,7 @@ static int m920x_tda10046_08_frontend_attach(struct dvb_usb_adapter *adap)
 
 static int m920x_tda10046_0b_frontend_attach(struct dvb_usb_adapter *adap)
 {
-        deb("%s\n",__FUNCTION__);
+        deb("%s\n",__func__);
 
         if ((adap->fe = dvb_attach(tda10046_attach,
                                    &m920x_tda10046_0b_config,
@@ -513,7 +515,7 @@ static int m920x_tda10046_0b_frontend_attach(struct dvb_usb_adapter *adap)
 
 static int m920x_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
 {
-        deb("%s\n",__FUNCTION__);
+        deb("%s\n",__func__);
 
         if (dvb_attach(qt1010_attach, adap->fe, &adap->dev->i2c_adap, &m920x_qt1010_config) == NULL)
                 return -ENODEV;
@@ -523,7 +525,7 @@ static int m920x_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
 
 static int m920x_tda8275_60_tuner_attach(struct dvb_usb_adapter *adap)
 {
-        deb("%s\n",__FUNCTION__);
+        deb("%s\n",__func__);
 
         if (dvb_attach(tda827x_attach, adap->fe, 0x60, &adap->dev->i2c_adap, NULL) == NULL)
                 return -ENODEV;
@@ -533,7 +535,7 @@ static int m920x_tda8275_60_tuner_attach(struct dvb_usb_adapter *adap)
 
 static int m920x_tda8275_61_tuner_attach(struct dvb_usb_adapter *adap)
 {
-        deb("%s\n",__FUNCTION__);
+        deb("%s\n",__func__);
 
         if (dvb_attach(tda827x_attach, adap->fe, 0x61, &adap->dev->i2c_adap, NULL) == NULL)
                 return -ENODEV;
@@ -618,27 +620,31 @@ static int m920x_probe(struct usb_interface *intf,
                  * multi-tuner device
                  */
 
-                if ((ret = dvb_usb_device_init(intf, &megasky_properties,
-                                               THIS_MODULE, &d)) == 0) {
+                ret = dvb_usb_device_init(intf, &megasky_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
                         rc_init_seq = megasky_rc_init;
                         goto found;
                 }
 
-                if ((ret = dvb_usb_device_init(intf, &digivox_mini_ii_properties,
-                                               THIS_MODULE, &d)) == 0) {
+                ret = dvb_usb_device_init(intf, &digivox_mini_ii_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
                         /* No remote control, so no rc_init_seq */
                         goto found;
                 }
 
                 /* This configures both tuners on the TV Walker Twin */
-                if ((ret = dvb_usb_device_init(intf, &tvwalkertwin_properties,
-                                               THIS_MODULE, &d)) == 0) {
+                ret = dvb_usb_device_init(intf, &tvwalkertwin_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
                         rc_init_seq = tvwalkertwin_rc_init;
                         goto found;
                 }
 
-                if ((ret = dvb_usb_device_init(intf, &dposh_properties,
-                                               THIS_MODULE, &d)) == 0) {
+                ret = dvb_usb_device_init(intf, &dposh_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
                         /* Remote controller not supported yet. */
                         goto found;
                 }
diff --git a/drivers/media/dvb/dvb-usb/nova-t-usb2.c b/drivers/media/dvb/dvb-usb/nova-t-usb2.c
index badc468170ea..07fb843c7c2b 100644
--- a/drivers/media/dvb/dvb-usb/nova-t-usb2.c
+++ b/drivers/media/dvb/dvb-usb/nova-t-usb2.c
@@ -15,6 +15,8 @@ static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=rc,2=eeprom (|-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define deb_rc(args...) dprintk(debug,0x01,args)
 #define deb_ee(args...) dprintk(debug,0x02,args)
 
@@ -142,7 +144,8 @@ static struct dvb_usb_device_properties nova_t_properties;
 static int nova_t_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf,&nova_t_properties,THIS_MODULE,NULL);
+        return dvb_usb_device_init(intf, &nova_t_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 /* do not change the order of the ID table */
diff --git a/drivers/media/dvb/dvb-usb/opera1.c b/drivers/media/dvb/dvb-usb/opera1.c
index 302cc67407c3..7e32d11f32b0 100644
--- a/drivers/media/dvb/dvb-usb/opera1.c
+++ b/drivers/media/dvb/dvb-usb/opera1.c
@@ -46,6 +46,9 @@ MODULE_PARM_DESC(debug,
                  "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
                  DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+
 static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
                             u8 * data, u16 len, int flags)
 {
@@ -243,7 +246,7 @@ static struct stv0299_config opera1_stv0299_config = {
         .mclk = 88000000UL,
         .invert = 1,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_0,
+        .lock_output = STV0299_LOCKOUTPUT_0,
         .volt13_op0_op1 = STV0299_VOLT13_OP0,
         .inittab = opera1_inittab,
         .set_symbol_rate = opera1_stv0299_set_symbol_rate,
@@ -548,7 +551,8 @@ static int opera1_probe(struct usb_interface *intf,
                 return -EINVAL;
         }
 
-        if (dvb_usb_device_init(intf, &opera1_properties, THIS_MODULE, NULL) != 0)
+        if (0 != dvb_usb_device_init(intf, &opera1_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
                 return -EINVAL;
         return 0;
 }
diff --git a/drivers/media/dvb/dvb-usb/ttusb2.c b/drivers/media/dvb/dvb-usb/ttusb2.c
index 3b9da9c25c6e..20ca9d9ee99b 100644
--- a/drivers/media/dvb/dvb-usb/ttusb2.c
+++ b/drivers/media/dvb/dvb-usb/ttusb2.c
@@ -37,6 +37,8 @@ static int dvb_usb_ttusb2_debug;
 module_param_named(debug,dvb_usb_ttusb2_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 struct ttusb2_state {
         u8 id;
 };
@@ -145,6 +147,7 @@ static struct tda10086_config tda10086_config = {
         .demod_address = 0x0e,
         .invert = 0,
         .diseqc_tone = 1,
+        .xtal_freq = TDA10086_XTAL_16M,
 };
 
 static int ttusb2_frontend_attach(struct dvb_usb_adapter *adap)
@@ -176,17 +179,25 @@ static int ttusb2_tuner_attach(struct dvb_usb_adapter *adap)
 
 /* DVB USB Driver stuff */
 static struct dvb_usb_device_properties ttusb2_properties;
+static struct dvb_usb_device_properties ttusb2_properties_s2400;
 
 static int ttusb2_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf,&ttusb2_properties,THIS_MODULE,NULL);
+        if (0 == dvb_usb_device_init(intf, &ttusb2_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &ttusb2_properties_s2400,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return 0;
+        return -ENODEV;
 }
 
 static struct usb_device_id ttusb2_table [] = {
-                { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_400E) },
-                { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_450E) },
-                {}              /* Terminating entry */
+        { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_400E) },
+        { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_450E) },
+        { USB_DEVICE(USB_VID_TECHNOTREND,
+                USB_PID_TECHNOTREND_CONNECT_S2400) },
+        {}              /* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, ttusb2_table);
 
@@ -242,6 +253,54 @@ static struct dvb_usb_device_properties ttusb2_properties = {
         }
 };
 
+static struct dvb_usb_device_properties ttusb2_properties_s2400 = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-tt-s2400-01.fw",
+
+        .size_of_priv = sizeof(struct ttusb2_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = NULL,
+
+                        .frontend_attach  = ttusb2_frontend_attach,
+                        .tuner_attach     = ttusb2_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_ISOC,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .isoc = {
+                                                .framesperurb = 4,
+                                                .framesize = 940,
+                                                .interval = 1,
+                                        }
+                                }
+                        }
+                }
+        },
+
+        .power_ctrl       = ttusb2_power_ctrl,
+        .identify_state   = ttusb2_identify_state,
+
+        .i2c_algo         = &ttusb2_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Technotrend TT-connect S-2400",
+                        { &ttusb2_table[2], NULL },
+                        { NULL },
+                },
+        }
+};
+
 static struct usb_driver ttusb2_driver = {
         .name           = "dvb_usb_ttusb2",
         .probe          = ttusb2_probe,
diff --git a/drivers/media/dvb/dvb-usb/umt-010.c b/drivers/media/dvb/dvb-usb/umt-010.c
index 0dcab3d4e236..9e7653bb3b66 100644
--- a/drivers/media/dvb/dvb-usb/umt-010.c
+++ b/drivers/media/dvb/dvb-usb/umt-010.c
@@ -13,6 +13,8 @@
 
 #include "mt352.h"
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static int umt_mt352_demod_init(struct dvb_frontend *fe)
 {
         static u8 mt352_clock_config[] = { 0x89, 0xb8, 0x2d };
@@ -75,7 +77,8 @@ static struct dvb_usb_device_properties umt_properties;
 static int umt_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        if (dvb_usb_device_init(intf,&umt_properties,THIS_MODULE,NULL) == 0)
+        if (0 == dvb_usb_device_init(intf, &umt_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
                 return 0;
         return -EINVAL;
 }
diff --git a/drivers/media/dvb/dvb-usb/vp702x-fe.c b/drivers/media/dvb/dvb-usb/vp702x-fe.c
index c3fdc7cd094e..ccc7e4452664 100644
--- a/drivers/media/dvb/dvb-usb/vp702x-fe.c
+++ b/drivers/media/dvb/dvb-usb/vp702x-fe.c
@@ -67,7 +67,7 @@ static int vp702x_fe_read_status(struct dvb_frontend* fe, fe_status_t *status)
 {
         struct vp702x_fe_state *st = fe->demodulator_priv;
         vp702x_fe_refresh_state(st);
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
 
         if (st->lock == 0)
                 *status = FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_SIGNAL | FE_HAS_CARRIER;
@@ -121,7 +121,7 @@ static int vp702x_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
 
 static int vp702x_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
 {
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
         tune->min_delay_ms = 2000;
         return 0;
 }
@@ -183,21 +183,21 @@ static int vp702x_fe_set_frontend(struct dvb_frontend* fe,
 static int vp702x_fe_init(struct dvb_frontend *fe)
 {
         struct vp702x_fe_state *st = fe->demodulator_priv;
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
         vp702x_usb_in_op(st->d, RESET_TUNER, 0, 0, NULL, 0);
         return 0;
 }
 
 static int vp702x_fe_sleep(struct dvb_frontend *fe)
 {
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
         return 0;
 }
 
 static int vp702x_fe_get_frontend(struct dvb_frontend* fe,
                                   struct dvb_frontend_parameters *fep)
 {
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
         return 0;
 }
 
@@ -208,7 +208,7 @@ static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe,
         u8 cmd[8],ibuf[10];
         memset(cmd,0,8);
 
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
 
         if (m->msg_len > 4)
                 return -EINVAL;
@@ -230,7 +230,7 @@ static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe,
 
 static int vp702x_fe_send_diseqc_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
 {
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
         return 0;
 }
 
@@ -238,7 +238,7 @@ static int vp702x_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
         struct vp702x_fe_state *st = fe->demodulator_priv;
         u8 ibuf[10];
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
 
         st->tone_mode = tone;
 
@@ -263,7 +263,7 @@ static int vp702x_fe_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t
 {
         struct vp702x_fe_state *st = fe->demodulator_priv;
         u8 ibuf[10];
-        deb_fe("%s\n",__FUNCTION__);
+        deb_fe("%s\n",__func__);
 
         st->voltage = voltage;
 
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c
index e553c139ac44..986fff9a5ba8 100644
--- a/drivers/media/dvb/dvb-usb/vp702x.c
+++ b/drivers/media/dvb/dvb-usb/vp702x.c
@@ -21,6 +21,8 @@ int dvb_usb_vp702x_debug;
 module_param_named(debug,dvb_usb_vp702x_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 struct vp702x_state {
         int pid_filter_count;
         int pid_filter_can_bypass;
@@ -238,7 +240,8 @@ static struct dvb_usb_device_properties vp702x_properties;
 static int vp702x_usb_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf,&vp702x_properties,THIS_MODULE,NULL);
+        return dvb_usb_device_init(intf, &vp702x_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 static struct usb_device_id vp702x_usb_table [] = {
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c
index c172babf59bb..acb345504e0d 100644
--- a/drivers/media/dvb/dvb-usb/vp7045.c
+++ b/drivers/media/dvb/dvb-usb/vp7045.c
@@ -18,6 +18,9 @@
 static int dvb_usb_vp7045_debug;
 module_param_named(debug,dvb_usb_vp7045_debug, int, 0644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define deb_info(args...) dprintk(dvb_usb_vp7045_debug,0x01,args)
 #define deb_xfer(args...) dprintk(dvb_usb_vp7045_debug,0x02,args)
 #define deb_rc(args...)   dprintk(dvb_usb_vp7045_debug,0x04,args)
@@ -219,7 +222,8 @@ static struct dvb_usb_device_properties vp7045_properties;
 static int vp7045_usb_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        return dvb_usb_device_init(intf,&vp7045_properties,THIS_MODULE,NULL);
+        return dvb_usb_device_init(intf, &vp7045_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 static struct usb_device_id vp7045_usb_table [] = {
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index 9ad86ce4a4e5..68fab616f55d 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -188,6 +188,14 @@ config DVB_DIB7000P
           A DVB-T tuner module. Designed for mobile usage. Say Y when you want
           to support this frontend.
 
+config DVB_TDA10048
+        tristate "Philips TDA10048HN based"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+        select FW_LOADER
+        help
+          A DVB-T tuner module. Say Y when you want to support this frontend.
+
 comment "DVB-C (cable) frontends"
         depends on DVB_CORE
 
@@ -291,6 +299,14 @@ config DVB_S5H1409
           An ATSC 8VSB and QAM64/256 tuner module. Say Y when you want
           to support this frontend.
 
+config DVB_AU8522
+        tristate "Auvitek AU8522 based"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+        help
+          An ATSC 8VSB and QAM64/256 tuner module. Say Y when you want
+          to support this frontend.
+
 comment "Tuners/PLL support"
         depends on DVB_CORE
 
@@ -369,6 +385,11 @@ config DVB_TUNER_XC5000
           This device is only used inside a SiP called togther with a
           demodulator for now.
 
+config DVB_TUNER_ITD1000
+        tristate "Integrant ITD1000 Zero IF tuner for DVB-S/DSS"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+
 comment "Miscellaneous devices"
         depends on DVB_CORE
 
@@ -379,6 +400,13 @@ config DVB_LNBP21
         help
           An SEC control chip.
 
+config DVB_ISL6405
+        tristate "ISL6405 SEC controller"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+        help
+          An SEC control chip.
+
 config DVB_ISL6421
         tristate "ISL6421 SEC controller"
         depends on DVB_CORE && I2C
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile
index 16bd107ebd32..2f873fc0f649 100644
--- a/drivers/media/dvb/frontends/Makefile
+++ b/drivers/media/dvb/frontends/Makefile
@@ -38,6 +38,7 @@ obj-$(CONFIG_DVB_S5H1420) += s5h1420.o
 obj-$(CONFIG_DVB_LGDT330X) += lgdt330x.o
 obj-$(CONFIG_DVB_CX24123) += cx24123.o
 obj-$(CONFIG_DVB_LNBP21) += lnbp21.o
+obj-$(CONFIG_DVB_ISL6405) += isl6405.o
 obj-$(CONFIG_DVB_ISL6421) += isl6421.o
 obj-$(CONFIG_DVB_TDA10086) += tda10086.o
 obj-$(CONFIG_DVB_TDA826X) += tda826x.o
@@ -51,3 +52,6 @@ obj-$(CONFIG_DVB_TUA6100) += tua6100.o
 obj-$(CONFIG_DVB_TUNER_MT2131) += mt2131.o
 obj-$(CONFIG_DVB_S5H1409) += s5h1409.o
 obj-$(CONFIG_DVB_TUNER_XC5000) += xc5000.o
+obj-$(CONFIG_DVB_TUNER_ITD1000) += itd1000.o
+obj-$(CONFIG_DVB_AU8522) += au8522.o
+obj-$(CONFIG_DVB_TDA10048) += tda10048.o
diff --git a/drivers/media/dvb/frontends/au8522.c b/drivers/media/dvb/frontends/au8522.c
new file mode 100644
index 000000000000..084a280c2d7f
--- /dev/null
+++ b/drivers/media/dvb/frontends/au8522.c
@@ -0,0 +1,692 @@
+/*
+    Auvitek AU8522 QAM/8VSB demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.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/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include "dvb_frontend.h"
+#include "dvb-pll.h"
+#include "au8522.h"
+
+struct au8522_state {
+
+        struct i2c_adapter *i2c;
+
+        /* configuration settings */
+        const struct au8522_config *config;
+
+        struct dvb_frontend frontend;
+
+        u32 current_frequency;
+        fe_modulation_t current_modulation;
+
+};
+
+static int debug;
+
+#define dprintk(arg...) do {            \
+        if (debug)                      \
+                 printk(arg);           \
+        } while (0)
+
+/* 16 bit registers, 8 bit values */
+static int au8522_writereg(struct au8522_state *state, u16 reg, u8 data)
+{
+        int ret;
+        u8 buf [] = { reg >> 8, reg & 0xff, data };
+
+        struct i2c_msg msg = { .addr = state->config->demod_address,
+                               .flags = 0, .buf = buf, .len = 3 };
+
+        ret = i2c_transfer(state->i2c, &msg, 1);
+
+        if (ret != 1)
+                printk("%s: writereg error (reg == 0x%02x, val == 0x%04x, "
+                       "ret == %i)\n", __func__, reg, data, ret);
+
+        return (ret != 1) ? -1 : 0;
+}
+
+static u8 au8522_readreg(struct au8522_state *state, u16 reg)
+{
+        int ret;
+        u8 b0 [] = { reg >> 8, reg & 0xff };
+        u8 b1 [] = { 0 };
+
+        struct i2c_msg msg [] = {
+                { .addr = state->config->demod_address, .flags = 0,
+                  .buf = b0, .len = 2 },
+                { .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: readreg error (ret == %i)\n",
+                       __func__, ret);
+        return b1[0];
+}
+
+static int au8522_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+
+        dprintk("%s(%d)\n", __func__, enable);
+
+        if (enable)
+                return au8522_writereg(state, 0x106, 1);
+        else
+                return au8522_writereg(state, 0x106, 0);
+}
+
+struct mse2snr_tab {
+        u16 val;
+        u16 data;
+};
+
+/* VSB SNR lookup table */
+static struct mse2snr_tab vsb_mse2snr_tab[] = {
+        {   0, 270 },
+        {   2, 250 },
+        {   3, 240 },
+        {   5, 230 },
+        {   7, 220 },
+        {   9, 210 },
+        {  12, 200 },
+        {  13, 195 },
+        {  15, 190 },
+        {  17, 185 },
+        {  19, 180 },
+        {  21, 175 },
+        {  24, 170 },
+        {  27, 165 },
+        {  31, 160 },
+        {  32, 158 },
+        {  33, 156 },
+        {  36, 152 },
+        {  37, 150 },
+        {  39, 148 },
+        {  40, 146 },
+        {  41, 144 },
+        {  43, 142 },
+        {  44, 140 },
+        {  48, 135 },
+        {  50, 130 },
+        {  43, 142 },
+        {  53, 125 },
+        {  56, 120 },
+        { 256, 115 },
+};
+
+/* QAM64 SNR lookup table */
+static struct mse2snr_tab qam64_mse2snr_tab[] = {
+        {  15,   0 },
+        {  16, 290 },
+        {  17, 288 },
+        {  18, 286 },
+        {  19, 284 },
+        {  20, 282 },
+        {  21, 281 },
+        {  22, 279 },
+        {  23, 277 },
+        {  24, 275 },
+        {  25, 273 },
+        {  26, 271 },
+        {  27, 269 },
+        {  28, 268 },
+        {  29, 266 },
+        {  30, 264 },
+        {  31, 262 },
+        {  32, 260 },
+        {  33, 259 },
+        {  34, 258 },
+        {  35, 256 },
+        {  36, 255 },
+        {  37, 254 },
+        {  38, 252 },
+        {  39, 251 },
+        {  40, 250 },
+        {  41, 249 },
+        {  42, 248 },
+        {  43, 246 },
+        {  44, 245 },
+        {  45, 244 },
+        {  46, 242 },
+        {  47, 241 },
+        {  48, 240 },
+        {  50, 239 },
+        {  51, 238 },
+        {  53, 237 },
+        {  54, 236 },
+        {  56, 235 },
+        {  57, 234 },
+        {  59, 233 },
+        {  60, 232 },
+        {  62, 231 },
+        {  63, 230 },
+        {  65, 229 },
+        {  67, 228 },
+        {  68, 227 },
+        {  70, 226 },
+        {  71, 225 },
+        {  73, 224 },
+        {  74, 223 },
+        {  76, 222 },
+        {  78, 221 },
+        {  80, 220 },
+        {  82, 219 },
+        {  85, 218 },
+        {  88, 217 },
+        {  90, 216 },
+        {  92, 215 },
+        {  93, 214 },
+        {  94, 212 },
+        {  95, 211 },
+        {  97, 210 },
+        {  99, 209 },
+        { 101, 208 },
+        { 102, 207 },
+        { 104, 206 },
+        { 107, 205 },
+        { 111, 204 },
+        { 114, 203 },
+        { 118, 202 },
+        { 122, 201 },
+        { 125, 200 },
+        { 128, 199 },
+        { 130, 198 },
+        { 132, 197 },
+        { 256, 190 },
+};
+
+/* QAM256 SNR lookup table */
+static struct mse2snr_tab qam256_mse2snr_tab[] = {
+        {  16,   0 },
+        {  17, 400 },
+        {  18, 398 },
+        {  19, 396 },
+        {  20, 394 },
+        {  21, 392 },
+        {  22, 390 },
+        {  23, 388 },
+        {  24, 386 },
+        {  25, 384 },
+        {  26, 382 },
+        {  27, 380 },
+        {  28, 379 },
+        {  29, 378 },
+        {  30, 377 },
+        {  31, 376 },
+        {  32, 375 },
+        {  33, 374 },
+        {  34, 373 },
+        {  35, 372 },
+        {  36, 371 },
+        {  37, 370 },
+        {  38, 362 },
+        {  39, 354 },
+        {  40, 346 },
+        {  41, 338 },
+        {  42, 330 },
+        {  43, 328 },
+        {  44, 326 },
+        {  45, 324 },
+        {  46, 322 },
+        {  47, 320 },
+        {  48, 319 },
+        {  49, 318 },
+        {  50, 317 },
+        {  51, 316 },
+        {  52, 315 },
+        {  53, 314 },
+        {  54, 313 },
+        {  55, 312 },
+        {  56, 311 },
+        {  57, 310 },
+        {  58, 308 },
+        {  59, 306 },
+        {  60, 304 },
+        {  61, 302 },
+        {  62, 300 },
+        {  63, 298 },
+        {  65, 295 },
+        {  68, 294 },
+        {  70, 293 },
+        {  73, 292 },
+        {  76, 291 },
+        {  78, 290 },
+        {  79, 289 },
+        {  81, 288 },
+        {  82, 287 },
+        {  83, 286 },
+        {  84, 285 },
+        {  85, 284 },
+        {  86, 283 },
+        {  88, 282 },
+        {  89, 281 },
+        { 256, 280 },
+};
+
+static int au8522_mse2snr_lookup(struct mse2snr_tab *tab, int sz, int mse,
+                                 u16 *snr)
+{
+        int i, ret = -EINVAL;
+        dprintk("%s()\n", __func__);
+
+        for (i = 0; i < sz; i++) {
+                if (mse < tab[i].val) {
+                        *snr = tab[i].data;
+                        ret = 0;
+                        break;
+                }
+        }
+        dprintk("%s() snr=%d\n", __func__, *snr);
+        return ret;
+}
+
+/* VSB Modulation table */
+static struct {
+        u16 reg;
+        u16 data;
+} VSB_mod_tab[] = {
+        { 0x8090, 0x84 },
+        { 0x4092, 0x11 },
+        { 0x2005, 0x00 },
+        { 0x8091, 0x80 },
+        { 0x80a3, 0x0c },
+        { 0x80a4, 0xe8 },
+        { 0x8081, 0xc4 },
+        { 0x80a5, 0x40 },
+        { 0x80a7, 0x40 },
+        { 0x80a6, 0x67 },
+        { 0x8262, 0x20 },
+        { 0x821c, 0x30 },
+        { 0x80d8, 0x1a },
+        { 0x8227, 0xa0 },
+        { 0x8121, 0xff },
+        { 0x80a8, 0xf0 },
+        { 0x80a9, 0x05 },
+        { 0x80aa, 0x77 },
+        { 0x80ab, 0xf0 },
+        { 0x80ac, 0x05 },
+        { 0x80ad, 0x77 },
+        { 0x80ae, 0x41 },
+        { 0x80af, 0x66 },
+        { 0x821b, 0xcc },
+        { 0x821d, 0x80 },
+        { 0x80b5, 0xfb },
+        { 0x80b6, 0x8e },
+        { 0x80b7, 0x39 },
+        { 0x80a4, 0xe8 },
+        { 0x8231, 0x13 },
+};
+
+/* QAM Modulation table */
+static struct {
+        u16 reg;
+        u16 data;
+} QAM_mod_tab[] = {
+        { 0x80a3, 0x09 },
+        { 0x80a4, 0x00 },
+        { 0x8081, 0xc4 },
+        { 0x80a5, 0x40 },
+        { 0x80b5, 0xfb },
+        { 0x80b6, 0x8e },
+        { 0x80b7, 0x39 },
+        { 0x80aa, 0x77 },
+        { 0x80ad, 0x77 },
+        { 0x80a6, 0x67 },
+        { 0x8262, 0x20 },
+        { 0x821c, 0x30 },
+        { 0x80b8, 0x3e },
+        { 0x80b9, 0xf0 },
+        { 0x80ba, 0x01 },
+        { 0x80bb, 0x18 },
+        { 0x80bc, 0x50 },
+        { 0x80bd, 0x00 },
+        { 0x80be, 0xea },
+        { 0x80bf, 0xef },
+        { 0x80c0, 0xfc },
+        { 0x80c1, 0xbd },
+        { 0x80c2, 0x1f },
+        { 0x80c3, 0xfc },
+        { 0x80c4, 0xdd },
+        { 0x80c5, 0xaf },
+        { 0x80c6, 0x00 },
+        { 0x80c7, 0x38 },
+        { 0x80c8, 0x30 },
+        { 0x80c9, 0x05 },
+        { 0x80ca, 0x4a },
+        { 0x80cb, 0xd0 },
+        { 0x80cc, 0x01 },
+        { 0x80cd, 0xd9 },
+        { 0x80ce, 0x6f },
+        { 0x80cf, 0xf9 },
+        { 0x80d0, 0x70 },
+        { 0x80d1, 0xdf },
+        { 0x80d2, 0xf7 },
+        { 0x80d3, 0xc2 },
+        { 0x80d4, 0xdf },
+        { 0x80d5, 0x02 },
+        { 0x80d6, 0x9a },
+        { 0x80d7, 0xd0 },
+        { 0x8250, 0x0d },
+        { 0x8251, 0xcd },
+        { 0x8252, 0xe0 },
+        { 0x8253, 0x05 },
+        { 0x8254, 0xa7 },
+        { 0x8255, 0xff },
+        { 0x8256, 0xed },
+        { 0x8257, 0x5b },
+        { 0x8258, 0xae },
+        { 0x8259, 0xe6 },
+        { 0x825a, 0x3d },
+        { 0x825b, 0x0f },
+        { 0x825c, 0x0d },
+        { 0x825d, 0xea },
+        { 0x825e, 0xf2 },
+        { 0x825f, 0x51 },
+        { 0x8260, 0xf5 },
+        { 0x8261, 0x06 },
+        { 0x821a, 0x00 },
+        { 0x8546, 0x40 },
+        { 0x8210, 0x26 },
+        { 0x8211, 0xf6 },
+        { 0x8212, 0x84 },
+        { 0x8213, 0x02 },
+        { 0x8502, 0x01 },
+        { 0x8121, 0x04 },
+        { 0x8122, 0x04 },
+        { 0x852e, 0x10 },
+        { 0x80a4, 0xca },
+        { 0x80a7, 0x40 },
+        { 0x8526, 0x01 },
+};
+
+static int au8522_enable_modulation(struct dvb_frontend *fe,
+                                    fe_modulation_t m)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+        int i;
+
+        dprintk("%s(0x%08x)\n", __func__, m);
+
+        switch (m) {
+        case VSB_8:
+                dprintk("%s() VSB_8\n", __func__);
+                for (i = 0; i < ARRAY_SIZE(VSB_mod_tab); i++)
+                        au8522_writereg(state,
+                                VSB_mod_tab[i].reg,
+                                VSB_mod_tab[i].data);
+                break;
+        case QAM_64:
+        case QAM_256:
+                dprintk("%s() QAM 64/256\n", __func__);
+                for (i = 0; i < ARRAY_SIZE(QAM_mod_tab); i++)
+                        au8522_writereg(state,
+                                QAM_mod_tab[i].reg,
+                                QAM_mod_tab[i].data);
+                break;
+        default:
+                dprintk("%s() Invalid modulation\n", __func__);
+                return -EINVAL;
+        }
+
+        state->current_modulation = m;
+
+        return 0;
+}
+
+/* Talk to the demod, set the FEC, GUARD, QAM settings etc */
+static int au8522_set_frontend(struct dvb_frontend *fe,
+                               struct dvb_frontend_parameters *p)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+
+        dprintk("%s(frequency=%d)\n", __func__, p->frequency);
+
+        state->current_frequency = p->frequency;
+
+        au8522_enable_modulation(fe, p->u.vsb.modulation);
+
+        /* Allow the demod to settle */
+        msleep(100);
+
+        if (fe->ops.tuner_ops.set_params) {
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 1);
+                fe->ops.tuner_ops.set_params(fe, p);
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 0);
+        }
+
+        return 0;
+}
+
+/* Reset the demod hardware and reset all of the configuration registers
+   to a default state. */
+static int au8522_init(struct dvb_frontend *fe)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+        dprintk("%s()\n", __func__);
+
+        au8522_writereg(state, 0xa4, 1 << 5);
+
+        au8522_i2c_gate_ctrl(fe, 1);
+
+        return 0;
+}
+
+static int au8522_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+        u8 reg;
+        u32 tuner_status = 0;
+
+        *status = 0;
+
+        if (state->current_modulation == VSB_8) {
+                dprintk("%s() Checking VSB_8\n", __func__);
+                reg = au8522_readreg(state, 0x4088);
+                if (reg & 0x01)
+                        *status |= FE_HAS_VITERBI;
+                if (reg & 0x02)
+                        *status |= FE_HAS_LOCK | FE_HAS_SYNC;
+        } else {
+                dprintk("%s() Checking QAM\n", __func__);
+                reg = au8522_readreg(state, 0x4541);
+                if (reg & 0x80)
+                        *status |= FE_HAS_VITERBI;
+                if (reg & 0x20)
+                        *status |= FE_HAS_LOCK | FE_HAS_SYNC;
+        }
+
+        switch (state->config->status_mode) {
+        case AU8522_DEMODLOCKING:
+                dprintk("%s() DEMODLOCKING\n", __func__);
+                if (*status & FE_HAS_VITERBI)
+                        *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
+                break;
+        case AU8522_TUNERLOCKING:
+                /* Get the tuner status */
+                dprintk("%s() TUNERLOCKING\n", __func__);
+                if (fe->ops.tuner_ops.get_status) {
+                        if (fe->ops.i2c_gate_ctrl)
+                                fe->ops.i2c_gate_ctrl(fe, 1);
+
+                        fe->ops.tuner_ops.get_status(fe, &tuner_status);
+
+                        if (fe->ops.i2c_gate_ctrl)
+                                fe->ops.i2c_gate_ctrl(fe, 0);
+                }
+                if (tuner_status)
+                        *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
+                break;
+        }
+
+        dprintk("%s() status 0x%08x\n", __func__, *status);
+
+        return 0;
+}
+
+static int au8522_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+        int ret = -EINVAL;
+
+        dprintk("%s()\n", __func__);
+
+        if (state->current_modulation == QAM_256)
+                ret = au8522_mse2snr_lookup(qam256_mse2snr_tab,
+                                            ARRAY_SIZE(qam256_mse2snr_tab),
+                                            au8522_readreg(state, 0x4522),
+                                            snr);
+        else if (state->current_modulation == QAM_64)
+                ret = au8522_mse2snr_lookup(qam64_mse2snr_tab,
+                                            ARRAY_SIZE(qam64_mse2snr_tab),
+                                            au8522_readreg(state, 0x4522),
+                                            snr);
+        else /* VSB_8 */
+                ret = au8522_mse2snr_lookup(vsb_mse2snr_tab,
+                                            ARRAY_SIZE(vsb_mse2snr_tab),
+                                            au8522_readreg(state, 0x4311),
+                                            snr);
+
+        return ret;
+}
+
+static int au8522_read_signal_strength(struct dvb_frontend *fe,
+                                       u16 *signal_strength)
+{
+        return au8522_read_snr(fe, signal_strength);
+}
+
+static int au8522_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+
+        if (state->current_modulation == VSB_8)
+                *ucblocks = au8522_readreg(state, 0x4087);
+        else
+                *ucblocks = au8522_readreg(state, 0x4543);
+
+        return 0;
+}
+
+static int au8522_read_ber(struct dvb_frontend *fe, u32 *ber)
+{
+        return au8522_read_ucblocks(fe, ber);
+}
+
+static int au8522_get_frontend(struct dvb_frontend *fe,
+                                struct dvb_frontend_parameters *p)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+
+        p->frequency = state->current_frequency;
+        p->u.vsb.modulation = state->current_modulation;
+
+        return 0;
+}
+
+static int au8522_get_tune_settings(struct dvb_frontend *fe,
+                                    struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 1000;
+        return 0;
+}
+
+static void au8522_release(struct dvb_frontend *fe)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops au8522_ops;
+
+struct dvb_frontend *au8522_attach(const struct au8522_config *config,
+                                   struct i2c_adapter *i2c)
+{
+        struct au8522_state *state = NULL;
+
+        /* allocate memory for the internal state */
+        state = kmalloc(sizeof(struct au8522_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        /* setup the state */
+        state->config = config;
+        state->i2c = i2c;
+        /* create dvb_frontend */
+        memcpy(&state->frontend.ops, &au8522_ops,
+               sizeof(struct dvb_frontend_ops));
+        state->frontend.demodulator_priv = state;
+
+        if (au8522_init(&state->frontend) != 0) {
+                printk(KERN_ERR "%s: Failed to initialize correctly\n",
+                        __func__);
+                goto error;
+        }
+
+        /* Note: Leaving the I2C gate open here. */
+        au8522_i2c_gate_ctrl(&state->frontend, 1);
+
+        return &state->frontend;
+
+error:
+        kfree(state);
+        return NULL;
+}
+EXPORT_SYMBOL(au8522_attach);
+
+static struct dvb_frontend_ops au8522_ops = {
+
+        .info = {
+                .name                   = "Auvitek AU8522 QAM/8VSB Frontend",
+                .type                   = FE_ATSC,
+                .frequency_min          = 54000000,
+                .frequency_max          = 858000000,
+                .frequency_stepsize     = 62500,
+                .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
+        },
+
+        .init                 = au8522_init,
+        .i2c_gate_ctrl        = au8522_i2c_gate_ctrl,
+        .set_frontend         = au8522_set_frontend,
+        .get_frontend         = au8522_get_frontend,
+        .get_tune_settings    = au8522_get_tune_settings,
+        .read_status          = au8522_read_status,
+        .read_ber             = au8522_read_ber,
+        .read_signal_strength = au8522_read_signal_strength,
+        .read_snr             = au8522_read_snr,
+        .read_ucblocks        = au8522_read_ucblocks,
+        .release              = au8522_release,
+};
+
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Enable verbose debug messages");
+
+MODULE_DESCRIPTION("Auvitek AU8522 QAM-B/ATSC Demodulator driver");
+MODULE_AUTHOR("Steven Toth");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/au8522.h b/drivers/media/dvb/frontends/au8522.h
new file mode 100644
index 000000000000..d7affa3cdb27
--- /dev/null
+++ b/drivers/media/dvb/frontends/au8522.h
@@ -0,0 +1,56 @@
+/*
+    Auvitek AU8522 QAM/8VSB demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.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 __AU8522_H__
+#define __AU8522_H__
+
+#include <linux/dvb/frontend.h>
+
+struct au8522_config {
+        /* the demodulator's i2c address */
+        u8 demod_address;
+
+        /* Return lock status based on tuner lock, or demod lock */
+#define AU8522_TUNERLOCKING 0
+#define AU8522_DEMODLOCKING 1
+        u8 status_mode;
+};
+
+#if defined(CONFIG_DVB_AU8522) ||                               \
+            (defined(CONFIG_DVB_AU8522_MODULE) && defined(MODULE))
+extern struct dvb_frontend *au8522_attach(const struct au8522_config *config,
+                                          struct i2c_adapter *i2c);
+#else
+static inline
+struct dvb_frontend *au8522_attach(const struct au8522_config *config,
+                                   struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+#endif /* CONFIG_DVB_AU8522 */
+
+#endif /* __AU8522_H__ */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ */
diff --git a/drivers/media/dvb/frontends/bcm3510.c b/drivers/media/dvb/frontends/bcm3510.c
index a913f49c062b..d268e65e777d 100644
--- a/drivers/media/dvb/frontends/bcm3510.c
+++ b/drivers/media/dvb/frontends/bcm3510.c
@@ -91,7 +91,7 @@ static int bcm3510_writebytes (struct bcm3510_state *state, u8 reg, u8 *buf, u8
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
 
                 deb_info("%s: i2c write error (addr %02x, reg %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, reg,  err);
+                        __func__, state->config->demod_address, reg,  err);
                 return -EREMOTEIO;
         }
 
@@ -110,7 +110,7 @@ static int bcm3510_readbytes (struct bcm3510_state *state, u8 reg, u8 *buf, u8 l
 
         if ((err = i2c_transfer (state->i2c, msg, 2)) != 2) {
                 deb_info("%s: i2c read error (addr %02x, reg %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, reg,  err);
+                        __func__, state->config->demod_address, reg,  err);
                 return -EREMOTEIO;
         }
         deb_i2c("i2c rd %02x: ",reg);
diff --git a/drivers/media/dvb/frontends/bcm3510.h b/drivers/media/dvb/frontends/bcm3510.h
index 7e4f95e1734b..f4575c0cc446 100644
--- a/drivers/media/dvb/frontends/bcm3510.h
+++ b/drivers/media/dvb/frontends/bcm3510.h
@@ -41,7 +41,7 @@ extern struct dvb_frontend* bcm3510_attach(const struct bcm3510_config* config,
 static inline struct dvb_frontend* bcm3510_attach(const struct bcm3510_config* config,
                                                   struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_BCM3510
diff --git a/drivers/media/dvb/frontends/bsbe1.h b/drivers/media/dvb/frontends/bsbe1.h
index d8f65738e5d2..5e431ebd089b 100644
--- a/drivers/media/dvb/frontends/bsbe1.h
+++ b/drivers/media/dvb/frontends/bsbe1.h
@@ -1,5 +1,5 @@
 /*
- * bsbe1.h - ALPS BSBE1 tuner support (moved from av7110.c)
+ * bsbe1.h - ALPS BSBE1 tuner support
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -26,44 +26,24 @@
 #define BSBE1_H
 
 static u8 alps_bsbe1_inittab[] = {
-        0x01, 0x15,
-        0x02, 0x30,
-        0x03, 0x00,
+        0x01, 0x15,   /* XTAL = 4MHz, VCO = 352 MHz */
+        0x02, 0x30,   /* MCLK = 88 MHz */
+        0x03, 0x00,   /* ACR output 0 */
         0x04, 0x7d,   /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
-        0x05, 0x35,   /* I2CT = 0, SCLT = 1, SDAT = 1 */
-        0x06, 0x40,   /* DAC not used, set to high impendance mode */
-        0x07, 0x00,   /* DAC LSB */
+        0x05, 0x05,   /* I2CT = 0, SCLT = 1, SDAT = 1 */
+        0x06, 0x00,   /* DAC output 0 */
         0x08, 0x40,   /* DiSEqC off, LNB power on OP2/LOCK pin on */
         0x09, 0x00,   /* FIFO */
-        0x0c, 0x51,   /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
-        0x0d, 0x82,   /* DC offset compensation = ON, beta_agc1 = 2 */
-        0x0e, 0x23,   /* alpha_tmg = 2, beta_tmg = 3 */
-        0x10, 0x3f,   // AGC2  0x3d
-        0x11, 0x84,
-        0x12, 0xb9,
-        0x15, 0xc9,   // lock detector threshold
-        0x16, 0x00,
-        0x17, 0x00,
-        0x18, 0x00,
-        0x19, 0x00,
-        0x1a, 0x00,
-        0x1f, 0x50,
-        0x20, 0x00,
-        0x21, 0x00,
-        0x22, 0x00,
-        0x23, 0x00,
-        0x28, 0x00,  // out imp: normal  out type: parallel FEC mode:0
-        0x29, 0x1e,  // 1/2 threshold
-        0x2a, 0x14,  // 2/3 threshold
-        0x2b, 0x0f,  // 3/4 threshold
-        0x2c, 0x09,  // 5/6 threshold
-        0x2d, 0x05,  // 7/8 threshold
-        0x2e, 0x01,
-        0x31, 0x1f,  // test all FECs
-        0x32, 0x19,  // viterbi and synchro search
-        0x33, 0xfc,  // rs control
-        0x34, 0x93,  // error control
-        0x0f, 0x92,
+        0x0c, 0x51,   /* OP1/OP0 normal, val = 1 (LNB power on) */
+        0x0d, 0x82,   /* DC offset compensation = on, beta_agc1 = 2 */
+        0x0f, 0x92,   /* AGC1R */
+        0x10, 0x34,   /* AGC2O */
+        0x11, 0x84,   /* TLSR */
+        0x12, 0xb9,   /* CFD */
+        0x15, 0xc9,   /* lock detector threshold */
+        0x28, 0x00,   /* out imp: normal, type: parallel, FEC mode: QPSK */
+        0x33, 0xfc,   /* RS control */
+        0x34, 0x93,   /* count viterbi bit errors per 2E18 bytes */
         0xff, 0xff
 };
 
@@ -100,11 +80,11 @@ static int alps_bsbe1_tuner_set_params(struct dvb_frontend* fe, struct dvb_front
         if ((params->frequency < 950000) || (params->frequency > 2150000))
                 return -EINVAL;
 
-        div = (params->frequency + (125 - 1)) / 125; // round correctly
+        div = params->frequency / 1000;
         data[0] = (div >> 8) & 0x7f;
         data[1] = div & 0xff;
-        data[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
-        data[3] = (params->frequency > 1530000) ? 0xE0 : 0xE4;
+        data[2] = 0x80 | ((div & 0x18000) >> 10) | 0x1;
+        data[3] = 0xe0;
 
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
diff --git a/drivers/media/dvb/frontends/bsru6.h b/drivers/media/dvb/frontends/bsru6.h
index e231cd84b3a1..45a6dfd8ebb5 100644
--- a/drivers/media/dvb/frontends/bsru6.h
+++ b/drivers/media/dvb/frontends/bsru6.h
@@ -133,7 +133,7 @@ static struct stv0299_config alps_bsru6_config = {
         .mclk = 88000000UL,
         .invert = 1,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_1,
+        .lock_output = STV0299_LOCKOUTPUT_1,
         .volt13_op0_op1 = STV0299_VOLT13_OP1,
         .min_delay_ms = 100,
         .set_symbol_rate = alps_bsru6_set_symbol_rate,
diff --git a/drivers/media/dvb/frontends/cx22700.c b/drivers/media/dvb/frontends/cx22700.c
index 11a4968f18cb..ace5cb17165d 100644
--- a/drivers/media/dvb/frontends/cx22700.c
+++ b/drivers/media/dvb/frontends/cx22700.c
@@ -73,13 +73,13 @@ static int cx22700_writereg (struct cx22700_state* state, u8 reg, u8 data)
         u8 buf [] = { reg, data };
         struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         ret = i2c_transfer (state->i2c, &msg, 1);
 
         if (ret != 1)
                 printk("%s: writereg error (reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        __FUNCTION__, reg, data, ret);
+                        __func__, reg, data, ret);
 
         return (ret != 1) ? -1 : 0;
 }
@@ -92,7 +92,7 @@ static int cx22700_readreg (struct cx22700_state* state, u8 reg)
         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 } };
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         ret = i2c_transfer (state->i2c, msg, 2);
 
@@ -105,7 +105,7 @@ static int cx22700_set_inversion (struct cx22700_state* state, int inversion)
 {
         u8 val;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         switch (inversion) {
         case INVERSION_AUTO:
@@ -127,7 +127,7 @@ static int cx22700_set_tps (struct cx22700_state *state, struct dvb_ofdm_paramet
         static const u8 fec_tab [6] = { 0, 1, 2, 0, 3, 4 };
         u8 val;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (p->code_rate_HP < FEC_1_2 || p->code_rate_HP > FEC_7_8)
                 return -EINVAL;
@@ -191,7 +191,7 @@ static int cx22700_get_tps (struct cx22700_state* state, struct dvb_ofdm_paramet
                                                     FEC_5_6, FEC_7_8 };
         u8 val;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (!(cx22700_readreg(state, 0x07) & 0x20))  /*  tps valid? */
                 return -EAGAIN;
diff --git a/drivers/media/dvb/frontends/cx22700.h b/drivers/media/dvb/frontends/cx22700.h
index 7ac33690cdcc..4757a930ca05 100644
--- a/drivers/media/dvb/frontends/cx22700.h
+++ b/drivers/media/dvb/frontends/cx22700.h
@@ -38,7 +38,7 @@ extern struct dvb_frontend* cx22700_attach(const struct cx22700_config* config,
 static inline struct dvb_frontend* cx22700_attach(const struct cx22700_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_CX22700
diff --git a/drivers/media/dvb/frontends/cx22702.c b/drivers/media/dvb/frontends/cx22702.c
index 1dc164d5488c..cc1db4e371c3 100644
--- a/drivers/media/dvb/frontends/cx22702.c
+++ b/drivers/media/dvb/frontends/cx22702.c
@@ -48,7 +48,7 @@ struct cx22702_state {
         u8 prevUCBlocks;
 };
 
-static int debug = 0;
+static int debug;
 #define dprintk if (debug) printk
 
 /* Register values to initialise the demod */
@@ -90,7 +90,7 @@ static int cx22702_writereg (struct cx22702_state* state, u8 reg, u8 data)
 
         if (ret != 1)
                 printk("%s: writereg error (reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        __FUNCTION__, reg, data, ret);
+                        __func__, reg, data, ret);
 
         return (ret != 1) ? -1 : 0;
 }
@@ -108,7 +108,7 @@ static u8 cx22702_readreg (struct cx22702_state* state, u8 reg)
         ret = i2c_transfer(state->i2c, msg, 2);
 
         if (ret != 2)
-                printk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
+                printk("%s: readreg error (ret == %i)\n", __func__, ret);
 
         return b1[0];
 }
@@ -195,7 +195,7 @@ static int cx22702_get_tps (struct cx22702_state *state, struct dvb_ofdm_paramet
 static int cx22702_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 {
         struct cx22702_state* state = fe->demodulator_priv;
-        dprintk ("%s(%d)\n", __FUNCTION__, enable);
+        dprintk ("%s(%d)\n", __func__, enable);
         if (enable)
                 return cx22702_writereg (state, 0x0D, cx22702_readreg(state, 0x0D) & 0xfe);
         else
@@ -228,7 +228,7 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 cx22702_writereg(state, 0x0C, cx22702_readreg(state, 0x0C) &0xcf );
                 break;
         default:
-                dprintk ("%s: invalid bandwidth\n",__FUNCTION__);
+                dprintk ("%s: invalid bandwidth\n",__func__);
                 return -EINVAL;
         }
 
@@ -250,7 +250,7 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 cx22702_writereg(state, 0x0B, cx22702_readreg(state, 0x0B) & 0xfc );
                 cx22702_writereg(state, 0x0C, (cx22702_readreg(state, 0x0C) & 0xBF) | 0x40 );
                 cx22702_writereg(state, 0x00, 0x01); /* Begin aquisition */
-                dprintk("%s: Autodetecting\n",__FUNCTION__);
+                dprintk("%s: Autodetecting\n",__func__);
                 return 0;
         }
 
@@ -261,7 +261,7 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 case QAM_16: val = (val&0xe7)|0x08; break;
                 case QAM_64: val = (val&0xe7)|0x10; break;
                 default:
-                        dprintk ("%s: invalid constellation\n",__FUNCTION__);
+                        dprintk ("%s: invalid constellation\n",__func__);
                         return -EINVAL;
         }
         switch(p->u.ofdm.hierarchy_information) {
@@ -270,7 +270,7 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 case    HIERARCHY_2: val = (val&0xf8)|2; break;
                 case    HIERARCHY_4: val = (val&0xf8)|3; break;
                 default:
-                        dprintk ("%s: invalid hierarchy\n",__FUNCTION__);
+                        dprintk ("%s: invalid hierarchy\n",__func__);
                         return -EINVAL;
         }
         cx22702_writereg (state, 0x06, val);
@@ -284,7 +284,7 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 case FEC_5_6: val = (val&0xc7)|0x18; break;
                 case FEC_7_8: val = (val&0xc7)|0x20; break;
                 default:
-                        dprintk ("%s: invalid code_rate_HP\n",__FUNCTION__);
+                        dprintk ("%s: invalid code_rate_HP\n",__func__);
                         return -EINVAL;
         }
         switch(p->u.ofdm.code_rate_LP) {
@@ -295,7 +295,7 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 case FEC_5_6: val = (val&0xf8)|3; break;
                 case FEC_7_8: val = (val&0xf8)|4; break;
                 default:
-                        dprintk ("%s: invalid code_rate_LP\n",__FUNCTION__);
+                        dprintk ("%s: invalid code_rate_LP\n",__func__);
                         return -EINVAL;
         }
         cx22702_writereg (state, 0x07, val);
@@ -307,14 +307,14 @@ static int cx22702_set_tps (struct dvb_frontend* fe, struct dvb_frontend_paramet
                 case  GUARD_INTERVAL_1_8: val = (val&0xf3)|0x08; break;
                 case  GUARD_INTERVAL_1_4: val = (val&0xf3)|0x0c; break;
                 default:
-                        dprintk ("%s: invalid guard_interval\n",__FUNCTION__);
+                        dprintk ("%s: invalid guard_interval\n",__func__);
                         return -EINVAL;
         }
         switch(p->u.ofdm.transmission_mode) {
                 case TRANSMISSION_MODE_2K: val = (val&0xfc); break;
                 case TRANSMISSION_MODE_8K: val = (val&0xfc)|1; break;
                 default:
-                        dprintk ("%s: invalid transmission_mode\n",__FUNCTION__);
+                        dprintk ("%s: invalid transmission_mode\n",__func__);
                         return -EINVAL;
         }
         cx22702_writereg(state, 0x08, val);
@@ -360,7 +360,7 @@ static int cx22702_read_status(struct dvb_frontend* fe, fe_status_t* status)
         reg23 = cx22702_readreg (state, 0x23);
 
         dprintk ("%s: status demod=0x%02x agc=0x%02x\n"
-                ,__FUNCTION__,reg0A,reg23);
+                ,__func__,reg0A,reg23);
 
         if(reg0A & 0x10) {
                 *status |= FE_HAS_LOCK;
diff --git a/drivers/media/dvb/frontends/cx22702.h b/drivers/media/dvb/frontends/cx22702.h
index 9cd64da6ee40..8af766a31552 100644
--- a/drivers/media/dvb/frontends/cx22702.h
+++ b/drivers/media/dvb/frontends/cx22702.h
@@ -48,7 +48,7 @@ extern struct dvb_frontend* cx22702_attach(const struct cx22702_config* config,
 static inline struct dvb_frontend* cx22702_attach(const struct cx22702_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_CX22702
diff --git a/drivers/media/dvb/frontends/cx24110.c b/drivers/media/dvb/frontends/cx24110.c
index b03d8283c37d..87ae29db024f 100644
--- a/drivers/media/dvb/frontends/cx24110.c
+++ b/drivers/media/dvb/frontends/cx24110.c
@@ -121,7 +121,7 @@ static int cx24110_writereg (struct cx24110_state* state, int reg, int data)
 
         if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
                 dprintk ("%s: writereg error (err == %i, reg == 0x%02x,"
-                         " data == 0x%02x)\n", __FUNCTION__, err, reg, data);
+                         " data == 0x%02x)\n", __func__, err, reg, data);
                 return -EREMOTEIO;
         }
 
@@ -247,7 +247,7 @@ static int cx24110_set_symbolrate (struct cx24110_state* state, u32 srate)
         static const u32 bands[]={5000000UL,15000000UL,90999000UL/2};
         int i;
 
-        dprintk("cx24110 debug: entering %s(%d)\n",__FUNCTION__,srate);
+        dprintk("cx24110 debug: entering %s(%d)\n",__func__,srate);
         if (srate>90999000UL/2)
                 srate=90999000UL/2;
         if (srate<500000)
@@ -358,7 +358,7 @@ static int cx24110_initfe(struct dvb_frontend* fe)
 /* fixme (low): error handling */
         int i;
 
-        dprintk("%s: init chip\n", __FUNCTION__);
+        dprintk("%s: init chip\n", __func__);
 
         for(i = 0; i < ARRAY_SIZE(cx24110_regdata); i++) {
                 cx24110_writereg(state, cx24110_regdata[i].reg, cx24110_regdata[i].data);
diff --git a/drivers/media/dvb/frontends/cx24110.h b/drivers/media/dvb/frontends/cx24110.h
index 0ca3af4db513..1792adb23c4d 100644
--- a/drivers/media/dvb/frontends/cx24110.h
+++ b/drivers/media/dvb/frontends/cx24110.h
@@ -48,7 +48,7 @@ extern struct dvb_frontend* cx24110_attach(const struct cx24110_config* config,
 static inline struct dvb_frontend* cx24110_attach(const struct cx24110_config* config,
                                                   struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_CX24110
diff --git a/drivers/media/dvb/frontends/cx24113.h b/drivers/media/dvb/frontends/cx24113.h
new file mode 100644
index 000000000000..5ab3dd11076b
--- /dev/null
+++ b/drivers/media/dvb/frontends/cx24113.h
@@ -0,0 +1,48 @@
+/*
+ *  Driver for Conexant CX24113/CX24128 Tuner (Satelite)
+ *
+ *  Copyright (C) 2007-8 Patrick Boettcher <pb@linuxtv.org>
+ *
+ *  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 CX24113_H
+#define CX24113_H
+
+struct dvb_frontend;
+
+struct cx24113_config {
+        u8 i2c_addr; /* 0x14 or 0x54 */
+
+        u32 xtal_khz;
+};
+
+/* TODO: #if defined(CONFIG_DVB_TUNER_CX24113) || \
+ * (defined(CONFIG_DVB_TUNER_CX24113_MODULE) && defined(MODULE)) */
+
+static inline struct dvb_frontend *cx24113_attach(struct dvb_frontend *fe,
+        const struct cx24113_config *config, struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+
+static inline void cx24113_agc_callback(struct dvb_frontend *fe)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+}
+
+#endif /* CX24113_H */
diff --git a/drivers/media/dvb/frontends/cx24123.c b/drivers/media/dvb/frontends/cx24123.c
index d74fdbd63361..7f68d78c6558 100644
--- a/drivers/media/dvb/frontends/cx24123.c
+++ b/drivers/media/dvb/frontends/cx24123.c
@@ -1,24 +1,26 @@
 /*
-    Conexant cx24123/cx24109 - DVB QPSK Satellite demod/tuner driver
-
-    Copyright (C) 2005 Steven Toth <stoth@hauppauge.com>
-
-    Support for KWorld DVB-S 100 by Vadim Catana <skystar@moldova.cc>
-
-    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.
-*/
+ *   Conexant cx24123/cx24109 - DVB QPSK Satellite demod/tuner driver
+ *
+ *   Copyright (C) 2005 Steven Toth <stoth@hauppauge.com>
+ *
+ *   Support for KWorld DVB-S 100 by Vadim Catana <skystar@moldova.cc>
+ *
+ *   Support for CX24123/CX24113-NIM by Patrick Boettcher <pb@linuxtv.org>
+ *
+ *   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>
@@ -32,9 +34,16 @@
 
 static int force_band;
 static int debug;
+
+#define info(args...) do { printk(KERN_INFO "CX24123: " args); } while (0)
+#define err(args...)  do { printk(KERN_ERR  "CX24123: " args); } while (0)
+
 #define dprintk(args...) \
         do { \
-                if (debug) printk (KERN_DEBUG "cx24123: " args); \
+                if (debug) { \
+                        printk(KERN_DEBUG "CX24123: %s: ", __func__); \
+                        printk(args); \
+                } \
         } while (0)
 
 struct cx24123_state
@@ -51,6 +60,10 @@ struct cx24123_state
         u32 pllarg;
         u32 FILTune;
 
+        struct i2c_adapter tuner_i2c_adapter;
+
+        u8 demod_rev;
+
         /* The Demod/Tuner can't easily provide these, we cache them */
         u32 currentfreq;
         u32 currentsymbolrate;
@@ -225,48 +238,52 @@ static struct {
         {0x67, 0x83}, /* Non-DCII symbol clock */
 };
 
-static int cx24123_writereg(struct cx24123_state* state, int reg, int data)
+static int cx24123_i2c_writereg(struct cx24123_state *state,
+        u8 i2c_addr, int reg, int data)
 {
         u8 buf[] = { reg, data };
-        struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
+        struct i2c_msg msg = {
+                .addr = i2c_addr, .flags = 0, .buf = buf, .len = 2
+        };
         int err;
 
-        if (debug>1)
-                printk("cx24123: %s:  write reg 0x%02x, value 0x%02x\n",
-                                                __FUNCTION__,reg, data);
+        /* printk(KERN_DEBUG "wr(%02x): %02x %02x\n", i2c_addr, reg, data); */
 
         if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
                 printk("%s: writereg error(err == %i, reg == 0x%02x,"
-                         " data == 0x%02x)\n", __FUNCTION__, err, reg, data);
-                return -EREMOTEIO;
+                         " data == 0x%02x)\n", __func__, err, reg, data);
+                return err;
         }
 
         return 0;
 }
 
-static int cx24123_readreg(struct cx24123_state* state, u8 reg)
+static int cx24123_i2c_readreg(struct cx24123_state *state, u8 i2c_addr, u8 reg)
 {
         int ret;
-        u8 b0[] = { reg };
-        u8 b1[] = { 0 };
+        u8 b = 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 }
+                { .addr = i2c_addr, .flags = 0, .buf = &reg, .len = 1 },
+                { .addr = i2c_addr, .flags = I2C_M_RD, .buf = &b, .len = 1 }
         };
 
         ret = i2c_transfer(state->i2c, msg, 2);
 
         if (ret != 2) {
-                printk("%s: reg=0x%x (error=%d)\n", __FUNCTION__, reg, ret);
+                err("%s: reg=0x%x (error=%d)\n", __func__, reg, ret);
                 return ret;
         }
 
-        if (debug>1)
-                printk("cx24123: read reg 0x%02x, value 0x%02x\n",reg, ret);
+        /* printk(KERN_DEBUG "rd(%02x): %02x %02x\n", i2c_addr, reg, b); */
 
-        return b1[0];
+        return b;
 }
 
+#define cx24123_readreg(state, reg) \
+        cx24123_i2c_readreg(state, state->config->demod_address, reg)
+#define cx24123_writereg(state, reg, val) \
+        cx24123_i2c_writereg(state, state->config->demod_address, reg, val)
+
 static int cx24123_set_inversion(struct cx24123_state* state, fe_spectral_inversion_t inversion)
 {
         u8 nom_reg = cx24123_readreg(state, 0x0e);
@@ -274,17 +291,17 @@ static int cx24123_set_inversion(struct cx24123_state* state, fe_spectral_invers
 
         switch (inversion) {
         case INVERSION_OFF:
-                dprintk("%s:  inversion off\n",__FUNCTION__);
+                dprintk("inversion off\n");
                 cx24123_writereg(state, 0x0e, nom_reg & ~0x80);
                 cx24123_writereg(state, 0x10, auto_reg | 0x80);
                 break;
         case INVERSION_ON:
-                dprintk("%s:  inversion on\n",__FUNCTION__);
+                dprintk("inversion on\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x80);
                 cx24123_writereg(state, 0x10, auto_reg | 0x80);
                 break;
         case INVERSION_AUTO:
-                dprintk("%s:  inversion auto\n",__FUNCTION__);
+                dprintk("inversion auto\n");
                 cx24123_writereg(state, 0x10, auto_reg & ~0x80);
                 break;
         default:
@@ -301,10 +318,10 @@ static int cx24123_get_inversion(struct cx24123_state* state, fe_spectral_invers
         val = cx24123_readreg(state, 0x1b) >> 7;
 
         if (val == 0) {
-                dprintk("%s:  read inversion off\n",__FUNCTION__);
+                dprintk("read inversion off\n");
                 *inversion = INVERSION_OFF;
         } else {
-                dprintk("%s:  read inversion on\n",__FUNCTION__);
+                dprintk("read inversion on\n");
                 *inversion = INVERSION_ON;
         }
 
@@ -326,42 +343,42 @@ static int cx24123_set_fec(struct cx24123_state* state, fe_code_rate_t fec)
 
         switch (fec) {
         case FEC_1_2:
-                dprintk("%s:  set FEC to 1/2\n",__FUNCTION__);
+                dprintk("set FEC to 1/2\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x01);
                 cx24123_writereg(state, 0x0f, 0x02);
                 break;
         case FEC_2_3:
-                dprintk("%s:  set FEC to 2/3\n",__FUNCTION__);
+                dprintk("set FEC to 2/3\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x02);
                 cx24123_writereg(state, 0x0f, 0x04);
                 break;
         case FEC_3_4:
-                dprintk("%s:  set FEC to 3/4\n",__FUNCTION__);
+                dprintk("set FEC to 3/4\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x03);
                 cx24123_writereg(state, 0x0f, 0x08);
                 break;
         case FEC_4_5:
-                dprintk("%s:  set FEC to 4/5\n",__FUNCTION__);
+                dprintk("set FEC to 4/5\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x04);
                 cx24123_writereg(state, 0x0f, 0x10);
                 break;
         case FEC_5_6:
-                dprintk("%s:  set FEC to 5/6\n",__FUNCTION__);
+                dprintk("set FEC to 5/6\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x05);
                 cx24123_writereg(state, 0x0f, 0x20);
                 break;
         case FEC_6_7:
-                dprintk("%s:  set FEC to 6/7\n",__FUNCTION__);
+                dprintk("set FEC to 6/7\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x06);
                 cx24123_writereg(state, 0x0f, 0x40);
                 break;
         case FEC_7_8:
-                dprintk("%s:  set FEC to 7/8\n",__FUNCTION__);
+                dprintk("set FEC to 7/8\n");
                 cx24123_writereg(state, 0x0e, nom_reg | 0x07);
                 cx24123_writereg(state, 0x0f, 0x80);
                 break;
         case FEC_AUTO:
-                dprintk("%s:  set FEC to auto\n",__FUNCTION__);
+                dprintk("set FEC to auto\n");
                 cx24123_writereg(state, 0x0f, 0xfe);
                 break;
         default:
@@ -490,7 +507,8 @@ static int cx24123_set_symbolrate(struct cx24123_state* state, u32 srate)
         tmp = cx24123_readreg(state, 0x0c) & ~0xe0;
         cx24123_writereg(state, 0x0c, tmp | sample_gain << 5);
 
-        dprintk("%s: srate=%d, ratio=0x%08x, sample_rate=%i sample_gain=%d\n", __FUNCTION__, srate, ratio, sample_rate, sample_gain);
+        dprintk("srate=%d, ratio=0x%08x, sample_rate=%i sample_gain=%d\n",
+                srate, ratio, sample_rate, sample_gain);
 
         return 0;
 }
@@ -570,7 +588,7 @@ static int cx24123_pll_writereg(struct dvb_frontend* fe, struct dvb_frontend_par
         struct cx24123_state *state = fe->demodulator_priv;
         unsigned long timeout;
 
-        dprintk("%s:  pll writereg called, data=0x%08x\n",__FUNCTION__,data);
+        dprintk("pll writereg called, data=0x%08x\n", data);
 
         /* align the 21 bytes into to bit23 boundary */
         data = data << 3;
@@ -583,7 +601,8 @@ static int cx24123_pll_writereg(struct dvb_frontend* fe, struct dvb_frontend_par
         cx24123_writereg(state, 0x22, (data >> 16) & 0xff);
         while ((cx24123_readreg(state, 0x20) & 0x40) == 0) {
                 if (time_after(jiffies, timeout)) {
-                        printk("%s:  demodulator is not responding, possibly hung, aborting.\n", __FUNCTION__);
+                        err("%s:  demodulator is not responding, "\
+                                "possibly hung, aborting.\n", __func__);
                         return -EREMOTEIO;
                 }
                 msleep(10);
@@ -594,7 +613,8 @@ static int cx24123_pll_writereg(struct dvb_frontend* fe, struct dvb_frontend_par
         cx24123_writereg(state, 0x22, (data>>8) & 0xff );
         while ((cx24123_readreg(state, 0x20) & 0x40) == 0) {
                 if (time_after(jiffies, timeout)) {
-                        printk("%s:  demodulator is not responding, possibly hung, aborting.\n", __FUNCTION__);
+                        err("%s:  demodulator is not responding, "\
+                                "possibly hung, aborting.\n", __func__);
                         return -EREMOTEIO;
                 }
                 msleep(10);
@@ -605,7 +625,8 @@ static int cx24123_pll_writereg(struct dvb_frontend* fe, struct dvb_frontend_par
         cx24123_writereg(state, 0x22, (data) & 0xff );
         while ((cx24123_readreg(state, 0x20) & 0x80)) {
                 if (time_after(jiffies, timeout)) {
-                        printk("%s:  demodulator is not responding, possibly hung, aborting.\n", __FUNCTION__);
+                        err("%s:  demodulator is not responding," \
+                                "possibly hung, aborting.\n", __func__);
                         return -EREMOTEIO;
                 }
                 msleep(10);
@@ -626,7 +647,7 @@ static int cx24123_pll_tune(struct dvb_frontend* fe, struct dvb_frontend_paramet
         dprintk("frequency=%i\n", p->frequency);
 
         if (cx24123_pll_calculate(fe, p) != 0) {
-                printk("%s: cx24123_pll_calcutate failed\n",__FUNCTION__);
+                err("%s: cx24123_pll_calcutate failed\n", __func__);
                 return -EINVAL;
         }
 
@@ -643,18 +664,38 @@ static int cx24123_pll_tune(struct dvb_frontend* fe, struct dvb_frontend_paramet
         cx24123_writereg(state, 0x27, state->FILTune >> 2);
         cx24123_writereg(state, 0x28, val | (state->FILTune & 0x3));
 
-        dprintk("%s:  pll tune VCA=%d, band=%d, pll=%d\n",__FUNCTION__,state->VCAarg,
-                        state->bandselectarg,state->pllarg);
+        dprintk("pll tune VCA=%d, band=%d, pll=%d\n", state->VCAarg,
+                        state->bandselectarg, state->pllarg);
 
         return 0;
 }
 
+
+/*
+ * 0x23:
+ *    [7:7] = BTI enabled
+ *    [6:6] = I2C repeater enabled
+ *    [5:5] = I2C repeater start
+ *    [0:0] = BTI start
+ */
+
+/* mode == 1 -> i2c-repeater, 0 -> bti */
+static int cx24123_repeater_mode(struct cx24123_state *state, u8 mode, u8 start)
+{
+        u8 r = cx24123_readreg(state, 0x23) & 0x1e;
+        if (mode)
+                r |= (1 << 6) | (start << 5);
+        else
+                r |= (1 << 7) | (start);
+        return cx24123_writereg(state, 0x23, r);
+}
+
 static int cx24123_initfe(struct dvb_frontend* fe)
 {
         struct cx24123_state *state = fe->demodulator_priv;
         int i;
 
-        dprintk("%s:  init frontend\n",__FUNCTION__);
+        dprintk("init frontend\n");
 
         /* Configure the demod to a good set of defaults */
         for (i = 0; i < ARRAY_SIZE(cx24123_regdata); i++)
@@ -664,6 +705,9 @@ static int cx24123_initfe(struct dvb_frontend* fe)
         if(state->config->lnb_polarity)
                 cx24123_writereg(state, 0x32, cx24123_readreg(state, 0x32) | 0x02);
 
+        if (state->config->dont_use_pll)
+        cx24123_repeater_mode(state, 1, 0);
+
         return 0;
 }
 
@@ -676,10 +720,10 @@ static int cx24123_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage
 
         switch (voltage) {
         case SEC_VOLTAGE_13:
-                dprintk("%s: setting voltage 13V\n", __FUNCTION__);
+                dprintk("setting voltage 13V\n");
                 return cx24123_writereg(state, 0x29, val & 0x7f);
         case SEC_VOLTAGE_18:
-                dprintk("%s: setting voltage 18V\n", __FUNCTION__);
+                dprintk("setting voltage 18V\n");
                 return cx24123_writereg(state, 0x29, val | 0x80);
         case SEC_VOLTAGE_OFF:
                 /* already handled in cx88-dvb */
@@ -697,7 +741,8 @@ static void cx24123_wait_for_diseqc(struct cx24123_state *state)
         unsigned long timeout = jiffies + msecs_to_jiffies(200);
         while (!(cx24123_readreg(state, 0x29) & 0x40)) {
                 if(time_after(jiffies, timeout)) {
-                        printk("%s: diseqc queue not ready, command may be lost.\n", __FUNCTION__);
+                        err("%s: diseqc queue not ready, " \
+                                "command may be lost.\n", __func__);
                         break;
                 }
                 msleep(10);
@@ -709,7 +754,7 @@ static int cx24123_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_ma
         struct cx24123_state *state = fe->demodulator_priv;
         int i, val, tone;
 
-        dprintk("%s:\n",__FUNCTION__);
+        dprintk("\n");
 
         /* stop continuous tone if enabled */
         tone = cx24123_readreg(state, 0x29);
@@ -744,7 +789,7 @@ static int cx24123_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t
         struct cx24123_state *state = fe->demodulator_priv;
         int val, tone;
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("\n");
 
         /* stop continuous tone if enabled */
         tone = cx24123_readreg(state, 0x29);
@@ -778,13 +823,21 @@ static int cx24123_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t
 static int cx24123_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
         struct cx24123_state *state = fe->demodulator_priv;
-
         int sync = cx24123_readreg(state, 0x14);
-        int lock = cx24123_readreg(state, 0x20);
 
         *status = 0;
-        if (lock & 0x01)
-                *status |= FE_HAS_SIGNAL;
+        if (state->config->dont_use_pll) {
+                u32 tun_status = 0;
+                if (fe->ops.tuner_ops.get_status)
+                        fe->ops.tuner_ops.get_status(fe, &tun_status);
+                if (tun_status & TUNER_STATUS_LOCKED)
+                        *status |= FE_HAS_SIGNAL;
+        } else {
+                int lock = cx24123_readreg(state, 0x20);
+                if (lock & 0x01)
+                        *status |= FE_HAS_SIGNAL;
+        }
+
         if (sync & 0x02)
                 *status |= FE_HAS_CARRIER;      /* Phase locked */
         if (sync & 0x04)
@@ -803,7 +856,7 @@ static int cx24123_read_status(struct dvb_frontend* fe, fe_status_t* status)
  * Configured to return the measurement of errors in blocks, because no UCBLOCKS value
  * is available, so this value doubles up to satisfy both measurements
  */
-static int cx24123_read_ber(struct dvb_frontend* fe, u32* ber)
+static int cx24123_read_ber(struct dvb_frontend *fe, u32 *ber)
 {
         struct cx24123_state *state = fe->demodulator_priv;
 
@@ -813,23 +866,24 @@ static int cx24123_read_ber(struct dvb_frontend* fe, u32* ber)
                 (cx24123_readreg(state, 0x1d) << 8 |
                  cx24123_readreg(state, 0x1e));
 
-        dprintk("%s:  BER = %d\n",__FUNCTION__,*ber);
+        dprintk("BER = %d\n", *ber);
 
         return 0;
 }
 
-static int cx24123_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
+static int cx24123_read_signal_strength(struct dvb_frontend *fe,
+        u16 *signal_strength)
 {
         struct cx24123_state *state = fe->demodulator_priv;
 
         *signal_strength = cx24123_readreg(state, 0x3b) << 8; /* larger = better */
 
-        dprintk("%s:  Signal strength = %d\n",__FUNCTION__,*signal_strength);
+        dprintk("Signal strength = %d\n", *signal_strength);
 
         return 0;
 }
 
-static int cx24123_read_snr(struct dvb_frontend* fe, u16* snr)
+static int cx24123_read_snr(struct dvb_frontend *fe, u16 *snr)
 {
         struct cx24123_state *state = fe->demodulator_priv;
 
@@ -838,16 +892,17 @@ static int cx24123_read_snr(struct dvb_frontend* fe, u16* snr)
         *snr = 65535 - (((u16)cx24123_readreg(state, 0x18) << 8) |
                          (u16)cx24123_readreg(state, 0x19));
 
-        dprintk("%s:  read S/N index = %d\n",__FUNCTION__,*snr);
+        dprintk("read S/N index = %d\n", *snr);
 
         return 0;
 }
 
-static int cx24123_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
+static int cx24123_set_frontend(struct dvb_frontend *fe,
+        struct dvb_frontend_parameters *p)
 {
         struct cx24123_state *state = fe->demodulator_priv;
 
-        dprintk("%s:  set_frontend\n",__FUNCTION__);
+        dprintk("\n");
 
         if (state->config->set_ts_params)
                 state->config->set_ts_params(fe, 0);
@@ -858,13 +913,22 @@ static int cx24123_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_par
         cx24123_set_inversion(state, p->inversion);
         cx24123_set_fec(state, p->u.qpsk.fec_inner);
         cx24123_set_symbolrate(state, p->u.qpsk.symbol_rate);
-        cx24123_pll_tune(fe, p);
+
+        if (!state->config->dont_use_pll)
+                cx24123_pll_tune(fe, p);
+        else if (fe->ops.tuner_ops.set_params)
+                fe->ops.tuner_ops.set_params(fe, p);
+        else
+                err("it seems I don't have a tuner...");
 
         /* Enable automatic aquisition and reset cycle */
         cx24123_writereg(state, 0x03, (cx24123_readreg(state, 0x03) | 0x07));
         cx24123_writereg(state, 0x00, 0x10);
         cx24123_writereg(state, 0x00, 0);
 
+        if (state->config->agc_callback)
+                state->config->agc_callback(fe);
+
         return 0;
 }
 
@@ -872,14 +936,14 @@ static int cx24123_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_par
 {
         struct cx24123_state *state = fe->demodulator_priv;
 
-        dprintk("%s:  get_frontend\n",__FUNCTION__);
+        dprintk("\n");
 
         if (cx24123_get_inversion(state, &p->inversion) != 0) {
-                printk("%s: Failed to get inversion status\n",__FUNCTION__);
+                err("%s: Failed to get inversion status\n", __func__);
                 return -EREMOTEIO;
         }
         if (cx24123_get_fec(state, &p->u.qpsk.fec_inner) != 0) {
-                printk("%s: Failed to get fec status\n",__FUNCTION__);
+                err("%s: Failed to get fec status\n", __func__);
                 return -EREMOTEIO;
         }
         p->frequency = state->currentfreq;
@@ -900,13 +964,13 @@ static int cx24123_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 
         switch (tone) {
         case SEC_TONE_ON:
-                dprintk("%s: setting tone on\n", __FUNCTION__);
+                dprintk("setting tone on\n");
                 return cx24123_writereg(state, 0x29, val | 0x10);
         case SEC_TONE_OFF:
-                dprintk("%s: setting tone off\n",__FUNCTION__);
+                dprintk("setting tone off\n");
                 return cx24123_writereg(state, 0x29, val & 0xef);
         default:
-                printk("%s: CASE reached default with tone=%d\n", __FUNCTION__, tone);
+                err("CASE reached default with tone=%d\n", tone);
                 return -EINVAL;
         }
 
@@ -939,47 +1003,86 @@ static int cx24123_get_algo(struct dvb_frontend *fe)
 static void cx24123_release(struct dvb_frontend* fe)
 {
         struct cx24123_state* state = fe->demodulator_priv;
-        dprintk("%s\n",__FUNCTION__);
+        dprintk("\n");
+        i2c_del_adapter(&state->tuner_i2c_adapter);
         kfree(state);
 }
 
+static int cx24123_tuner_i2c_tuner_xfer(struct i2c_adapter *i2c_adap,
+        struct i2c_msg msg[], int num)
+{
+        struct cx24123_state *state = i2c_get_adapdata(i2c_adap);
+        /* this repeater closes after the first stop */
+    cx24123_repeater_mode(state, 1, 1);
+        return i2c_transfer(state->i2c, msg, num);
+}
+
+static u32 cx24123_tuner_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm cx24123_tuner_i2c_algo = {
+        .master_xfer   = cx24123_tuner_i2c_tuner_xfer,
+        .functionality = cx24123_tuner_i2c_func,
+};
+
+struct i2c_adapter *
+        cx24123_get_tuner_i2c_adapter(struct dvb_frontend *fe)
+{
+        struct cx24123_state *state = fe->demodulator_priv;
+        return &state->tuner_i2c_adapter;
+}
+EXPORT_SYMBOL(cx24123_get_tuner_i2c_adapter);
+
 static struct dvb_frontend_ops cx24123_ops;
 
 struct dvb_frontend* cx24123_attach(const struct cx24123_config* config,
                                     struct i2c_adapter* i2c)
 {
-        struct cx24123_state* state = NULL;
-        int ret;
-
-        dprintk("%s\n",__FUNCTION__);
+        struct cx24123_state *state =
+                kzalloc(sizeof(struct cx24123_state), GFP_KERNEL);
 
+        dprintk("\n");
         /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct cx24123_state), GFP_KERNEL);
         if (state == NULL) {
-                printk("Unable to kmalloc\n");
+                err("Unable to kmalloc\n");
                 goto error;
         }
 
         /* setup the state */
         state->config = config;
         state->i2c = i2c;
-        state->VCAarg = 0;
-        state->VGAarg = 0;
-        state->bandselectarg = 0;
-        state->pllarg = 0;
-        state->currentfreq = 0;
-        state->currentsymbolrate = 0;
 
         /* check if the demod is there */
-        ret = cx24123_readreg(state, 0x00);
-        if ((ret != 0xd1) && (ret != 0xe1)) {
-                printk("Version != d1 or e1\n");
+        state->demod_rev = cx24123_readreg(state, 0x00);
+        switch (state->demod_rev) {
+        case 0xe1: info("detected CX24123C\n"); break;
+        case 0xd1: info("detected CX24123\n"); break;
+        default:
+                err("wrong demod revision: %x\n", state->demod_rev);
                 goto error;
         }
 
         /* create dvb_frontend */
         memcpy(&state->frontend.ops, &cx24123_ops, sizeof(struct dvb_frontend_ops));
         state->frontend.demodulator_priv = state;
+
+    /* create tuner i2c adapter */
+    if (config->dont_use_pll)
+        cx24123_repeater_mode(state, 1, 0);
+
+        strncpy(state->tuner_i2c_adapter.name,
+                "CX24123 tuner I2C bus", I2C_NAME_SIZE);
+        state->tuner_i2c_adapter.class     = I2C_CLASS_TV_DIGITAL,
+        state->tuner_i2c_adapter.algo      = &cx24123_tuner_i2c_algo;
+        state->tuner_i2c_adapter.algo_data = NULL;
+        i2c_set_adapdata(&state->tuner_i2c_adapter, state);
+        if (i2c_add_adapter(&state->tuner_i2c_adapter) < 0) {
+        err("tuner i2c bus could not be initialized\n");
+                goto error;
+        }
+
         return &state->frontend;
 
 error:
@@ -1029,7 +1132,8 @@ MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
 module_param(force_band, int, 0644);
 MODULE_PARM_DESC(force_band, "Force a specific band select (1-9, default:off).");
 
-MODULE_DESCRIPTION("DVB Frontend module for Conexant cx24123/cx24109 hardware");
+MODULE_DESCRIPTION("DVB Frontend module for Conexant " \
+        "CX24123/CX24109/CX24113 hardware");
 MODULE_AUTHOR("Steven Toth");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/media/dvb/frontends/cx24123.h b/drivers/media/dvb/frontends/cx24123.h
index 84f9e4f5c15e..81ebc3d2f19f 100644
--- a/drivers/media/dvb/frontends/cx24123.h
+++ b/drivers/media/dvb/frontends/cx24123.h
@@ -33,16 +33,27 @@ struct cx24123_config
 
         /* 0 = LNB voltage normal, 1 = LNB voltage inverted */
         int lnb_polarity;
+
+        /* this device has another tuner */
+        u8 dont_use_pll;
+        void (*agc_callback) (struct dvb_frontend *);
 };
 
 #if defined(CONFIG_DVB_CX24123) || (defined(CONFIG_DVB_CX24123_MODULE) && defined(MODULE))
-extern struct dvb_frontend* cx24123_attach(const struct cx24123_config* config,
-                                           struct i2c_adapter* i2c);
+extern struct dvb_frontend *cx24123_attach(const struct cx24123_config *config,
+                                           struct i2c_adapter *i2c);
+extern struct i2c_adapter *cx24123_get_tuner_i2c_adapter(struct dvb_frontend *);
 #else
-static inline struct dvb_frontend* cx24123_attach(const struct cx24123_config* config,
-                                                  struct i2c_adapter* i2c)
+static inline struct dvb_frontend *cx24123_attach(
+        const struct cx24123_config *config, struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+static struct i2c_adapter *
+        cx24123_get_tuner_i2c_adapter(struct dvb_frontend *fe)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_CX24123
diff --git a/drivers/media/dvb/frontends/dib3000.h b/drivers/media/dvb/frontends/dib3000.h
index a6d3854a67bc..ba917359fa65 100644
--- a/drivers/media/dvb/frontends/dib3000.h
+++ b/drivers/media/dvb/frontends/dib3000.h
@@ -48,7 +48,7 @@ extern struct dvb_frontend* dib3000mb_attach(const struct dib3000_config* config
 static inline struct dvb_frontend* dib3000mb_attach(const struct dib3000_config* config,
                                              struct i2c_adapter* i2c, struct dib_fe_xfer_ops *xfer_ops)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_DIB3000MB
diff --git a/drivers/media/dvb/frontends/dib3000mc.h b/drivers/media/dvb/frontends/dib3000mc.h
index 72d4757601d8..4142ed7a47d0 100644
--- a/drivers/media/dvb/frontends/dib3000mc.h
+++ b/drivers/media/dvb/frontends/dib3000mc.h
@@ -44,7 +44,7 @@ extern struct dvb_frontend * dib3000mc_attach(struct i2c_adapter *i2c_adap, u8 i
 #else
 static inline struct dvb_frontend * dib3000mc_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib3000mc_config *cfg)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_DIB3000MC
diff --git a/drivers/media/dvb/frontends/dib7000p.c b/drivers/media/dvb/frontends/dib7000p.c
index 47c23e29753e..1a0142e0d741 100644
--- a/drivers/media/dvb/frontends/dib7000p.c
+++ b/drivers/media/dvb/frontends/dib7000p.c
@@ -1168,7 +1168,7 @@ static int dib7000p_set_frontend(struct dvb_frontend* fe,
         ret = dib7000p_tune(fe, fep);
 
         /* make this a config parameter */
-        dib7000p_set_output_mode(state, OUTMODE_MPEG2_FIFO);
+        dib7000p_set_output_mode(state, state->cfg.output_mode);
     return ret;
 }
 
@@ -1330,6 +1330,12 @@ struct dvb_frontend * dib7000p_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr,
         st->gpio_val = cfg->gpio_val;
         st->gpio_dir = cfg->gpio_dir;
 
+        /* Ensure the output mode remains at the previous default if it's
+         * not specifically set by the caller.
+         */
+        if (st->cfg.output_mode != OUTMODE_MPEG2_SERIAL)
+                st->cfg.output_mode = OUTMODE_MPEG2_FIFO;
+
         demod                   = &st->demod;
         demod->demodulator_priv = st;
         memcpy(&st->demod.ops, &dib7000p_ops, sizeof(struct dvb_frontend_ops));
diff --git a/drivers/media/dvb/frontends/dib7000p.h b/drivers/media/dvb/frontends/dib7000p.h
index eefcac8b5244..081bd81f3da2 100644
--- a/drivers/media/dvb/frontends/dib7000p.h
+++ b/drivers/media/dvb/frontends/dib7000p.h
@@ -31,6 +31,8 @@ struct dib7000p_config {
         u8 spur_protect;
 
         int (*agc_control) (struct dvb_frontend *, u8 before);
+
+        u8 output_mode;
 };
 
 #define DEFAULT_DIB7000P_I2C_ADDRESS 18
diff --git a/drivers/media/dvb/frontends/dvb-pll.c b/drivers/media/dvb/frontends/dvb-pll.c
index 8c8d7342d0b3..a054894ff481 100644
--- a/drivers/media/dvb/frontends/dvb-pll.c
+++ b/drivers/media/dvb/frontends/dvb-pll.c
@@ -44,14 +44,10 @@ struct dvb_pll_priv {
 
 static unsigned int dvb_pll_devcount;
 
-static int debug = 0;
+static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "enable verbose debug messages");
 
-static unsigned int input[DVB_PLL_MAX] = { [ 0 ... (DVB_PLL_MAX-1) ] = 0 };
-module_param_array(input, int, NULL, 0644);
-MODULE_PARM_DESC(input,"specify rf input choice, 0 for autoselect (default)");
-
 static unsigned int id[DVB_PLL_MAX] =
         { [ 0 ... (DVB_PLL_MAX-1) ] = DVB_PLL_UNDEFINED };
 module_param_array(id, int, NULL, 0644);
@@ -80,23 +76,6 @@ struct dvb_pll_desc {
 /* ----------------------------------------------------------- */
 /* descriptions                                                */
 
-/* Set AGC TOP value to 103 dBuV:
-        0x80 = Control Byte
-        0x40 = 250 uA charge pump (irrelevant)
-        0x18 = Aux Byte to follow
-        0x06 = 64.5 kHz divider (irrelevant)
-        0x01 = Disable Vt (aka sleep)
-
-        0x00 = AGC Time constant 2s Iagc = 300 nA (vs 0x80 = 9 nA)
-        0x50 = AGC Take over point = 103 dBuV */
-static u8 tua603x_agc103[] = { 2, 0x80|0x40|0x18|0x06|0x01, 0x00|0x50 };
-
-/*      0x04 = 166.67 kHz divider
-
-        0x80 = AGC Time constant 50ms Iagc = 9 uA
-        0x20 = AGC Take over point = 112 dBuV */
-static u8 tua603x_agc112[] = { 2, 0x80|0x40|0x18|0x04|0x01, 0x80|0x20 };
-
 static struct dvb_pll_desc dvb_pll_thomson_dtt7579 = {
         .name  = "Thomson dtt7579",
         .min   = 177000000,
@@ -112,19 +91,6 @@ static struct dvb_pll_desc dvb_pll_thomson_dtt7579 = {
         },
 };
 
-static struct dvb_pll_desc dvb_pll_thomson_dtt7610 = {
-        .name  = "Thomson dtt7610",
-        .min   =  44000000,
-        .max   = 958000000,
-        .iffreq= 44000000,
-        .count = 3,
-        .entries = {
-                { 157250000, 62500, 0x8e, 0x39 },
-                { 454000000, 62500, 0x8e, 0x3a },
-                { 999999999, 62500, 0x8e, 0x3c },
-        },
-};
-
 static void thomson_dtt759x_bw(struct dvb_frontend *fe, u8 *buf,
                                const struct dvb_frontend_parameters *params)
 {
@@ -165,34 +131,6 @@ static struct dvb_pll_desc dvb_pll_lg_z201 = {
         },
 };
 
-static struct dvb_pll_desc dvb_pll_microtune_4042 = {
-        .name  = "Microtune 4042 FI5",
-        .min   =  57000000,
-        .max   = 858000000,
-        .iffreq= 44000000,
-        .count = 3,
-        .entries = {
-                { 162000000, 62500, 0x8e, 0xa1 },
-                { 457000000, 62500, 0x8e, 0x91 },
-                { 999999999, 62500, 0x8e, 0x31 },
-        },
-};
-
-static struct dvb_pll_desc dvb_pll_thomson_dtt761x = {
-        /* DTT 7611 7611A 7612 7613 7613A 7614 7615 7615A */
-        .name  = "Thomson dtt761x",
-        .min   =  57000000,
-        .max   = 863000000,
-        .iffreq= 44000000,
-        .count = 3,
-        .initdata = tua603x_agc103,
-        .entries = {
-                { 147000000, 62500, 0x8e, 0x39 },
-                { 417000000, 62500, 0x8e, 0x3a },
-                { 999999999, 62500, 0x8e, 0x3c },
-        },
-};
-
 static struct dvb_pll_desc dvb_pll_unknown_1 = {
         .name  = "unknown 1", /* used by dntv live dvb-t */
         .min   = 174000000,
@@ -301,54 +239,6 @@ static struct dvb_pll_desc dvb_pll_tua6034 = {
         },
 };
 
-/* Infineon TUA6034
- * used in LG TDVS-H061F, LG TDVS-H062F and LG TDVS-H064F
- */
-static struct dvb_pll_desc dvb_pll_lg_tdvs_h06xf = {
-        .name  = "LG TDVS-H06xF",
-        .min   =  54000000,
-        .max   = 863000000,
-        .iffreq= 44000000,
-        .initdata = tua603x_agc103,
-        .count = 3,
-        .entries = {
-                {  165000000, 62500, 0xce, 0x01 },
-                {  450000000, 62500, 0xce, 0x02 },
-                {  999999999, 62500, 0xce, 0x04 },
-        },
-};
-
-/* Philips FMD1216ME
- * used in Medion Hybrid PCMCIA card and USB Box
- */
-static void fmd1216me_bw(struct dvb_frontend *fe, u8 *buf,
-                         const struct dvb_frontend_parameters *params)
-{
-        if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ &&
-            params->frequency >= 158870000)
-                buf[3] |= 0x08;
-}
-
-static struct dvb_pll_desc dvb_pll_fmd1216me = {
-        .name = "Philips FMD1216ME",
-        .min = 50870000,
-        .max = 858000000,
-        .iffreq= 36125000,
-        .set   = fmd1216me_bw,
-        .initdata = tua603x_agc112,
-        .sleepdata = (u8[]){ 4, 0x9c, 0x60, 0x85, 0x54 },
-        .count = 7,
-        .entries = {
-                { 143870000, 166667, 0xbc, 0x41 },
-                { 158870000, 166667, 0xf4, 0x41 },
-                { 329870000, 166667, 0xbc, 0x42 },
-                { 441870000, 166667, 0xf4, 0x42 },
-                { 625870000, 166667, 0xbc, 0x44 },
-                { 803870000, 166667, 0xf4, 0x44 },
-                { 999999999, 166667, 0xfc, 0x44 },
-        }
-};
-
 /* ALPS TDED4
  * used in Nebula-Cards and USB boxes
  */
@@ -391,55 +281,6 @@ static struct dvb_pll_desc dvb_pll_tdhu2 = {
         }
 };
 
-/* Philips TUV1236D
- * used in ATI HDTV Wonder
- */
-static void tuv1236d_rf(struct dvb_frontend *fe, u8 *buf,
-                        const struct dvb_frontend_parameters *params)
-{
-        struct dvb_pll_priv *priv = fe->tuner_priv;
-        unsigned int new_rf = input[priv->nr];
-
-        if ((new_rf == 0) || (new_rf > 2)) {
-                switch (params->u.vsb.modulation) {
-                        case QAM_64:
-                        case QAM_256:
-                                new_rf = 1;
-                                break;
-                        case VSB_8:
-                        default:
-                                new_rf = 2;
-                }
-        }
-
-        switch (new_rf) {
-                case 1:
-                        buf[3] |= 0x08;
-                        break;
-                case 2:
-                        buf[3] &= ~0x08;
-                        break;
-                default:
-                        printk(KERN_WARNING
-                               "%s: unhandled rf input selection: %d",
-                               __FUNCTION__, new_rf);
-        }
-}
-
-static struct dvb_pll_desc dvb_pll_tuv1236d = {
-        .name  = "Philips TUV1236D",
-        .min   =  54000000,
-        .max   = 864000000,
-        .iffreq= 44000000,
-        .set   = tuv1236d_rf,
-        .count = 3,
-        .entries = {
-                { 157250000, 62500, 0xc6, 0x41 },
-                { 454000000, 62500, 0xc6, 0x42 },
-                { 999999999, 62500, 0xc6, 0x44 },
-        },
-};
-
 /* Samsung TBMV30111IN / TBMV30712IN1
  * used in Air2PC ATSC - 2nd generation (nxt2002)
  */
@@ -476,64 +317,6 @@ static struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261 = {
         },
 };
 
-/*
- * Philips TD1316 Tuner.
- */
-static void td1316_bw(struct dvb_frontend *fe, u8 *buf,
-                      const struct dvb_frontend_parameters *params)
-{
-        u8 band;
-
-        /* determine band */
-        if (params->frequency < 161000000)
-                band = 1;
-        else if (params->frequency < 444000000)
-                band = 2;
-        else
-                band = 4;
-
-        buf[3] |= band;
-
-        /* setup PLL filter */
-        if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ)
-                buf[3] |= 1 << 3;
-}
-
-static struct dvb_pll_desc dvb_pll_philips_td1316 = {
-        .name  = "Philips TD1316",
-        .min   =  87000000,
-        .max   = 895000000,
-        .iffreq= 36166667,
-        .set   = td1316_bw,
-        .count = 9,
-        .entries = {
-                {  93834000, 166667, 0xca, 0x60},
-                { 123834000, 166667, 0xca, 0xa0},
-                { 163834000, 166667, 0xca, 0xc0},
-                { 253834000, 166667, 0xca, 0x60},
-                { 383834000, 166667, 0xca, 0xa0},
-                { 443834000, 166667, 0xca, 0xc0},
-                { 583834000, 166667, 0xca, 0x60},
-                { 793834000, 166667, 0xca, 0xa0},
-                { 858834000, 166667, 0xca, 0xe0},
-        },
-};
-
-/* FE6600 used on DViCO Hybrid */
-static struct dvb_pll_desc dvb_pll_thomson_fe6600 = {
-        .name = "Thomson FE6600",
-        .min =  44250000,
-        .max = 858000000,
-        .iffreq= 36125000,
-        .count = 4,
-        .entries = {
-                { 250000000, 166667, 0xb4, 0x12 },
-                { 455000000, 166667, 0xfe, 0x11 },
-                { 775500000, 166667, 0xbc, 0x18 },
-                { 999999999, 166667, 0xf4, 0x18 },
-        }
-};
-
 static void opera1_bw(struct dvb_frontend *fe, u8 *buf,
                       const struct dvb_frontend_parameters *params)
 {
@@ -560,50 +343,23 @@ static struct dvb_pll_desc dvb_pll_opera1 = {
         }
 };
 
-/* Philips FCV1236D
- */
-static struct dvb_pll_desc dvb_pll_fcv1236d = {
-/* Bit_0: RF Input select
- * Bit_1: 0=digital, 1=analog
- */
-        .name  = "Philips FCV1236D",
-        .min   =  53000000,
-        .max   = 803000000,
-        .iffreq= 44000000,
-        .count = 3,
-        .entries = {
-                { 159000000, 62500, 0x8e, 0xa0 },
-                { 453000000, 62500, 0x8e, 0x90 },
-                { 999999999, 62500, 0x8e, 0x30 },
-        },
-};
-
 /* ----------------------------------------------------------- */
 
 static struct dvb_pll_desc *pll_list[] = {
         [DVB_PLL_UNDEFINED]              = NULL,
         [DVB_PLL_THOMSON_DTT7579]        = &dvb_pll_thomson_dtt7579,
         [DVB_PLL_THOMSON_DTT759X]        = &dvb_pll_thomson_dtt759x,
-        [DVB_PLL_THOMSON_DTT7610]        = &dvb_pll_thomson_dtt7610,
         [DVB_PLL_LG_Z201]                = &dvb_pll_lg_z201,
-        [DVB_PLL_MICROTUNE_4042]         = &dvb_pll_microtune_4042,
-        [DVB_PLL_THOMSON_DTT761X]        = &dvb_pll_thomson_dtt761x,
         [DVB_PLL_UNKNOWN_1]              = &dvb_pll_unknown_1,
         [DVB_PLL_TUA6010XS]              = &dvb_pll_tua6010xs,
         [DVB_PLL_ENV57H1XD5]             = &dvb_pll_env57h1xd5,
         [DVB_PLL_TUA6034]                = &dvb_pll_tua6034,
-        [DVB_PLL_LG_TDVS_H06XF]          = &dvb_pll_lg_tdvs_h06xf,
         [DVB_PLL_TDA665X]                = &dvb_pll_tda665x,
-        [DVB_PLL_FMD1216ME]              = &dvb_pll_fmd1216me,
         [DVB_PLL_TDED4]                  = &dvb_pll_tded4,
-        [DVB_PLL_TUV1236D]               = &dvb_pll_tuv1236d,
         [DVB_PLL_TDHU2]                  = &dvb_pll_tdhu2,
         [DVB_PLL_SAMSUNG_TBMV]           = &dvb_pll_samsung_tbmv,
         [DVB_PLL_PHILIPS_SD1878_TDA8261] = &dvb_pll_philips_sd1878_tda8261,
-        [DVB_PLL_PHILIPS_TD1316]         = &dvb_pll_philips_td1316,
-        [DVB_PLL_THOMSON_FE6600]         = &dvb_pll_thomson_fe6600,
         [DVB_PLL_OPERA1]                 = &dvb_pll_opera1,
-        [DVB_PLL_FCV1236D]               = &dvb_pll_fcv1236d,
 };
 
 /* ----------------------------------------------------------- */
@@ -849,20 +605,6 @@ struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
                        id[priv->nr] == pll_desc_id ?
                                 "insmod option" : "autodetected");
         }
-        if ((debug) || (input[priv->nr] > 0)) {
-                printk("dvb-pll[%d]", priv->nr);
-                if (i2c != NULL)
-                        printk(" %d-%04x", i2c_adapter_id(i2c), pll_addr);
-                printk(": tuner rf input will be ");
-                switch (input[priv->nr]) {
-                case 0:
-                        printk("autoselected\n");
-                        break;
-                default:
-                        printk("set to input %d (insmod option)\n",
-                               input[priv->nr]);
-                }
-        }
 
         return fe;
 }
diff --git a/drivers/media/dvb/frontends/dvb-pll.h b/drivers/media/dvb/frontends/dvb-pll.h
index e93a8104052b..872ca29e7cf3 100644
--- a/drivers/media/dvb/frontends/dvb-pll.h
+++ b/drivers/media/dvb/frontends/dvb-pll.h
@@ -11,26 +11,17 @@
 #define DVB_PLL_UNDEFINED               0
 #define DVB_PLL_THOMSON_DTT7579         1
 #define DVB_PLL_THOMSON_DTT759X         2
-#define DVB_PLL_THOMSON_DTT7610         3
-#define DVB_PLL_LG_Z201                 4
-#define DVB_PLL_MICROTUNE_4042          5
-#define DVB_PLL_THOMSON_DTT761X         6
-#define DVB_PLL_UNKNOWN_1               7
-#define DVB_PLL_TUA6010XS               8
-#define DVB_PLL_ENV57H1XD5              9
-#define DVB_PLL_TUA6034                10
-#define DVB_PLL_LG_TDVS_H06XF          11
-#define DVB_PLL_TDA665X                12
-#define DVB_PLL_FMD1216ME              13
-#define DVB_PLL_TDED4                  14
-#define DVB_PLL_TUV1236D               15
-#define DVB_PLL_TDHU2                  16
-#define DVB_PLL_SAMSUNG_TBMV           17
-#define DVB_PLL_PHILIPS_SD1878_TDA8261 18
-#define DVB_PLL_PHILIPS_TD1316         19
-#define DVB_PLL_THOMSON_FE6600         20
-#define DVB_PLL_OPERA1                 21
-#define DVB_PLL_FCV1236D               22
+#define DVB_PLL_LG_Z201                 3
+#define DVB_PLL_UNKNOWN_1               4
+#define DVB_PLL_TUA6010XS               5
+#define DVB_PLL_ENV57H1XD5              6
+#define DVB_PLL_TUA6034                 7
+#define DVB_PLL_TDA665X                 8
+#define DVB_PLL_TDED4                   9
+#define DVB_PLL_TDHU2                  10
+#define DVB_PLL_SAMSUNG_TBMV           11
+#define DVB_PLL_PHILIPS_SD1878_TDA8261 12
+#define DVB_PLL_OPERA1                 13
 
 /**
  * Attach a dvb-pll to the supplied frontend structure.
@@ -52,7 +43,7 @@ static inline struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe,
                                            struct i2c_adapter *i2c,
                                            unsigned int pll_desc_id)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif
diff --git a/drivers/media/dvb/frontends/isl6405.c b/drivers/media/dvb/frontends/isl6405.c
new file mode 100644
index 000000000000..33d33f4d8867
--- /dev/null
+++ b/drivers/media/dvb/frontends/isl6405.c
@@ -0,0 +1,164 @@
+/*
+ * isl6405.c - driver for dual lnb supply and control ic ISL6405
+ *
+ * Copyright (C) 2008 Hartmut Hackmann
+ * Copyright (C) 2006 Oliver Endriss
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
+ *
+ *
+ * the project's page is at http://www.linuxtv.org
+ */
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
+#include "dvb_frontend.h"
+#include "isl6405.h"
+
+struct isl6405 {
+        u8                      config;
+        u8                      override_or;
+        u8                      override_and;
+        struct i2c_adapter      *i2c;
+        u8                      i2c_addr;
+};
+
+static int isl6405_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+        struct isl6405 *isl6405 = (struct isl6405 *) fe->sec_priv;
+        struct i2c_msg msg = {  .addr = isl6405->i2c_addr, .flags = 0,
+                                .buf = &isl6405->config,
+                                .len = sizeof(isl6405->config) };
+
+        if (isl6405->override_or & 0x80) {
+                isl6405->config &= ~(ISL6405_VSEL2 | ISL6405_EN2);
+                switch (voltage) {
+                case SEC_VOLTAGE_OFF:
+                        break;
+                case SEC_VOLTAGE_13:
+                        isl6405->config |= ISL6405_EN2;
+                        break;
+                case SEC_VOLTAGE_18:
+                        isl6405->config |= (ISL6405_EN2 | ISL6405_VSEL2);
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        } else {
+                isl6405->config &= ~(ISL6405_VSEL1 | ISL6405_EN1);
+                switch (voltage) {
+                case SEC_VOLTAGE_OFF:
+                        break;
+                case SEC_VOLTAGE_13:
+                        isl6405->config |= ISL6405_EN1;
+                        break;
+                case SEC_VOLTAGE_18:
+                        isl6405->config |= (ISL6405_EN1 | ISL6405_VSEL1);
+                        break;
+                default:
+                        return -EINVAL;
+                };
+        }
+        isl6405->config |= isl6405->override_or;
+        isl6405->config &= isl6405->override_and;
+
+        return (i2c_transfer(isl6405->i2c, &msg, 1) == 1) ? 0 : -EIO;
+}
+
+static int isl6405_enable_high_lnb_voltage(struct dvb_frontend *fe, long arg)
+{
+        struct isl6405 *isl6405 = (struct isl6405 *) fe->sec_priv;
+        struct i2c_msg msg = {  .addr = isl6405->i2c_addr, .flags = 0,
+                                .buf = &isl6405->config,
+                                .len = sizeof(isl6405->config) };
+
+        if (isl6405->override_or & 0x80) {
+                if (arg)
+                        isl6405->config |= ISL6405_LLC2;
+                else
+                        isl6405->config &= ~ISL6405_LLC2;
+        } else {
+                if (arg)
+                        isl6405->config |= ISL6405_LLC1;
+                else
+                        isl6405->config &= ~ISL6405_LLC1;
+        }
+        isl6405->config |= isl6405->override_or;
+        isl6405->config &= isl6405->override_and;
+
+        return (i2c_transfer(isl6405->i2c, &msg, 1) == 1) ? 0 : -EIO;
+}
+
+static void isl6405_release(struct dvb_frontend *fe)
+{
+        /* power off */
+        isl6405_set_voltage(fe, SEC_VOLTAGE_OFF);
+
+        /* free */
+        kfree(fe->sec_priv);
+        fe->sec_priv = NULL;
+}
+
+struct dvb_frontend *isl6405_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c,
+                                    u8 i2c_addr, u8 override_set, u8 override_clear)
+{
+        struct isl6405 *isl6405 = kmalloc(sizeof(struct isl6405), GFP_KERNEL);
+        if (!isl6405)
+                return NULL;
+
+        /* default configuration */
+        if (override_set & 0x80)
+                isl6405->config = ISL6405_ISEL2;
+        else
+                isl6405->config = ISL6405_ISEL1;
+        isl6405->i2c = i2c;
+        isl6405->i2c_addr = i2c_addr;
+        fe->sec_priv = isl6405;
+
+        /* bits which should be forced to '1' */
+        isl6405->override_or = override_set;
+
+        /* bits which should be forced to '0' */
+        isl6405->override_and = ~override_clear;
+
+        /* detect if it is present or not */
+        if (isl6405_set_voltage(fe, SEC_VOLTAGE_OFF)) {
+                kfree(isl6405);
+                fe->sec_priv = NULL;
+                return NULL;
+        }
+
+        /* install release callback */
+        fe->ops.release_sec = isl6405_release;
+
+        /* override frontend ops */
+        fe->ops.set_voltage = isl6405_set_voltage;
+        fe->ops.enable_high_lnb_voltage = isl6405_enable_high_lnb_voltage;
+
+        return fe;
+}
+EXPORT_SYMBOL(isl6405_attach);
+
+MODULE_DESCRIPTION("Driver for lnb supply and control ic isl6405");
+MODULE_AUTHOR("Hartmut Hackmann & Oliver Endriss");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/isl6405.h b/drivers/media/dvb/frontends/isl6405.h
new file mode 100644
index 000000000000..1c793d37576b
--- /dev/null
+++ b/drivers/media/dvb/frontends/isl6405.h
@@ -0,0 +1,74 @@
+/*
+ * isl6405.h - driver for dual lnb supply and control ic ISL6405
+ *
+ * Copyright (C) 2008 Hartmut Hackmann
+ * Copyright (C) 2006 Oliver Endriss
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
+ *
+ *
+ * the project's page is at http://www.linuxtv.org
+ */
+
+#ifndef _ISL6405_H
+#define _ISL6405_H
+
+#include <linux/dvb/frontend.h>
+
+/* system register bits */
+
+/* this bit selects register (control) 1 or 2
+   note that the bit maps are different */
+
+#define ISL6405_SR      0x80
+
+/* SR = 0 */
+#define ISL6405_OLF1    0x01
+#define ISL6405_EN1     0x02
+#define ISL6405_VSEL1   0x04
+#define ISL6405_LLC1    0x08
+#define ISL6405_ENT1    0x10
+#define ISL6405_ISEL1   0x20
+#define ISL6405_DCL     0x40
+
+/* SR = 1 */
+#define ISL6405_OLF2    0x01
+#define ISL6405_OTF     0x02
+#define ISL6405_EN2     0x04
+#define ISL6405_VSEL2   0x08
+#define ISL6405_LLC2    0x10
+#define ISL6405_ENT2    0x20
+#define ISL6405_ISEL2   0x40
+
+#if defined(CONFIG_DVB_ISL6405) || (defined(CONFIG_DVB_ISL6405_MODULE) && defined(MODULE))
+/* override_set and override_clear control which system register bits (above)
+ * to always set & clear
+ */
+extern struct dvb_frontend *isl6405_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c,
+                                           u8 i2c_addr, u8 override_set, u8 override_clear);
+#else
+static inline struct dvb_frontend *isl6405_attach(struct dvb_frontend *fe,
+                                                  struct i2c_adapter *i2c, u8 i2c_addr,
+                                                  u8 override_set, u8 override_clear)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+#endif /* CONFIG_DVB_ISL6405 */
+
+#endif
diff --git a/drivers/media/dvb/frontends/isl6421.h b/drivers/media/dvb/frontends/isl6421.h
index ea7f78a7d3cd..47e4518a042d 100644
--- a/drivers/media/dvb/frontends/isl6421.h
+++ b/drivers/media/dvb/frontends/isl6421.h
@@ -47,7 +47,7 @@ extern struct dvb_frontend *isl6421_attach(struct dvb_frontend *fe, struct i2c_a
 static inline struct dvb_frontend *isl6421_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, u8 i2c_addr,
                                                   u8 override_set, u8 override_clear)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_ISL6421
diff --git a/drivers/media/dvb/frontends/itd1000.c b/drivers/media/dvb/frontends/itd1000.c
new file mode 100644
index 000000000000..04c562ccf990
--- /dev/null
+++ b/drivers/media/dvb/frontends/itd1000.c
@@ -0,0 +1,400 @@
+/*
+ *  Driver for the Integrant ITD1000 "Zero-IF Tuner IC for Direct Broadcast Satellite"
+ *
+ *  Copyright (c) 2007-8 Patrick Boettcher <pb@linuxtv.org>
+ *
+ *  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/module.h>
+#include <linux/moduleparam.h>
+#include <linux/delay.h>
+#include <linux/dvb/frontend.h>
+#include <linux/i2c.h>
+
+#include "dvb_frontend.h"
+
+#include "itd1000.h"
+#include "itd1000_priv.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
+
+#define deb(args...)  do { \
+        if (debug) { \
+                printk(KERN_DEBUG   "ITD1000: " args);\
+                printk("\n"); \
+        } \
+} while (0)
+
+#define warn(args...) do { \
+        printk(KERN_WARNING "ITD1000: " args); \
+        printk("\n"); \
+} while (0)
+
+#define info(args...) do { \
+        printk(KERN_INFO    "ITD1000: " args); \
+        printk("\n"); \
+} while (0)
+
+/* don't write more than one byte with flexcop behind */
+static int itd1000_write_regs(struct itd1000_state *state, u8 reg, u8 v[], u8 len)
+{
+        u8 buf[1+len];
+        struct i2c_msg msg = {
+                .addr = state->cfg->i2c_address, .flags = 0, .buf = buf, .len = len+1
+        };
+        buf[0] = reg;
+        memcpy(&buf[1], v, len);
+
+        /* deb("wr %02x: %02x", reg, v[0]); */
+
+        if (i2c_transfer(state->i2c, &msg, 1) != 1) {
+                printk(KERN_WARNING "itd1000 I2C write failed\n");
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+static int itd1000_read_reg(struct itd1000_state *state, u8 reg)
+{
+        u8 val;
+        struct i2c_msg msg[2] = {
+                { .addr = state->cfg->i2c_address, .flags = 0,        .buf = &reg, .len = 1 },
+                { .addr = state->cfg->i2c_address, .flags = I2C_M_RD, .buf = &val, .len = 1 },
+        };
+
+        /* ugly flexcop workaround */
+        itd1000_write_regs(state, (reg - 1) & 0xff, &state->shadow[(reg - 1) & 0xff], 1);
+
+        if (i2c_transfer(state->i2c, msg, 2) != 2) {
+                warn("itd1000 I2C read failed");
+                return -EREMOTEIO;
+        }
+        return val;
+}
+
+static inline int itd1000_write_reg(struct itd1000_state *state, u8 r, u8 v)
+{
+        int ret = itd1000_write_regs(state, r, &v, 1);
+        state->shadow[r] = v;
+        return ret;
+}
+
+
+static struct {
+        u32 symbol_rate;
+        u8  pgaext  : 4; /* PLLFH */
+        u8  bbgvmin : 4; /* BBGVMIN */
+} itd1000_lpf_pga[] = {
+        {        0, 0x8, 0x3 },
+        {  5200000, 0x8, 0x3 },
+        { 12200000, 0x4, 0x3 },
+        { 15400000, 0x2, 0x3 },
+        { 19800000, 0x2, 0x3 },
+        { 21500000, 0x2, 0x3 },
+        { 24500000, 0x2, 0x3 },
+        { 28400000, 0x2, 0x3 },
+        { 33400000, 0x2, 0x3 },
+        { 34400000, 0x1, 0x4 },
+        { 34400000, 0x1, 0x4 },
+        { 38400000, 0x1, 0x4 },
+        { 38400000, 0x1, 0x4 },
+        { 40400000, 0x1, 0x4 },
+        { 45400000, 0x1, 0x4 },
+};
+
+static void itd1000_set_lpf_bw(struct itd1000_state *state, u32 symbol_rate)
+{
+        u8 i;
+        u8 con1    = itd1000_read_reg(state, CON1)    & 0xfd;
+        u8 pllfh   = itd1000_read_reg(state, PLLFH)   & 0x0f;
+        u8 bbgvmin = itd1000_read_reg(state, BBGVMIN) & 0xf0;
+        u8 bw      = itd1000_read_reg(state, BW)      & 0xf0;
+
+        deb("symbol_rate = %d", symbol_rate);
+
+        /* not sure what is that ? - starting to download the table */
+        itd1000_write_reg(state, CON1, con1 | (1 << 1));
+
+        for (i = 0; i < ARRAY_SIZE(itd1000_lpf_pga); i++)
+                if (symbol_rate < itd1000_lpf_pga[i].symbol_rate) {
+                        deb("symrate: index: %d pgaext: %x, bbgvmin: %x", i, itd1000_lpf_pga[i].pgaext, itd1000_lpf_pga[i].bbgvmin);
+                        itd1000_write_reg(state, PLLFH,   pllfh | (itd1000_lpf_pga[i].pgaext << 4));
+                        itd1000_write_reg(state, BBGVMIN, bbgvmin | (itd1000_lpf_pga[i].bbgvmin));
+                        itd1000_write_reg(state, BW,      bw | (i & 0x0f));
+                        break;
+                }
+
+        itd1000_write_reg(state, CON1, con1 | (0 << 1));
+}
+
+static struct {
+        u8 vcorg;
+        u32 fmax_rg;
+} itd1000_vcorg[] = {
+        {  1,  920000 },
+        {  2,  971000 },
+        {  3, 1031000 },
+        {  4, 1091000 },
+        {  5, 1171000 },
+        {  6, 1281000 },
+        {  7, 1381000 },
+        {  8,  500000 },        /* this is intentional. */
+        {  9, 1451000 },
+        { 10, 1531000 },
+        { 11, 1631000 },
+        { 12, 1741000 },
+        { 13, 1891000 },
+        { 14, 2071000 },
+        { 15, 2250000 },
+};
+
+static void itd1000_set_vco(struct itd1000_state *state, u32 freq_khz)
+{
+        u8 i;
+        u8 gvbb_i2c     = itd1000_read_reg(state, GVBB_I2C) & 0xbf;
+        u8 vco_chp1_i2c = itd1000_read_reg(state, VCO_CHP1_I2C) & 0x0f;
+        u8 adcout;
+
+        /* reserved bit again (reset ?) */
+        itd1000_write_reg(state, GVBB_I2C, gvbb_i2c | (1 << 6));
+
+        for (i = 0; i < ARRAY_SIZE(itd1000_vcorg); i++) {
+                if (freq_khz < itd1000_vcorg[i].fmax_rg) {
+                        itd1000_write_reg(state, VCO_CHP1_I2C, vco_chp1_i2c | (itd1000_vcorg[i].vcorg << 4));
+                        msleep(1);
+
+                        adcout = itd1000_read_reg(state, PLLLOCK) & 0x0f;
+
+                        deb("VCO: %dkHz: %d -> ADCOUT: %d %02x", freq_khz, itd1000_vcorg[i].vcorg, adcout, vco_chp1_i2c);
+
+                        if (adcout > 13) {
+                                if (!(itd1000_vcorg[i].vcorg == 7 || itd1000_vcorg[i].vcorg == 15))
+                                        itd1000_write_reg(state, VCO_CHP1_I2C, vco_chp1_i2c | ((itd1000_vcorg[i].vcorg + 1) << 4));
+                        } else if (adcout < 2) {
+                                if (!(itd1000_vcorg[i].vcorg == 1 || itd1000_vcorg[i].vcorg == 9))
+                                        itd1000_write_reg(state, VCO_CHP1_I2C, vco_chp1_i2c | ((itd1000_vcorg[i].vcorg - 1) << 4));
+                        }
+                        break;
+                }
+        }
+}
+
+struct {
+        u32 freq;
+        u8 values[10]; /* RFTR, RFST1 - RFST9 */
+} itd1000_fre_values[] = {
+        { 1075000, { 0x59, 0x1d, 0x1c, 0x17, 0x16, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a } },
+        { 1250000, { 0x89, 0x1e, 0x1d, 0x17, 0x15, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a } },
+        { 1450000, { 0x89, 0x1e, 0x1d, 0x17, 0x15, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a } },
+        { 1650000, { 0x69, 0x1e, 0x1d, 0x17, 0x15, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a } },
+        { 1750000, { 0x69, 0x1e, 0x17, 0x15, 0x14, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a } },
+        { 1850000, { 0x69, 0x1d, 0x17, 0x16, 0x14, 0x0f, 0x0e, 0x0d, 0x0b, 0x0a } },
+        { 1900000, { 0x69, 0x1d, 0x17, 0x15, 0x14, 0x0f, 0x0e, 0x0d, 0x0b, 0x0a } },
+        { 1950000, { 0x69, 0x1d, 0x17, 0x16, 0x14, 0x13, 0x0e, 0x0d, 0x0b, 0x0a } },
+        { 2050000, { 0x69, 0x1e, 0x1d, 0x17, 0x16, 0x14, 0x13, 0x0e, 0x0b, 0x0a } },
+        { 2150000, { 0x69, 0x1d, 0x1c, 0x17, 0x15, 0x14, 0x13, 0x0f, 0x0e, 0x0b } }
+};
+
+
+#define FREF 16
+
+static void itd1000_set_lo(struct itd1000_state *state, u32 freq_khz)
+{
+        int i, j;
+        u32 plln, pllf;
+        u64 tmp;
+
+        plln = (freq_khz * 1000) / 2 / FREF;
+
+        /* Compute the factional part times 1000 */
+        tmp  = plln % 1000000;
+        plln /= 1000000;
+
+        tmp *= 1048576;
+        do_div(tmp, 1000000);
+        pllf = (u32) tmp;
+
+        state->frequency = ((plln * 1000) + (pllf * 1000)/1048576) * 2*FREF;
+        deb("frequency: %dkHz (wanted) %dkHz (set), PLLF = %d, PLLN = %d", freq_khz, state->frequency, pllf, plln);
+
+        itd1000_write_reg(state, PLLNH, 0x80); /* PLLNH */;
+        itd1000_write_reg(state, PLLNL, plln & 0xff);
+        itd1000_write_reg(state, PLLFH, (itd1000_read_reg(state, PLLFH) & 0xf0) | ((pllf >> 16) & 0x0f));
+        itd1000_write_reg(state, PLLFM, (pllf >> 8) & 0xff);
+        itd1000_write_reg(state, PLLFL, (pllf >> 0) & 0xff);
+
+        for (i = 0; i < ARRAY_SIZE(itd1000_fre_values); i++) {
+                if (freq_khz <= itd1000_fre_values[i].freq) {
+                        deb("fre_values: %d", i);
+                        itd1000_write_reg(state, RFTR, itd1000_fre_values[i].values[0]);
+                        for (j = 0; j < 9; j++)
+                                itd1000_write_reg(state, RFST1+j, itd1000_fre_values[i].values[j+1]);
+                        break;
+                }
+        }
+
+        itd1000_set_vco(state, freq_khz);
+}
+
+static int itd1000_set_parameters(struct dvb_frontend *fe, struct dvb_frontend_parameters *p)
+{
+        struct itd1000_state *state = fe->tuner_priv;
+        u8 pllcon1;
+
+        itd1000_set_lo(state, p->frequency);
+        itd1000_set_lpf_bw(state, p->u.qpsk.symbol_rate);
+
+        pllcon1 = itd1000_read_reg(state, PLLCON1) & 0x7f;
+        itd1000_write_reg(state, PLLCON1, pllcon1 | (1 << 7));
+        itd1000_write_reg(state, PLLCON1, pllcon1);
+
+        return 0;
+}
+
+static int itd1000_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+        struct itd1000_state *state = fe->tuner_priv;
+        *frequency = state->frequency;
+        return 0;
+}
+
+static int itd1000_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
+{
+        return 0;
+}
+
+static u8 itd1000_init_tab[][2] = {
+        { PLLCON1,       0x65 }, /* Register does not change */
+        { PLLNH,         0x80 }, /* Bits [7:6] do not change */
+        { RESERVED_0X6D, 0x3b },
+        { VCO_CHP2_I2C,  0x12 },
+        { 0x72,          0xf9 }, /* No such regsister defined */
+        { RESERVED_0X73, 0xff },
+        { RESERVED_0X74, 0xb2 },
+        { RESERVED_0X75, 0xc7 },
+        { EXTGVBBRF,     0xf0 },
+        { DIVAGCCK,      0x80 },
+        { BBTR,          0xa0 },
+        { RESERVED_0X7E, 0x4f },
+        { 0x82,          0x88 }, /* No such regsister defined */
+        { 0x83,          0x80 }, /* No such regsister defined */
+        { 0x84,          0x80 }, /* No such regsister defined */
+        { RESERVED_0X85, 0x74 },
+        { RESERVED_0X86, 0xff },
+        { RESERVED_0X88, 0x02 },
+        { RESERVED_0X89, 0x16 },
+        { RFST0,         0x1f },
+        { RESERVED_0X94, 0x66 },
+        { RESERVED_0X95, 0x66 },
+        { RESERVED_0X96, 0x77 },
+        { RESERVED_0X97, 0x99 },
+        { RESERVED_0X98, 0xff },
+        { RESERVED_0X99, 0xfc },
+        { RESERVED_0X9A, 0xba },
+        { RESERVED_0X9B, 0xaa },
+};
+
+static u8 itd1000_reinit_tab[][2] = {
+        { VCO_CHP1_I2C, 0x8a },
+        { BW,           0x87 },
+        { GVBB_I2C,     0x03 },
+        { BBGVMIN,      0x03 },
+        { CON1,         0x2e },
+};
+
+
+static int itd1000_init(struct dvb_frontend *fe)
+{
+        struct itd1000_state *state = fe->tuner_priv;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(itd1000_init_tab); i++)
+                itd1000_write_reg(state, itd1000_init_tab[i][0], itd1000_init_tab[i][1]);
+
+        for (i = 0; i < ARRAY_SIZE(itd1000_reinit_tab); i++)
+                itd1000_write_reg(state, itd1000_reinit_tab[i][0], itd1000_reinit_tab[i][1]);
+
+        return 0;
+}
+
+static int itd1000_sleep(struct dvb_frontend *fe)
+{
+        return 0;
+}
+
+static int itd1000_release(struct dvb_frontend *fe)
+{
+        kfree(fe->tuner_priv);
+        fe->tuner_priv = NULL;
+        return 0;
+}
+
+static const struct dvb_tuner_ops itd1000_tuner_ops = {
+        .info = {
+                .name           = "Integrant ITD1000",
+                .frequency_min  = 950000,
+                .frequency_max  = 2150000,
+                .frequency_step = 125,     /* kHz for QPSK frontends */
+        },
+
+        .release       = itd1000_release,
+
+        .init          = itd1000_init,
+        .sleep         = itd1000_sleep,
+
+        .set_params    = itd1000_set_parameters,
+        .get_frequency = itd1000_get_frequency,
+        .get_bandwidth = itd1000_get_bandwidth
+};
+
+
+struct dvb_frontend *itd1000_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct itd1000_config *cfg)
+{
+        struct itd1000_state *state = NULL;
+        u8 i = 0;
+
+        state = kzalloc(sizeof(struct itd1000_state), GFP_KERNEL);
+        if (state == NULL)
+                return NULL;
+
+        state->cfg = cfg;
+        state->i2c = i2c;
+
+        i = itd1000_read_reg(state, 0);
+        if (i != 0) {
+                kfree(state);
+                return NULL;
+        }
+        info("successfully identified (ID: %d)", i);
+
+        memset(state->shadow, 0xff, sizeof(state->shadow));
+        for (i = 0x65; i < 0x9c; i++)
+                state->shadow[i] = itd1000_read_reg(state, i);
+
+        memcpy(&fe->ops.tuner_ops, &itd1000_tuner_ops, sizeof(struct dvb_tuner_ops));
+
+        fe->tuner_priv = state;
+
+        return fe;
+}
+EXPORT_SYMBOL(itd1000_attach);
+
+MODULE_AUTHOR("Patrick Boettcher <pb@linuxtv.org>");
+MODULE_DESCRIPTION("Integrant ITD1000 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/itd1000.h b/drivers/media/dvb/frontends/itd1000.h
new file mode 100644
index 000000000000..5e18df071b88
--- /dev/null
+++ b/drivers/media/dvb/frontends/itd1000.h
@@ -0,0 +1,42 @@
+/*
+ *  Driver for the Integrant ITD1000 "Zero-IF Tuner IC for Direct Broadcast Satellite"
+ *
+ *  Copyright (c) 2007 Patrick Boettcher <pb@linuxtv.org>
+ *
+ *  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 ITD1000_H
+#define ITD1000_H
+
+struct dvb_frontend;
+struct i2c_adapter;
+
+struct itd1000_config {
+        u8 i2c_address;
+};
+
+#if defined(CONFIG_DVB_TUNER_ITD1000) || (defined(CONFIG_DVB_TUNER_ITD1000_MODULE) && defined(MODULE))
+extern struct dvb_frontend *itd1000_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct itd1000_config *cfg);
+#else
+static inline struct dvb_frontend *itd1000_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct itd1000_config *cfg)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+#endif
+
+#endif
diff --git a/drivers/media/dvb/frontends/itd1000_priv.h b/drivers/media/dvb/frontends/itd1000_priv.h
new file mode 100644
index 000000000000..8cdc54e57903
--- /dev/null
+++ b/drivers/media/dvb/frontends/itd1000_priv.h
@@ -0,0 +1,88 @@
+/*
+ *  Driver for the Integrant ITD1000 "Zero-IF Tuner IC for Direct Broadcast Satellite"
+ *
+ *  Copyright (c) 2007 Patrick Boettcher <pb@linuxtv.org>
+ *
+ *  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 ITD1000_PRIV_H
+#define ITD1000_PRIV_H
+
+struct itd1000_state {
+        struct itd1000_config *cfg;
+        struct i2c_adapter    *i2c;
+
+        u32 frequency; /* contains the value resulting from the LO-setting */
+
+        /* ugly workaround for flexcop's incapable i2c-controller
+         * FIXME, if possible
+         */
+        u8 shadow[255];
+};
+
+enum itd1000_register {
+        VCO_CHP1 = 0x65,
+        VCO_CHP2,
+        PLLCON1,
+        PLLNH,
+        PLLNL,
+        PLLFH,
+        PLLFM,
+        PLLFL,
+        RESERVED_0X6D,
+        PLLLOCK,
+        VCO_CHP2_I2C,
+        VCO_CHP1_I2C,
+        BW,
+        RESERVED_0X73 = 0x73,
+        RESERVED_0X74,
+        RESERVED_0X75,
+        GVBB,
+        GVRF,
+        GVBB_I2C,
+        EXTGVBBRF,
+        DIVAGCCK,
+        BBTR,
+        RFTR,
+        BBGVMIN,
+        RESERVED_0X7E,
+        RESERVED_0X85 = 0x85,
+        RESERVED_0X86,
+        CON1,
+        RESERVED_0X88,
+        RESERVED_0X89,
+        RFST0,
+        RFST1,
+        RFST2,
+        RFST3,
+        RFST4,
+        RFST5,
+        RFST6,
+        RFST7,
+        RFST8,
+        RFST9,
+        RESERVED_0X94,
+        RESERVED_0X95,
+        RESERVED_0X96,
+        RESERVED_0X97,
+        RESERVED_0X98,
+        RESERVED_0X99,
+        RESERVED_0X9A,
+        RESERVED_0X9B,
+};
+
+#endif
diff --git a/drivers/media/dvb/frontends/l64781.c b/drivers/media/dvb/frontends/l64781.c
index 443d9045d4c9..e1e70e9e0cb9 100644
--- a/drivers/media/dvb/frontends/l64781.c
+++ b/drivers/media/dvb/frontends/l64781.c
@@ -57,7 +57,7 @@ static int l64781_writereg (struct l64781_state* state, u8 reg, u8 data)
 
         if ((ret = i2c_transfer(state->i2c, &msg, 1)) != 1)
                 dprintk ("%s: write_reg error (reg == %02x) = %02x!\n",
-                         __FUNCTION__, reg, ret);
+                         __func__, reg, ret);
 
         return (ret != 1) ? -1 : 0;
 }
diff --git a/drivers/media/dvb/frontends/l64781.h b/drivers/media/dvb/frontends/l64781.h
index cd15f76ff28d..1305a9e7fb0b 100644
--- a/drivers/media/dvb/frontends/l64781.h
+++ b/drivers/media/dvb/frontends/l64781.h
@@ -38,7 +38,7 @@ extern struct dvb_frontend* l64781_attach(const struct l64781_config* config,
 static inline struct dvb_frontend* l64781_attach(const struct l64781_config* config,
                                           struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_L64781
diff --git a/drivers/media/dvb/frontends/lgdt330x.c b/drivers/media/dvb/frontends/lgdt330x.c
index bdc9fa88b86a..f0195c8272f4 100644
--- a/drivers/media/dvb/frontends/lgdt330x.c
+++ b/drivers/media/dvb/frontends/lgdt330x.c
@@ -49,7 +49,7 @@
 /* Use Equalizer Mean Squared Error instead of Phaser Tracker MSE */
 /* #define USE_EQMSE */
 
-static int debug = 0;
+static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug,"Turn on/off lgdt330x frontend debugging (default:off).");
 #define dprintk(args...) \
@@ -88,7 +88,7 @@ static int i2c_write_demod_bytes (struct lgdt330x_state* state,
 
         for (i=0; i<len-1; i+=2){
                 if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
-                        printk(KERN_WARNING "lgdt330x: %s error (addr %02x <- %02x, err = %i)\n", __FUNCTION__, msg.buf[0], msg.buf[1], err);
+                        printk(KERN_WARNING "lgdt330x: %s error (addr %02x <- %02x, err = %i)\n", __func__, msg.buf[0], msg.buf[1], err);
                         if (err < 0)
                                 return err;
                         else
@@ -117,7 +117,7 @@ static u8 i2c_read_demod_bytes (struct lgdt330x_state* state,
         int ret;
         ret = i2c_transfer(state->i2c, msg, 2);
         if (ret != 2) {
-                printk(KERN_WARNING "lgdt330x: %s: addr 0x%02x select 0x%02x error (ret == %i)\n", __FUNCTION__, state->config->demod_address, reg, ret);
+                printk(KERN_WARNING "lgdt330x: %s: addr 0x%02x select 0x%02x error (ret == %i)\n", __func__, state->config->demod_address, reg, ret);
         } else {
                 ret = 0;
         }
@@ -256,7 +256,7 @@ static int lgdt330x_init(struct dvb_frontend* fe)
                 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
                 err = -ENODEV;
         }
-        dprintk("%s entered as %s\n", __FUNCTION__, chip_name);
+        dprintk("%s entered as %s\n", __func__, chip_name);
         if (err < 0)
                 return err;
         return lgdt330x_SwReset(state);
@@ -334,7 +334,7 @@ static int lgdt330x_set_parameters(struct dvb_frontend* fe,
         if (state->current_modulation != param->u.vsb.modulation) {
                 switch(param->u.vsb.modulation) {
                 case VSB_8:
-                        dprintk("%s: VSB_8 MODE\n", __FUNCTION__);
+                        dprintk("%s: VSB_8 MODE\n", __func__);
 
                         /* Select VSB mode */
                         top_ctrl_cfg[1] = 0x03;
@@ -350,7 +350,7 @@ static int lgdt330x_set_parameters(struct dvb_frontend* fe,
                         break;
 
                 case QAM_64:
-                        dprintk("%s: QAM_64 MODE\n", __FUNCTION__);
+                        dprintk("%s: QAM_64 MODE\n", __func__);
 
                         /* Select QAM_64 mode */
                         top_ctrl_cfg[1] = 0x00;
@@ -366,7 +366,7 @@ static int lgdt330x_set_parameters(struct dvb_frontend* fe,
                         break;
 
                 case QAM_256:
-                        dprintk("%s: QAM_256 MODE\n", __FUNCTION__);
+                        dprintk("%s: QAM_256 MODE\n", __func__);
 
                         /* Select QAM_256 mode */
                         top_ctrl_cfg[1] = 0x01;
@@ -381,7 +381,7 @@ static int lgdt330x_set_parameters(struct dvb_frontend* fe,
                         }
                         break;
                 default:
-                        printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __FUNCTION__, param->u.vsb.modulation);
+                        printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __func__, param->u.vsb.modulation);
                         return -1;
                 }
                 /*
@@ -431,7 +431,7 @@ static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
 
         /* AGC status register */
         i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
-        dprintk("%s: AGC_STATUS = 0x%02x\n", __FUNCTION__, buf[0]);
+        dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
         if ((buf[0] & 0x0c) == 0x8){
                 /* Test signal does not exist flag */
                 /* as well as the AGC lock flag.   */
@@ -445,7 +445,7 @@ static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
          */
         /* signal status */
         i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
-        dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __FUNCTION__, buf[0], buf[1], buf[2]);
+        dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __func__, buf[0], buf[1], buf[2]);
 
 
         /* sync status */
@@ -461,7 +461,7 @@ static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
 
         /* Carrier Recovery Lock Status Register */
         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
-        dprintk("%s: CARRIER_LOCK = 0x%02x\n", __FUNCTION__, buf[0]);
+        dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
         switch (state->current_modulation) {
         case QAM_256:
         case QAM_64:
@@ -474,7 +474,7 @@ static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
                         *status |= FE_HAS_CARRIER;
                 break;
         default:
-                printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __FUNCTION__);
+                printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
         }
 
         return 0;
@@ -493,7 +493,7 @@ static int lgdt3303_read_status(struct dvb_frontend* fe, fe_status_t* status)
         if (err < 0)
                 return err;
 
-        dprintk("%s: AGC_STATUS = 0x%02x\n", __FUNCTION__, buf[0]);
+        dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
         if ((buf[0] & 0x21) == 0x01){
                 /* Test input signal does not exist flag */
                 /* as well as the AGC lock flag.   */
@@ -502,7 +502,7 @@ static int lgdt3303_read_status(struct dvb_frontend* fe, fe_status_t* status)
 
         /* Carrier Recovery Lock Status Register */
         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
-        dprintk("%s: CARRIER_LOCK = 0x%02x\n", __FUNCTION__, buf[0]);
+        dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
         switch (state->current_modulation) {
         case QAM_256:
         case QAM_64:
@@ -533,7 +533,7 @@ static int lgdt3303_read_status(struct dvb_frontend* fe, fe_status_t* status)
                 }
                 break;
         default:
-                printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __FUNCTION__);
+                printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
         }
         return 0;
 }
@@ -607,14 +607,14 @@ static int lgdt3302_read_snr(struct dvb_frontend* fe, u16* snr)
                 break;
         default:
                 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
-                       __FUNCTION__);
+                       __func__);
                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
         }
 
         state->snr = calculate_snr(noise, c);
         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
 
-        dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __FUNCTION__, noise,
+        dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
                 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
 
         return 0;
@@ -651,14 +651,14 @@ static int lgdt3303_read_snr(struct dvb_frontend* fe, u16* snr)
                 break;
         default:
                 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
-                       __FUNCTION__);
+                       __func__);
                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
         }
 
         state->snr = calculate_snr(noise, c);
         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
 
-        dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __FUNCTION__, noise,
+        dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
                 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
 
         return 0;
@@ -743,7 +743,7 @@ struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
 
 error:
         kfree(state);
-        dprintk("%s: ERROR\n",__FUNCTION__);
+        dprintk("%s: ERROR\n",__func__);
         return NULL;
 }
 
diff --git a/drivers/media/dvb/frontends/lgdt330x.h b/drivers/media/dvb/frontends/lgdt330x.h
index 995059004b10..9012504f0f2d 100644
--- a/drivers/media/dvb/frontends/lgdt330x.h
+++ b/drivers/media/dvb/frontends/lgdt330x.h
@@ -59,7 +59,7 @@ extern struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config
 static inline struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
                                             struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_LGDT330X
diff --git a/drivers/media/dvb/frontends/lnbp21.h b/drivers/media/dvb/frontends/lnbp21.h
index 68906acf7d63..8fe094bd9689 100644
--- a/drivers/media/dvb/frontends/lnbp21.h
+++ b/drivers/media/dvb/frontends/lnbp21.h
@@ -45,7 +45,7 @@ extern struct dvb_frontend *lnbp21_attach(struct dvb_frontend *fe, struct i2c_ad
 #else
 static inline struct dvb_frontend *lnbp21_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, u8 override_set, u8 override_clear)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_LNBP21
diff --git a/drivers/media/dvb/frontends/mt2060.h b/drivers/media/dvb/frontends/mt2060.h
index 0a86eab3a954..acba0058f519 100644
--- a/drivers/media/dvb/frontends/mt2060.h
+++ b/drivers/media/dvb/frontends/mt2060.h
@@ -35,7 +35,7 @@ extern struct dvb_frontend * mt2060_attach(struct dvb_frontend *fe, struct i2c_a
 #else
 static inline struct dvb_frontend * mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TUNER_MT2060
diff --git a/drivers/media/dvb/frontends/mt2131.c b/drivers/media/dvb/frontends/mt2131.c
index 13cf16668171..e254bcfc2efb 100644
--- a/drivers/media/dvb/frontends/mt2131.c
+++ b/drivers/media/dvb/frontends/mt2131.c
@@ -110,7 +110,7 @@ static int mt2131_set_params(struct dvb_frontend *fe,
                 priv->bandwidth = 0;
 
         freq = params->frequency / 1000;  // Hz -> kHz
-        dprintk(1, "%s() freq=%d\n", __FUNCTION__, freq);
+        dprintk(1, "%s() freq=%d\n", __func__, freq);
 
         f_lo1 = freq + MT2131_IF1 * 1000;
         f_lo1 = (f_lo1 / 250) * 250;
@@ -187,7 +187,7 @@ static int mt2131_set_params(struct dvb_frontend *fe,
 static int mt2131_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 {
         struct mt2131_priv *priv = fe->tuner_priv;
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
         *frequency = priv->frequency;
         return 0;
 }
@@ -195,7 +195,7 @@ static int mt2131_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 static int mt2131_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 {
         struct mt2131_priv *priv = fe->tuner_priv;
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
         *bandwidth = priv->bandwidth;
         return 0;
 }
@@ -214,7 +214,7 @@ static int mt2131_get_status(struct dvb_frontend *fe, u32 *status)
 
         mt2131_readreg(priv, 0x09, &afc_status);
         dprintk(1, "%s() - LO Status = 0x%x, AFC Status = 0x%x\n",
-                __FUNCTION__, lock_status, afc_status);
+                __func__, lock_status, afc_status);
 
         return 0;
 }
@@ -223,7 +223,7 @@ static int mt2131_init(struct dvb_frontend *fe)
 {
         struct mt2131_priv *priv = fe->tuner_priv;
         int ret;
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         if ((ret = mt2131_writeregs(priv, mt2131_config1,
                                     sizeof(mt2131_config1))) < 0)
@@ -243,7 +243,7 @@ static int mt2131_init(struct dvb_frontend *fe)
 
 static int mt2131_release(struct dvb_frontend *fe)
 {
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
         kfree(fe->tuner_priv);
         fe->tuner_priv = NULL;
         return 0;
@@ -273,7 +273,7 @@ struct dvb_frontend * mt2131_attach(struct dvb_frontend *fe,
         struct mt2131_priv *priv = NULL;
         u8 id = 0;
 
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         priv = kzalloc(sizeof(struct mt2131_priv), GFP_KERNEL);
         if (priv == NULL)
diff --git a/drivers/media/dvb/frontends/mt2131.h b/drivers/media/dvb/frontends/mt2131.h
index 1e4ffe7dc8c8..606d8576bc98 100644
--- a/drivers/media/dvb/frontends/mt2131.h
+++ b/drivers/media/dvb/frontends/mt2131.h
@@ -41,7 +41,7 @@ static inline struct dvb_frontend* mt2131_attach(struct dvb_frontend *fe,
                                                  struct mt2131_config *cfg,
                                                  u16 if1)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif /* CONFIG_DVB_TUNER_MT2131 */
diff --git a/drivers/media/dvb/frontends/mt2266.h b/drivers/media/dvb/frontends/mt2266.h
index f31dd613ad37..c5113efe333c 100644
--- a/drivers/media/dvb/frontends/mt2266.h
+++ b/drivers/media/dvb/frontends/mt2266.h
@@ -29,7 +29,7 @@ extern struct dvb_frontend * mt2266_attach(struct dvb_frontend *fe, struct i2c_a
 #else
 static inline struct dvb_frontend * mt2266_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2266_config *cfg)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TUNER_MT2266
diff --git a/drivers/media/dvb/frontends/mt312.c b/drivers/media/dvb/frontends/mt312.c
index 1638301fbd6e..081ca3398c76 100644
--- a/drivers/media/dvb/frontends/mt312.c
+++ b/drivers/media/dvb/frontends/mt312.c
@@ -1,7 +1,8 @@
 /*
-    Driver for Zarlink VP310/MT312 Satellite Channel Decoder
+    Driver for Zarlink VP310/MT312/ZL10313 Satellite Channel Decoder
 
     Copyright (C) 2003 Andreas Oberritter <obi@linuxtv.org>
+    Copyright (C) 2008 Matthias Schwarzott <zzam@gentoo.org>
 
     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
@@ -43,7 +44,8 @@ struct mt312_state {
         struct dvb_frontend frontend;
 
         u8 id;
-        u8 frequency;
+        unsigned long xtal;
+        u8 freq_mult;
 };
 
 static int debug;
@@ -53,12 +55,11 @@ static int debug;
                         printk(KERN_DEBUG "mt312: " args); \
         } while (0)
 
-#define MT312_SYS_CLK           90000000UL      /* 90 MHz */
-#define MT312_LPOWER_SYS_CLK    60000000UL      /* 60 MHz */
 #define MT312_PLL_CLK           10000000UL      /* 10 MHz */
+#define MT312_PLL_CLK_10_111    10111000UL      /* 10.111 MHz */
 
 static int mt312_read(struct mt312_state *state, const enum mt312_reg_addr reg,
-                      void *buf, const size_t count)
+                      u8 *buf, const size_t count)
 {
         int ret;
         struct i2c_msg msg[2];
@@ -76,7 +77,7 @@ static int mt312_read(struct mt312_state *state, const enum mt312_reg_addr reg,
         ret = i2c_transfer(state->i2c, msg, 2);
 
         if (ret != 2) {
-                printk(KERN_ERR "%s: ret == %d\n", __FUNCTION__, ret);
+                printk(KERN_ERR "%s: ret == %d\n", __func__, ret);
                 return -EREMOTEIO;
         }
 
@@ -84,7 +85,7 @@ static int mt312_read(struct mt312_state *state, const enum mt312_reg_addr reg,
                 int i;
                 dprintk("R(%d):", reg & 0x7f);
                 for (i = 0; i < count; i++)
-                        printk(" %02x", ((const u8 *) buf)[i]);
+                        printk(" %02x", buf[i]);
                 printk("\n");
         }
 
@@ -92,7 +93,7 @@ static int mt312_read(struct mt312_state *state, const enum mt312_reg_addr reg,
 }
 
 static int mt312_write(struct mt312_state *state, const enum mt312_reg_addr reg,
-                       const void *src, const size_t count)
+                       const u8 *src, const size_t count)
 {
         int ret;
         u8 buf[count + 1];
@@ -102,7 +103,7 @@ static int mt312_write(struct mt312_state *state, const enum mt312_reg_addr reg,
                 int i;
                 dprintk("W(%d):", reg & 0x7f);
                 for (i = 0; i < count; i++)
-                        printk(" %02x", ((const u8 *) src)[i]);
+                        printk(" %02x", src[i]);
                 printk("\n");
         }
 
@@ -117,7 +118,7 @@ static int mt312_write(struct mt312_state *state, const enum mt312_reg_addr reg,
         ret = i2c_transfer(state->i2c, &msg, 1);
 
         if (ret != 1) {
-                dprintk("%s: ret == %d\n", __FUNCTION__, ret);
+                dprintk("%s: ret == %d\n", __func__, ret);
                 return -EREMOTEIO;
         }
 
@@ -209,7 +210,7 @@ static int mt312_get_symbol_rate(struct mt312_state *state, u32 *sr)
                 dprintk("sym_rat_op=%d dec_ratio=%d\n",
                        sym_rat_op, dec_ratio);
                 dprintk("*sr(manual) = %lu\n",
-                       (((MT312_PLL_CLK * 8192) / (sym_rat_op + 8192)) *
+                       (((state->xtal * 8192) / (sym_rat_op + 8192)) *
                         2) - dec_ratio);
         }
 
@@ -242,7 +243,7 @@ static int mt312_initfe(struct dvb_frontend *fe)
 
         /* wake up */
         ret = mt312_writereg(state, CONFIG,
-                        (state->frequency == 60 ? 0x88 : 0x8c));
+                        (state->freq_mult == 6 ? 0x88 : 0x8c));
         if (ret < 0)
                 return ret;
 
@@ -265,12 +266,37 @@ static int mt312_initfe(struct dvb_frontend *fe)
                         return ret;
         }
 
+        switch (state->id) {
+        case ID_ZL10313:
+                /* enable ADC */
+                ret = mt312_writereg(state, GPP_CTRL, 0x80);
+                if (ret < 0)
+                        return ret;
+
+                /* configure ZL10313 for optimal ADC performance */
+                buf[0] = 0x80;
+                buf[1] = 0xB0;
+                ret = mt312_write(state, HW_CTRL, buf, 2);
+                if (ret < 0)
+                        return ret;
+
+                /* enable MPEG output and ADCs */
+                ret = mt312_writereg(state, HW_CTRL, 0x00);
+                if (ret < 0)
+                        return ret;
+
+                ret = mt312_writereg(state, MPEG_CTRL, 0x00);
+                if (ret < 0)
+                        return ret;
+
+                break;
+        }
+
         /* SYS_CLK */
-        buf[0] = mt312_div((state->frequency == 60 ? MT312_LPOWER_SYS_CLK :
-                                MT312_SYS_CLK) * 2, 1000000);
+        buf[0] = mt312_div(state->xtal * state->freq_mult * 2, 1000000);
 
         /* DISEQC_RATIO */
-        buf[1] = mt312_div(MT312_PLL_CLK, 15000 * 4);
+        buf[1] = mt312_div(state->xtal, 22000 * 4);
 
         ret = mt312_write(state, SYS_CLK, buf, sizeof(buf));
         if (ret < 0)
@@ -280,7 +306,17 @@ static int mt312_initfe(struct dvb_frontend *fe)
         if (ret < 0)
                 return ret;
 
-        ret = mt312_writereg(state, OP_CTRL, 0x53);
+        /* different MOCLK polarity */
+        switch (state->id) {
+        case ID_ZL10313:
+                buf[0] = 0x33;
+                break;
+        default:
+                buf[0] = 0x53;
+                break;
+        }
+
+        ret = mt312_writereg(state, OP_CTRL, buf[0]);
         if (ret < 0)
                 return ret;
 
@@ -323,6 +359,9 @@ static int mt312_send_master_cmd(struct dvb_frontend *fe,
         if (ret < 0)
                 return ret;
 
+        /* is there a better way to wait for message to be transmitted */
+        msleep(100);
+
         /* set DISEQC_MODE[2:0] to zero if a return message is expected */
         if (c->msg[0] & 0x02) {
                 ret = mt312_writereg(state, DISEQC_MODE, (diseqc_mode & 0x40));
@@ -383,11 +422,16 @@ static int mt312_set_voltage(struct dvb_frontend *fe, const fe_sec_voltage_t v)
 {
         struct mt312_state *state = fe->demodulator_priv;
         const u8 volt_tab[3] = { 0x00, 0x40, 0x00 };
+        u8 val;
 
         if (v > SEC_VOLTAGE_OFF)
                 return -EINVAL;
 
-        return mt312_writereg(state, DISEQC_MODE, volt_tab[v]);
+        val = volt_tab[v];
+        if (state->config->voltage_inverted)
+                val ^= 0x40;
+
+        return mt312_writereg(state, DISEQC_MODE, val);
 }
 
 static int mt312_read_status(struct dvb_frontend *fe, fe_status_t *s)
@@ -463,7 +507,7 @@ static int mt312_read_snr(struct dvb_frontend *fe, u16 *snr)
         int ret;
         u8 buf[2];
 
-        ret = mt312_read(state, M_SNR_H, &buf, sizeof(buf));
+        ret = mt312_read(state, M_SNR_H, buf, sizeof(buf));
         if (ret < 0)
                 return ret;
 
@@ -478,7 +522,7 @@ static int mt312_read_ucblocks(struct dvb_frontend *fe, u32 *ubc)
         int ret;
         u8 buf[2];
 
-        ret = mt312_read(state, RS_UBC_H, &buf, sizeof(buf));
+        ret = mt312_read(state, RS_UBC_H, buf, sizeof(buf));
         if (ret < 0)
                 return ret;
 
@@ -499,7 +543,7 @@ static int mt312_set_frontend(struct dvb_frontend *fe,
             { 0x00, 0x01, 0x02, 0x04, 0x3f, 0x08, 0x10, 0x20, 0x3f, 0x3f };
         const u8 inv_tab[3] = { 0x00, 0x40, 0x80 };
 
-        dprintk("%s: Freq %d\n", __FUNCTION__, p->frequency);
+        dprintk("%s: Freq %d\n", __func__, p->frequency);
 
         if ((p->frequency < fe->ops.info.frequency_min)
             || (p->frequency > fe->ops.info.frequency_max))
@@ -532,17 +576,17 @@ static int mt312_set_frontend(struct dvb_frontend *fe,
                         return ret;
                 if (p->u.qpsk.symbol_rate >= 30000000) {
                         /* Note that 30MS/s should use 90MHz */
-                        if ((config_val & 0x0c) == 0x08) {
+                        if (state->freq_mult == 6) {
                                 /* We are running 60MHz */
-                                state->frequency = 90;
+                                state->freq_mult = 9;
                                 ret = mt312_initfe(fe);
                                 if (ret < 0)
                                         return ret;
                         }
                 } else {
-                        if ((config_val & 0x0c) == 0x0C) {
+                        if (state->freq_mult == 9) {
                                 /* We are running 90MHz */
-                                state->frequency = 60;
+                                state->freq_mult = 6;
                                 ret = mt312_initfe(fe);
                                 if (ret < 0)
                                         return ret;
@@ -551,6 +595,7 @@ static int mt312_set_frontend(struct dvb_frontend *fe,
                 break;
 
         case ID_MT312:
+        case ID_ZL10313:
                 break;
 
         default:
@@ -616,11 +661,29 @@ static int mt312_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 {
         struct mt312_state *state = fe->demodulator_priv;
 
-        if (enable) {
-                return mt312_writereg(state, GPP_CTRL, 0x40);
-        } else {
-                return mt312_writereg(state, GPP_CTRL, 0x00);
+        u8 val = 0x00;
+        int ret;
+
+        switch (state->id) {
+        case ID_ZL10313:
+                ret = mt312_readreg(state, GPP_CTRL, &val);
+                if (ret < 0)
+                        goto error;
+
+                /* preserve this bit to not accidently shutdown ADC */
+                val &= 0x80;
+                break;
         }
+
+        if (enable)
+                val |= 0x40;
+        else
+                val &= ~0x40;
+
+        ret = mt312_writereg(state, GPP_CTRL, val);
+
+error:
+        return ret;
 }
 
 static int mt312_sleep(struct dvb_frontend *fe)
@@ -634,6 +697,18 @@ static int mt312_sleep(struct dvb_frontend *fe)
         if (ret < 0)
                 return ret;
 
+        if (state->id == ID_ZL10313) {
+                /* reset ADC */
+                ret = mt312_writereg(state, GPP_CTRL, 0x00);
+                if (ret < 0)
+                        return ret;
+
+                /* full shutdown of ADCs, mpeg bus tristated */
+                ret = mt312_writereg(state, HW_CTRL, 0x0d);
+                if (ret < 0)
+                        return ret;
+        }
+
         ret = mt312_readreg(state, CONFIG, &config);
         if (ret < 0)
                 return ret;
@@ -661,6 +736,7 @@ static void mt312_release(struct dvb_frontend *fe)
         kfree(state);
 }
 
+#define MT312_SYS_CLK           90000000UL      /* 90 MHz */
 static struct dvb_frontend_ops vp310_mt312_ops = {
 
         .info = {
@@ -668,8 +744,8 @@ static struct dvb_frontend_ops vp310_mt312_ops = {
                 .type = FE_QPSK,
                 .frequency_min = 950000,
                 .frequency_max = 2150000,
-                .frequency_stepsize = (MT312_PLL_CLK / 1000) / 128,
-                .symbol_rate_min = MT312_SYS_CLK / 128,
+                .frequency_stepsize = (MT312_PLL_CLK / 1000) / 128, /* FIXME: adjust freq to real used xtal */
+                .symbol_rate_min = MT312_SYS_CLK / 128, /* FIXME as above */
                 .symbol_rate_max = MT312_SYS_CLK / 2,
                 .caps =
                     FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
@@ -726,14 +802,21 @@ struct dvb_frontend *vp310_mt312_attach(const struct mt312_config *config,
         switch (state->id) {
         case ID_VP310:
                 strcpy(state->frontend.ops.info.name, "Zarlink VP310 DVB-S");
-                state->frequency = 90;
+                state->xtal = MT312_PLL_CLK;
+                state->freq_mult = 9;
                 break;
         case ID_MT312:
                 strcpy(state->frontend.ops.info.name, "Zarlink MT312 DVB-S");
-                state->frequency = 60;
+                state->xtal = MT312_PLL_CLK;
+                state->freq_mult = 6;
+                break;
+        case ID_ZL10313:
+                strcpy(state->frontend.ops.info.name, "Zarlink ZL10313 DVB-S");
+                state->xtal = MT312_PLL_CLK_10_111;
+                state->freq_mult = 9;
                 break;
         default:
-                printk(KERN_WARNING "Only Zarlink VP310/MT312"
+                printk(KERN_WARNING "Only Zarlink VP310/MT312/ZL10313"
                         " are supported chips.\n");
                 goto error;
         }
@@ -749,7 +832,7 @@ EXPORT_SYMBOL(vp310_mt312_attach);
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 
-MODULE_DESCRIPTION("Zarlink VP310/MT312 DVB-S Demodulator driver");
+MODULE_DESCRIPTION("Zarlink VP310/MT312/ZL10313 DVB-S Demodulator driver");
 MODULE_AUTHOR("Andreas Oberritter <obi@linuxtv.org>");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/media/dvb/frontends/mt312.h b/drivers/media/dvb/frontends/mt312.h
index f17cb93ba9ba..96338f0c4dd4 100644
--- a/drivers/media/dvb/frontends/mt312.h
+++ b/drivers/media/dvb/frontends/mt312.h
@@ -31,6 +31,9 @@
 struct mt312_config {
         /* the demodulator's i2c address */
         u8 demod_address;
+
+        /* inverted voltage setting */
+        int voltage_inverted:1;
 };
 
 #if defined(CONFIG_DVB_MT312) || (defined(CONFIG_DVB_MT312_MODULE) && defined(MODULE))
@@ -40,7 +43,7 @@ struct dvb_frontend *vp310_mt312_attach(const struct mt312_config *config,
 static inline struct dvb_frontend *vp310_mt312_attach(
         const struct mt312_config *config, struct i2c_adapter *i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif /* CONFIG_DVB_MT312 */
diff --git a/drivers/media/dvb/frontends/mt312_priv.h b/drivers/media/dvb/frontends/mt312_priv.h
index 5e0b95b5337b..a3959f94d639 100644
--- a/drivers/media/dvb/frontends/mt312_priv.h
+++ b/drivers/media/dvb/frontends/mt312_priv.h
@@ -110,6 +110,8 @@ enum mt312_reg_addr {
         VIT_ERRPER_H = 83,
         VIT_ERRPER_M = 84,
         VIT_ERRPER_L = 85,
+        HW_CTRL = 84,   /* ZL10313 only */
+        MPEG_CTRL = 85, /* ZL10313 only */
         VIT_SETUP = 86,
         VIT_REF0 = 87,
         VIT_REF1 = 88,
@@ -156,7 +158,8 @@ enum mt312_reg_addr {
 
 enum mt312_model_id {
         ID_VP310 = 1,
-        ID_MT312 = 3
+        ID_MT312 = 3,
+        ID_ZL10313 = 5,
 };
 
 #endif                          /* DVB_FRONTENDS_MT312_PRIV */
diff --git a/drivers/media/dvb/frontends/mt352.c b/drivers/media/dvb/frontends/mt352.c
index 7cd190b6f015..beba5aa0db50 100644
--- a/drivers/media/dvb/frontends/mt352.c
+++ b/drivers/media/dvb/frontends/mt352.c
@@ -95,7 +95,7 @@ static int mt352_read_register(struct mt352_state* state, u8 reg)
 
         if (ret != 2) {
                 printk("%s: readreg error (reg=%d, ret==%i)\n",
-                       __FUNCTION__, reg, ret);
+                       __func__, reg, ret);
                 return ret;
         }
 
@@ -135,7 +135,7 @@ static void mt352_calc_nominal_rate(struct mt352_state* state,
         value = 64 * bw * (1<<16) / (7 * 8);
         value = value * 1000 / adc_clock;
         dprintk("%s: bw %d, adc_clock %d => 0x%x\n",
-                __FUNCTION__, bw, adc_clock, value);
+                __func__, bw, adc_clock, value);
         buf[0] = msb(value);
         buf[1] = lsb(value);
 }
@@ -161,7 +161,7 @@ static void mt352_calc_input_freq(struct mt352_state* state,
         }
         value = -16374 * ife / adc_clock;
         dprintk("%s: if2 %d, ife %d, adc_clock %d => %d / 0x%x\n",
-                __FUNCTION__, if2, ife, adc_clock, value, value & 0x3fff);
+                __func__, if2, ife, adc_clock, value, value & 0x3fff);
         buf[0] = msb(value);
         buf[1] = lsb(value);
 }
@@ -521,7 +521,7 @@ static int mt352_init(struct dvb_frontend* fe)
 
         static u8 mt352_reset_attach [] = { RESET, 0xC0 };
 
-        dprintk("%s: hello\n",__FUNCTION__);
+        dprintk("%s: hello\n",__func__);
 
         if ((mt352_read_register(state, CLOCK_CTL) & 0x10) == 0 ||
             (mt352_read_register(state, CONFIG) & 0x20) == 0) {
diff --git a/drivers/media/dvb/frontends/mt352.h b/drivers/media/dvb/frontends/mt352.h
index e9964081fd84..595092f9f0c4 100644
--- a/drivers/media/dvb/frontends/mt352.h
+++ b/drivers/media/dvb/frontends/mt352.h
@@ -58,7 +58,7 @@ extern struct dvb_frontend* mt352_attach(const struct mt352_config* config,
 static inline struct dvb_frontend* mt352_attach(const struct mt352_config* config,
                                          struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_MT352
diff --git a/drivers/media/dvb/frontends/nxt200x.c b/drivers/media/dvb/frontends/nxt200x.c
index fcf964fe1d6b..23d022852543 100644
--- a/drivers/media/dvb/frontends/nxt200x.c
+++ b/drivers/media/dvb/frontends/nxt200x.c
@@ -74,7 +74,7 @@ static int i2c_writebytes (struct nxt200x_state* state, u8 addr, u8 *buf, u8 len
 
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
                 printk (KERN_WARNING "nxt200x: %s: i2c write error (addr 0x%02x, err == %i)\n",
-                        __FUNCTION__, addr, err);
+                        __func__, addr, err);
                 return -EREMOTEIO;
         }
         return 0;
@@ -87,7 +87,7 @@ static u8 i2c_readbytes (struct nxt200x_state* state, u8 addr, u8* buf, u8 len)
 
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
                 printk (KERN_WARNING "nxt200x: %s: i2c read error (addr 0x%02x, err == %i)\n",
-                        __FUNCTION__, addr, err);
+                        __func__, addr, err);
                 return -EREMOTEIO;
         }
         return 0;
@@ -104,7 +104,7 @@ static int nxt200x_writebytes (struct nxt200x_state* state, u8 reg, u8 *buf, u8
 
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
                 printk (KERN_WARNING "nxt200x: %s: i2c write error (addr 0x%02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
+                        __func__, state->config->demod_address, err);
                 return -EREMOTEIO;
         }
         return 0;
@@ -121,7 +121,7 @@ static u8 nxt200x_readbytes (struct nxt200x_state* state, u8 reg, u8* buf, u8 le
 
         if ((err = i2c_transfer (state->i2c, msg, 2)) != 2) {
                 printk (KERN_WARNING "nxt200x: %s: i2c read error (addr 0x%02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
+                        __func__, state->config->demod_address, err);
                 return -EREMOTEIO;
         }
         return 0;
@@ -146,7 +146,7 @@ static u16 nxt200x_crc(u16 crc, u8 c)
 static int nxt200x_writereg_multibyte (struct nxt200x_state* state, u8 reg, u8* data, u8 len)
 {
         u8 attr, len2, buf;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* set mutli register register */
         nxt200x_writebytes(state, 0x35, &reg, 1);
@@ -207,7 +207,7 @@ static int nxt200x_readreg_multibyte (struct nxt200x_state* state, u8 reg, u8* d
 {
         int i;
         u8 buf, len2, attr;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* set mutli register register */
         nxt200x_writebytes(state, 0x35, &reg, 1);
@@ -254,7 +254,7 @@ static int nxt200x_readreg_multibyte (struct nxt200x_state* state, u8 reg, u8* d
 static void nxt200x_microcontroller_stop (struct nxt200x_state* state)
 {
         u8 buf, stopval, counter = 0;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* set correct stop value */
         switch (state->demod_chip) {
@@ -287,7 +287,7 @@ static void nxt200x_microcontroller_stop (struct nxt200x_state* state)
 static void nxt200x_microcontroller_start (struct nxt200x_state* state)
 {
         u8 buf;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         buf = 0x00;
         nxt200x_writebytes(state, 0x22, &buf, 1);
@@ -297,7 +297,7 @@ static void nxt2004_microcontroller_init (struct nxt200x_state* state)
 {
         u8 buf[9];
         u8 counter = 0;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         buf[0] = 0x00;
         nxt200x_writebytes(state, 0x2b, buf, 1);
@@ -328,7 +328,7 @@ static int nxt200x_writetuner (struct nxt200x_state* state, u8* data)
 {
         u8 buf, count = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         dprintk("Tuner Bytes: %02X %02X %02X %02X\n", data[1], data[2], data[3], data[4]);
 
@@ -387,7 +387,7 @@ static int nxt200x_writetuner (struct nxt200x_state* state, u8* data)
 static void nxt200x_agc_reset(struct nxt200x_state* state)
 {
         u8 buf;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         switch (state->demod_chip) {
                 case NXT2002:
@@ -416,7 +416,7 @@ static int nxt2002_load_firmware (struct dvb_frontend* fe, const struct firmware
         u8 buf[3], written = 0, chunkpos = 0;
         u16 rambase, position, crc = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         dprintk("Firmware is %zu bytes\n", fw->size);
 
         /* Get the RAM base for this nxt2002 */
@@ -483,7 +483,7 @@ static int nxt2004_load_firmware (struct dvb_frontend* fe, const struct firmware
         u8 buf[3];
         u16 rambase, position, crc=0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         dprintk("Firmware is %zu bytes\n", fw->size);
 
         /* set rambase */
diff --git a/drivers/media/dvb/frontends/nxt200x.h b/drivers/media/dvb/frontends/nxt200x.h
index bb0ef58d7972..f3c84583770f 100644
--- a/drivers/media/dvb/frontends/nxt200x.h
+++ b/drivers/media/dvb/frontends/nxt200x.h
@@ -49,7 +49,7 @@ extern struct dvb_frontend* nxt200x_attach(const struct nxt200x_config* config,
 static inline struct dvb_frontend* nxt200x_attach(const struct nxt200x_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_NXT200X
diff --git a/drivers/media/dvb/frontends/nxt6000.c b/drivers/media/dvb/frontends/nxt6000.c
index d313d7dcf386..0eef22dbf8a0 100644
--- a/drivers/media/dvb/frontends/nxt6000.c
+++ b/drivers/media/dvb/frontends/nxt6000.c
@@ -38,7 +38,7 @@ struct nxt6000_state {
         struct dvb_frontend frontend;
 };
 
-static int debug = 0;
+static int debug;
 #define dprintk if (debug) printk
 
 static int nxt6000_writereg(struct nxt6000_state* state, u8 reg, u8 data)
diff --git a/drivers/media/dvb/frontends/nxt6000.h b/drivers/media/dvb/frontends/nxt6000.h
index 13d22518356e..878eb38a075e 100644
--- a/drivers/media/dvb/frontends/nxt6000.h
+++ b/drivers/media/dvb/frontends/nxt6000.h
@@ -40,7 +40,7 @@ extern struct dvb_frontend* nxt6000_attach(const struct nxt6000_config* config,
 static inline struct dvb_frontend* nxt6000_attach(const struct nxt6000_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_NXT6000
diff --git a/drivers/media/dvb/frontends/or51132.c b/drivers/media/dvb/frontends/or51132.c
index 8ffb8daca031..c7b5785f81f2 100644
--- a/drivers/media/dvb/frontends/or51132.c
+++ b/drivers/media/dvb/frontends/or51132.c
@@ -419,7 +419,7 @@ static int or51132_read_status(struct dvb_frontend* fe, fe_status_t* status)
                 *status = 0;
                 return -EREMOTEIO;
         }
-        dprintk("%s: read_status %04x\n", __FUNCTION__, reg);
+        dprintk("%s: read_status %04x\n", __func__, reg);
 
         if (reg & 0x0100) /* Receiver Lock */
                 *status = FE_HAS_SIGNAL|FE_HAS_CARRIER|FE_HAS_VITERBI|
@@ -504,14 +504,14 @@ start:
                 if (retry--) goto start;
                 return -EREMOTEIO;
         }
-        dprintk("%s: modulation %02x, NTSC rej O%s\n", __FUNCTION__,
+        dprintk("%s: modulation %02x, NTSC rej O%s\n", __func__,
                 reg&0xff, reg&0x1000?"n":"ff");
 
         /* Calculate SNR using noise, c, and NTSC rejection correction */
         state->snr = calculate_snr(noise, c) - usK;
         *snr = (state->snr) >> 16;
 
-        dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __FUNCTION__, noise,
+        dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
                 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
 
         return 0;
diff --git a/drivers/media/dvb/frontends/or51132.h b/drivers/media/dvb/frontends/or51132.h
index add24f0a743b..1b8e04d973c8 100644
--- a/drivers/media/dvb/frontends/or51132.h
+++ b/drivers/media/dvb/frontends/or51132.h
@@ -41,7 +41,7 @@ extern struct dvb_frontend* or51132_attach(const struct or51132_config* config,
 static inline struct dvb_frontend* or51132_attach(const struct or51132_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_OR51132
diff --git a/drivers/media/dvb/frontends/or51211.c b/drivers/media/dvb/frontends/or51211.c
index 6a6b0d727c6f..7eaa4765593f 100644
--- a/drivers/media/dvb/frontends/or51211.c
+++ b/drivers/media/dvb/frontends/or51211.c
@@ -307,19 +307,19 @@ static int or51211_read_snr(struct dvb_frontend* fe, u16* snr)
 
         if (i2c_writebytes(state,state->config->demod_address,snd_buf,3)) {
                 printk(KERN_WARNING "%s: error writing snr reg\n",
-                       __FUNCTION__);
+                       __func__);
                 return -1;
         }
         if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
                 printk(KERN_WARNING "%s: read_status read error\n",
-                       __FUNCTION__);
+                       __func__);
                 return -1;
         }
 
         state->snr = calculate_snr(rec_buf[0], 89599047);
         *snr = (state->snr) >> 16;
 
-        dprintk("%s: noise = 0x%02x, snr = %d.%02d dB\n", __FUNCTION__, rec_buf[0],
+        dprintk("%s: noise = 0x%02x, snr = %d.%02d dB\n", __func__, rec_buf[0],
                 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
 
         return 0;
diff --git a/drivers/media/dvb/frontends/or51211.h b/drivers/media/dvb/frontends/or51211.h
index 8aad8402d615..3ce0508b898e 100644
--- a/drivers/media/dvb/frontends/or51211.h
+++ b/drivers/media/dvb/frontends/or51211.h
@@ -44,7 +44,7 @@ extern struct dvb_frontend* or51211_attach(const struct or51211_config* config,
 static inline struct dvb_frontend* or51211_attach(const struct or51211_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_OR51211
diff --git a/drivers/media/dvb/frontends/qt1010.h b/drivers/media/dvb/frontends/qt1010.h
index 3ab4aa045c36..cff6a7ca5380 100644
--- a/drivers/media/dvb/frontends/qt1010.h
+++ b/drivers/media/dvb/frontends/qt1010.h
@@ -45,7 +45,7 @@ static inline struct dvb_frontend *qt1010_attach(struct dvb_frontend *fe,
                                                  struct i2c_adapter *i2c,
                                                  struct qt1010_config *cfg)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TUNER_QT1010
diff --git a/drivers/media/dvb/frontends/s5h1409.c b/drivers/media/dvb/frontends/s5h1409.c
index 1a4d8319773c..b999ec424ff7 100644
--- a/drivers/media/dvb/frontends/s5h1409.c
+++ b/drivers/media/dvb/frontends/s5h1409.c
@@ -48,7 +48,7 @@ struct s5h1409_state {
         u32 qam_state;
 };
 
-static int debug = 0;
+static int debug;
 #define dprintk if (debug) printk
 
 /* Register values to initialise the demod, this will set VSB by default */
@@ -312,7 +312,7 @@ static int s5h1409_writereg(struct s5h1409_state* state, u8 reg, u16 data)
 
         if (ret != 1)
                 printk("%s: writereg error (reg == 0x%02x, val == 0x%04x, "
-                       "ret == %i)\n", __FUNCTION__, reg, data, ret);
+                       "ret == %i)\n", __func__, reg, data, ret);
 
         return (ret != 1) ? -1 : 0;
 }
@@ -332,7 +332,7 @@ static u16 s5h1409_readreg(struct s5h1409_state* state, u8 reg)
         ret = i2c_transfer(state->i2c, msg, 2);
 
         if (ret != 2)
-                printk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
+                printk("%s: readreg error (ret == %i)\n", __func__, ret);
         return (b1[0] << 8) | b1[1];
 }
 
@@ -340,7 +340,7 @@ static int s5h1409_softreset(struct dvb_frontend* fe)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         s5h1409_writereg(state, 0xf5, 0);
         s5h1409_writereg(state, 0xf5, 1);
@@ -356,7 +356,7 @@ static int s5h1409_set_if_freq(struct dvb_frontend* fe, int KHz)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(%d KHz)\n", __FUNCTION__, KHz);
+        dprintk("%s(%d KHz)\n", __func__, KHz);
 
         switch (KHz) {
         case 4000:
@@ -381,7 +381,7 @@ static int s5h1409_set_spectralinversion(struct dvb_frontend* fe, int inverted)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(%d)\n", __FUNCTION__, inverted);
+        dprintk("%s(%d)\n", __func__, inverted);
 
         if(inverted == 1)
                 return s5h1409_writereg(state, 0x1b, 0x1101); /* Inverted */
@@ -394,25 +394,25 @@ static int s5h1409_enable_modulation(struct dvb_frontend* fe,
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(0x%08x)\n", __FUNCTION__, m);
+        dprintk("%s(0x%08x)\n", __func__, m);
 
         switch(m) {
         case VSB_8:
-                dprintk("%s() VSB_8\n", __FUNCTION__);
+                dprintk("%s() VSB_8\n", __func__);
                 if (state->if_freq != S5H1409_VSB_IF_FREQ)
                         s5h1409_set_if_freq(fe, S5H1409_VSB_IF_FREQ);
                 s5h1409_writereg(state, 0xf4, 0);
                 break;
         case QAM_64:
         case QAM_256:
-                dprintk("%s() QAM_AUTO (64/256)\n", __FUNCTION__);
+                dprintk("%s() QAM_AUTO (64/256)\n", __func__);
                 if (state->if_freq != S5H1409_QAM_IF_FREQ)
                         s5h1409_set_if_freq(fe, S5H1409_QAM_IF_FREQ);
                 s5h1409_writereg(state, 0xf4, 1);
                 s5h1409_writereg(state, 0x85, 0x110);
                 break;
         default:
-                dprintk("%s() Invalid modulation\n", __FUNCTION__);
+                dprintk("%s() Invalid modulation\n", __func__);
                 return -EINVAL;
         }
 
@@ -426,7 +426,7 @@ static int s5h1409_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(%d)\n", __FUNCTION__, enable);
+        dprintk("%s(%d)\n", __func__, enable);
 
         if (enable)
                 return s5h1409_writereg(state, 0xf3, 1);
@@ -438,7 +438,7 @@ static int s5h1409_set_gpio(struct dvb_frontend* fe, int enable)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(%d)\n", __FUNCTION__, enable);
+        dprintk("%s(%d)\n", __func__, enable);
 
         if (enable)
                 return s5h1409_writereg(state, 0xe3,
@@ -452,7 +452,7 @@ static int s5h1409_sleep(struct dvb_frontend* fe, int enable)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(%d)\n", __FUNCTION__, enable);
+        dprintk("%s(%d)\n", __func__, enable);
 
         return s5h1409_writereg(state, 0xf2, enable);
 }
@@ -461,7 +461,7 @@ static int s5h1409_register_reset(struct dvb_frontend* fe)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         return s5h1409_writereg(state, 0xfa, 0);
 }
@@ -534,7 +534,7 @@ static int s5h1409_set_frontend (struct dvb_frontend* fe,
 {
         struct s5h1409_state* state = fe->demodulator_priv;
 
-        dprintk("%s(frequency=%d)\n", __FUNCTION__, p->frequency);
+        dprintk("%s(frequency=%d)\n", __func__, p->frequency);
 
         s5h1409_softreset(fe);
 
@@ -565,7 +565,7 @@ static int s5h1409_set_mpeg_timing(struct dvb_frontend *fe, int mode)
         struct s5h1409_state *state = fe->demodulator_priv;
         u16 val;
 
-        dprintk("%s(%d)\n", __FUNCTION__, mode);
+        dprintk("%s(%d)\n", __func__, mode);
 
         val = s5h1409_readreg(state, 0xac) & 0xcfff;
         switch (mode) {
@@ -573,7 +573,7 @@ static int s5h1409_set_mpeg_timing(struct dvb_frontend *fe, int mode)
                 val |= 0x0000;
                 break;
         case S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK:
-                dprintk("%s(%d) Mode1 or Defaulting\n", __FUNCTION__, mode);
+                dprintk("%s(%d) Mode1 or Defaulting\n", __func__, mode);
                 val |= 0x1000;
                 break;
         case S5H1409_MPEGTIMING_NONCONTINOUS_INVERTING_CLOCK:
@@ -597,7 +597,7 @@ static int s5h1409_init (struct dvb_frontend* fe)
         int i;
 
         struct s5h1409_state* state = fe->demodulator_priv;
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         s5h1409_sleep(fe, 0);
         s5h1409_register_reset(fe);
@@ -663,7 +663,7 @@ static int s5h1409_read_status(struct dvb_frontend* fe, fe_status_t* status)
                 break;
         }
 
-        dprintk("%s() status 0x%08x\n", __FUNCTION__, *status);
+        dprintk("%s() status 0x%08x\n", __func__, *status);
 
         return 0;
 }
@@ -671,7 +671,7 @@ static int s5h1409_read_status(struct dvb_frontend* fe, fe_status_t* status)
 static int s5h1409_qam256_lookup_snr(struct dvb_frontend* fe, u16* snr, u16 v)
 {
         int i, ret = -EINVAL;
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         for (i=0; i < ARRAY_SIZE(qam256_snr_tab); i++) {
                 if (v < qam256_snr_tab[i].val) {
@@ -686,7 +686,7 @@ static int s5h1409_qam256_lookup_snr(struct dvb_frontend* fe, u16* snr, u16 v)
 static int s5h1409_qam64_lookup_snr(struct dvb_frontend* fe, u16* snr, u16 v)
 {
         int i, ret = -EINVAL;
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         for (i=0; i < ARRAY_SIZE(qam64_snr_tab); i++) {
                 if (v < qam64_snr_tab[i].val) {
@@ -701,7 +701,7 @@ static int s5h1409_qam64_lookup_snr(struct dvb_frontend* fe, u16* snr, u16 v)
 static int s5h1409_vsb_lookup_snr(struct dvb_frontend* fe, u16* snr, u16 v)
 {
         int i, ret = -EINVAL;
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         for (i=0; i < ARRAY_SIZE(vsb_snr_tab); i++) {
                 if (v > vsb_snr_tab[i].val) {
@@ -710,7 +710,7 @@ static int s5h1409_vsb_lookup_snr(struct dvb_frontend* fe, u16* snr, u16 v)
                         break;
                 }
         }
-        dprintk("%s() snr=%d\n", __FUNCTION__, *snr);
+        dprintk("%s() snr=%d\n", __func__, *snr);
         return ret;
 }
 
@@ -718,7 +718,7 @@ static int s5h1409_read_snr(struct dvb_frontend* fe, u16* snr)
 {
         struct s5h1409_state* state = fe->demodulator_priv;
         u16 reg;
-        dprintk("%s()\n", __FUNCTION__);
+        dprintk("%s()\n", __func__);
 
         switch(state->current_modulation) {
         case QAM_64:
@@ -812,7 +812,7 @@ struct dvb_frontend* s5h1409_attach(const struct s5h1409_config* config,
 
         if (s5h1409_init(&state->frontend) != 0) {
                 printk(KERN_ERR "%s: Failed to initialize correctly\n",
-                        __FUNCTION__);
+                        __func__);
                 goto error;
         }
 
diff --git a/drivers/media/dvb/frontends/s5h1409.h b/drivers/media/dvb/frontends/s5h1409.h
index f0bb13fe808b..59f4335964c6 100644
--- a/drivers/media/dvb/frontends/s5h1409.h
+++ b/drivers/media/dvb/frontends/s5h1409.h
@@ -67,7 +67,7 @@ extern struct dvb_frontend* s5h1409_attach(const struct s5h1409_config* config,
 static inline struct dvb_frontend* s5h1409_attach(const struct s5h1409_config* config,
                                                   struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif /* CONFIG_DVB_S5H1409 */
diff --git a/drivers/media/dvb/frontends/s5h1420.c b/drivers/media/dvb/frontends/s5h1420.c
index 2c2c344c4c64..281e1cb2edc6 100644
--- a/drivers/media/dvb/frontends/s5h1420.c
+++ b/drivers/media/dvb/frontends/s5h1420.c
@@ -1,24 +1,26 @@
 /*
-Driver for Samsung S5H1420 QPSK Demodulator
-
-Copyright (C) 2005 Andrew de Quincey <adq_dvb@lidskialf.net>
-
-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.
-
-*/
+ * Driver for
+ *    Samsung S5H1420 and
+ *    PnpNetwork PN1010 QPSK Demodulator
+ *
+ * Copyright (C) 2005 Andrew de Quincey <adq_dvb@lidskialf.net>
+ * Copyright (C) 2005-8 Patrick Boettcher <pb@linuxtv.org>
+ *
+ * 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/kernel.h>
 #include <linux/module.h>
@@ -29,23 +31,35 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <linux/jiffies.h>
 #include <asm/div64.h>
 
-#include "dvb_frontend.h"
-#include "s5h1420.h"
+#include <linux/i2c.h>
 
 
+#include "dvb_frontend.h"
+#include "s5h1420.h"
+#include "s5h1420_priv.h"
 
 #define TONE_FREQ 22000
 
 struct s5h1420_state {
         struct i2c_adapter* i2c;
         const struct s5h1420_config* config;
+
         struct dvb_frontend frontend;
+        struct i2c_adapter tuner_i2c_adapter;
+
+        u8 CON_1_val;
 
         u8 postlocked:1;
         u32 fclk;
         u32 tunedfreq;
         fe_code_rate_t fec_inner;
         u32 symbol_rate;
+
+        /* FIXME: ugly workaround for flexcop's incapable i2c-controller
+         * it does not support repeated-start, workaround: write addr-1
+         * and then read
+         */
+        u8 shadow[255];
 };
 
 static u32 s5h1420_getsymbolrate(struct s5h1420_state* state);
@@ -53,44 +67,66 @@ static int s5h1420_get_tune_settings(struct dvb_frontend* fe,
                                      struct dvb_frontend_tune_settings* fesettings);
 
 
-static int debug = 0;
-#define dprintk if (debug) printk
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable debugging");
+
+#define dprintk(x...) do { \
+        if (debug) \
+                printk(KERN_DEBUG "S5H1420: " x); \
+} while (0)
+
+static u8 s5h1420_readreg(struct s5h1420_state *state, u8 reg)
+{
+        int ret;
+        u8 b[2];
+        struct i2c_msg msg[] = {
+                { .addr = state->config->demod_address, .flags = 0, .buf = b, .len = 2 },
+                { .addr = state->config->demod_address, .flags = 0, .buf = &reg, .len = 1 },
+                { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b, .len = 1 },
+        };
+
+        b[0] = (reg - 1) & 0xff;
+        b[1] = state->shadow[(reg - 1) & 0xff];
+
+        if (state->config->repeated_start_workaround) {
+                ret = i2c_transfer(state->i2c, msg, 3);
+                if (ret != 3)
+                        return ret;
+        } else {
+                ret = i2c_transfer(state->i2c, &msg[1], 2);
+                if (ret != 2)
+                        return ret;
+        }
+
+        /* dprintk("rd(%02x): %02x %02x\n", state->config->demod_address, reg, b[0]); */
+
+        return b[0];
+}
 
 static int s5h1420_writereg (struct s5h1420_state* state, u8 reg, u8 data)
 {
-        u8 buf [] = { reg, data };
+        u8 buf[] = { reg, data };
         struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
         int err;
 
-        if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
-                dprintk ("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __FUNCTION__, err, reg, data);
+        /* dprintk("wr(%02x): %02x %02x\n", state->config->demod_address, reg, data); */
+        err = i2c_transfer(state->i2c, &msg, 1);
+        if (err != 1) {
+                dprintk("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __func__, err, reg, data);
                 return -EREMOTEIO;
         }
+        state->shadow[reg] = data;
 
         return 0;
 }
 
-static u8 s5h1420_readreg (struct s5h1420_state* state, u8 reg)
-{
-        int ret;
-        u8 b0 [] = { reg };
-        u8 b1 [] = { 0 };
-        struct i2c_msg msg1 = { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 1 };
-        struct i2c_msg msg2 = { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 };
-
-        if ((ret = i2c_transfer (state->i2c, &msg1, 1)) != 1)
-                return ret;
-
-        if ((ret = i2c_transfer (state->i2c, &msg2, 1)) != 1)
-                return ret;
-
-        return b1[0];
-}
-
 static int s5h1420_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
         struct s5h1420_state* state = fe->demodulator_priv;
 
+        dprintk("enter %s\n", __func__);
+
         switch(voltage) {
         case SEC_VOLTAGE_13:
                 s5h1420_writereg(state, 0x3c,
@@ -106,6 +142,7 @@ static int s5h1420_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltag
                 break;
         }
 
+        dprintk("leave %s\n", __func__);
         return 0;
 }
 
@@ -113,6 +150,7 @@ static int s5h1420_set_tone (struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
         struct s5h1420_state* state = fe->demodulator_priv;
 
+        dprintk("enter %s\n", __func__);
         switch(tone) {
         case SEC_TONE_ON:
                 s5h1420_writereg(state, 0x3b,
@@ -124,6 +162,7 @@ static int s5h1420_set_tone (struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
                                  (s5h1420_readreg(state, 0x3b) & 0x74) | 0x01);
                 break;
         }
+        dprintk("leave %s\n", __func__);
 
         return 0;
 }
@@ -137,6 +176,7 @@ static int s5h1420_send_master_cmd (struct dvb_frontend* fe,
         unsigned long timeout;
         int result = 0;
 
+        dprintk("enter %s\n", __func__);
         if (cmd->msg_len > 8)
                 return -EINVAL;
 
@@ -168,6 +208,7 @@ static int s5h1420_send_master_cmd (struct dvb_frontend* fe,
         /* restore original settings */
         s5h1420_writereg(state, 0x3b, val);
         msleep(15);
+        dprintk("leave %s\n", __func__);
         return result;
 }
 
@@ -289,6 +330,8 @@ static int s5h1420_read_status(struct dvb_frontend* fe, fe_status_t* status)
         struct s5h1420_state* state = fe->demodulator_priv;
         u8 val;
 
+        dprintk("enter %s\n", __func__);
+
         if (status == NULL)
                 return -EINVAL;
 
@@ -297,13 +340,13 @@ static int s5h1420_read_status(struct dvb_frontend* fe, fe_status_t* status)
 
         /* fix for FEC 5/6 inversion issue - if it doesn't quite lock, invert
         the inversion, wait a bit and check again */
-        if (*status == (FE_HAS_SIGNAL|FE_HAS_CARRIER|FE_HAS_VITERBI)) {
-                val = s5h1420_readreg(state, 0x32);
+        if (*status == (FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI)) {
+                val = s5h1420_readreg(state, Vit10);
                 if ((val & 0x07) == 0x03) {
                         if (val & 0x08)
-                                s5h1420_writereg(state, 0x31, 0x13);
+                                s5h1420_writereg(state, Vit09, 0x13);
                         else
-                                s5h1420_writereg(state, 0x31, 0x1b);
+                                s5h1420_writereg(state, Vit09, 0x1b);
 
                         /* wait a bit then update lock status */
                         mdelay(200);
@@ -312,68 +355,73 @@ static int s5h1420_read_status(struct dvb_frontend* fe, fe_status_t* status)
         }
 
         /* perform post lock setup */
-        if ((*status & FE_HAS_LOCK) && (!state->postlocked)) {
+        if ((*status & FE_HAS_LOCK) && !state->postlocked) {
 
                 /* calculate the data rate */
                 u32 tmp = s5h1420_getsymbolrate(state);
-                switch(s5h1420_readreg(state, 0x32) & 0x07) {
-                case 0:
-                        tmp = (tmp * 2 * 1) / 2;
-                        break;
-
-                case 1:
-                        tmp = (tmp * 2 * 2) / 3;
-                        break;
-
-                case 2:
-                        tmp = (tmp * 2 * 3) / 4;
-                        break;
-
-                case 3:
-                        tmp = (tmp * 2 * 5) / 6;
-                        break;
-
-                case 4:
-                        tmp = (tmp * 2 * 6) / 7;
-                        break;
-
-                case 5:
-                        tmp = (tmp * 2 * 7) / 8;
-                        break;
+                switch (s5h1420_readreg(state, Vit10) & 0x07) {
+                case 0: tmp = (tmp * 2 * 1) / 2; break;
+                case 1: tmp = (tmp * 2 * 2) / 3; break;
+                case 2: tmp = (tmp * 2 * 3) / 4; break;
+                case 3: tmp = (tmp * 2 * 5) / 6; break;
+                case 4: tmp = (tmp * 2 * 6) / 7; break;
+                case 5: tmp = (tmp * 2 * 7) / 8; break;
                 }
+
                 if (tmp == 0) {
-                        printk("s5h1420: avoided division by 0\n");
+                        printk(KERN_ERR "s5h1420: avoided division by 0\n");
                         tmp = 1;
                 }
                 tmp = state->fclk / tmp;
 
+
                 /* set the MPEG_CLK_INTL for the calculated data rate */
-                if (tmp < 4)
+                if (tmp < 2)
                         val = 0x00;
-                else if (tmp < 8)
+                else if (tmp < 5)
                         val = 0x01;
-                else if (tmp < 12)
+                else if (tmp < 9)
                         val = 0x02;
-                else if (tmp < 16)
+                else if (tmp < 13)
                         val = 0x03;
-                else if (tmp < 24)
+                else if (tmp < 17)
                         val = 0x04;
-                else if (tmp < 32)
+                else if (tmp < 25)
                         val = 0x05;
-                else
+                else if (tmp < 33)
                         val = 0x06;
-                s5h1420_writereg(state, 0x22, val);
+                else
+                        val = 0x07;
+                dprintk("for MPEG_CLK_INTL %d %x\n", tmp, val);
+
+                s5h1420_writereg(state, FEC01, 0x18);
+                s5h1420_writereg(state, FEC01, 0x10);
+                s5h1420_writereg(state, FEC01, val);
+
+                /* Enable "MPEG_Out" */
+                val = s5h1420_readreg(state, Mpeg02);
+                s5h1420_writereg(state, Mpeg02, val | (1 << 6));
 
-                /* DC freeze */
-                s5h1420_writereg(state, 0x1f, s5h1420_readreg(state, 0x1f) | 0x01);
+                /* kicker disable */
+                val = s5h1420_readreg(state, QPSK01) & 0x7f;
+                s5h1420_writereg(state, QPSK01, val);
 
-                /* kicker disable + remove DC offset */
-                s5h1420_writereg(state, 0x05, s5h1420_readreg(state, 0x05) & 0x6f);
+                /* DC freeze TODO it was never activated by default or it can stay activated */
+
+                if (s5h1420_getsymbolrate(state) >= 20000000) {
+                        s5h1420_writereg(state, Loop04, 0x8a);
+                        s5h1420_writereg(state, Loop05, 0x6a);
+                } else {
+                        s5h1420_writereg(state, Loop04, 0x58);
+                        s5h1420_writereg(state, Loop05, 0x27);
+                }
 
                 /* post-lock processing has been done! */
                 state->postlocked = 1;
         }
 
+        dprintk("leave %s\n", __func__);
+
         return 0;
 }
 
@@ -414,6 +462,7 @@ static int s5h1420_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 
 static void s5h1420_reset(struct s5h1420_state* state)
 {
+        dprintk("%s\n", __func__);
         s5h1420_writereg (state, 0x01, 0x08);
         s5h1420_writereg (state, 0x01, 0x00);
         udelay(10);
@@ -422,54 +471,52 @@ static void s5h1420_reset(struct s5h1420_state* state)
 static void s5h1420_setsymbolrate(struct s5h1420_state* state,
                                   struct dvb_frontend_parameters *p)
 {
+        u8 v;
         u64 val;
 
+        dprintk("enter %s\n", __func__);
+
         val = ((u64) p->u.qpsk.symbol_rate / 1000ULL) * (1ULL<<24);
-        if (p->u.qpsk.symbol_rate <= 21000000) {
+        if (p->u.qpsk.symbol_rate < 29000000)
                 val *= 2;
-        }
         do_div(val, (state->fclk / 1000));
 
-        s5h1420_writereg(state, 0x09, s5h1420_readreg(state, 0x09) & 0x7f);
-        s5h1420_writereg(state, 0x11, val >> 16);
-        s5h1420_writereg(state, 0x12, val >> 8);
-        s5h1420_writereg(state, 0x13, val & 0xff);
-        s5h1420_writereg(state, 0x09, s5h1420_readreg(state, 0x09) | 0x80);
+        dprintk("symbol rate register: %06llx\n", val);
+
+        v = s5h1420_readreg(state, Loop01);
+        s5h1420_writereg(state, Loop01, v & 0x7f);
+        s5h1420_writereg(state, Tnco01, val >> 16);
+        s5h1420_writereg(state, Tnco02, val >> 8);
+        s5h1420_writereg(state, Tnco03, val & 0xff);
+        s5h1420_writereg(state, Loop01,  v | 0x80);
+        dprintk("leave %s\n", __func__);
 }
 
 static u32 s5h1420_getsymbolrate(struct s5h1420_state* state)
 {
-        u64 val = 0;
-        int sampling = 2;
-
-        if (s5h1420_readreg(state, 0x05) & 0x2)
-                sampling = 1;
-
-        s5h1420_writereg(state, 0x06, s5h1420_readreg(state, 0x06) | 0x08);
-        val  = s5h1420_readreg(state, 0x11) << 16;
-        val |= s5h1420_readreg(state, 0x12) << 8;
-        val |= s5h1420_readreg(state, 0x13);
-        s5h1420_writereg(state, 0x06, s5h1420_readreg(state, 0x06) & 0xf7);
-
-        val *= (state->fclk / 1000ULL);
-        do_div(val, ((1<<24) * sampling));
-
-        return (u32) (val * 1000ULL);
+        return state->symbol_rate;
 }
 
 static void s5h1420_setfreqoffset(struct s5h1420_state* state, int freqoffset)
 {
         int val;
+        u8 v;
+
+        dprintk("enter %s\n", __func__);
 
         /* remember freqoffset is in kHz, but the chip wants the offset in Hz, so
          * divide fclk by 1000000 to get the correct value. */
         val = -(int) ((freqoffset * (1<<24)) / (state->fclk / 1000000));
 
-        s5h1420_writereg(state, 0x09, s5h1420_readreg(state, 0x09) & 0xbf);
-        s5h1420_writereg(state, 0x0e, val >> 16);
-        s5h1420_writereg(state, 0x0f, val >> 8);
-        s5h1420_writereg(state, 0x10, val & 0xff);
-        s5h1420_writereg(state, 0x09, s5h1420_readreg(state, 0x09) | 0x40);
+        dprintk("phase rotator/freqoffset: %d %06x\n", freqoffset, val);
+
+        v = s5h1420_readreg(state, Loop01);
+        s5h1420_writereg(state, Loop01, v & 0xbf);
+        s5h1420_writereg(state, Pnco01, val >> 16);
+        s5h1420_writereg(state, Pnco02, val >> 8);
+        s5h1420_writereg(state, Pnco03, val & 0xff);
+        s5h1420_writereg(state, Loop01, v | 0x40);
+        dprintk("leave %s\n", __func__);
 }
 
 static int s5h1420_getfreqoffset(struct s5h1420_state* state)
@@ -496,52 +543,53 @@ static void s5h1420_setfec_inversion(struct s5h1420_state* state,
                                      struct dvb_frontend_parameters *p)
 {
         u8 inversion = 0;
+        u8 vit08, vit09;
+
+        dprintk("enter %s\n", __func__);
 
-        if (p->inversion == INVERSION_OFF) {
+        if (p->inversion == INVERSION_OFF)
                 inversion = state->config->invert ? 0x08 : 0;
-        } else if (p->inversion == INVERSION_ON) {
+        else if (p->inversion == INVERSION_ON)
                 inversion = state->config->invert ? 0 : 0x08;
-        }
 
         if ((p->u.qpsk.fec_inner == FEC_AUTO) || (p->inversion == INVERSION_AUTO)) {
-                s5h1420_writereg(state, 0x30, 0x3f);
-                s5h1420_writereg(state, 0x31, 0x00 | inversion);
+                vit08 = 0x3f;
+                vit09 = 0;
         } else {
                 switch(p->u.qpsk.fec_inner) {
                 case FEC_1_2:
-                        s5h1420_writereg(state, 0x30, 0x01);
-                        s5h1420_writereg(state, 0x31, 0x10 | inversion);
+                        vit08 = 0x01; vit09 = 0x10;
                         break;
 
                 case FEC_2_3:
-                        s5h1420_writereg(state, 0x30, 0x02);
-                        s5h1420_writereg(state, 0x31, 0x11 | inversion);
+                        vit08 = 0x02; vit09 = 0x11;
                         break;
 
                 case FEC_3_4:
-                        s5h1420_writereg(state, 0x30, 0x04);
-                        s5h1420_writereg(state, 0x31, 0x12 | inversion);
+                        vit08 = 0x04; vit09 = 0x12;
                         break;
 
                 case FEC_5_6:
-                        s5h1420_writereg(state, 0x30, 0x08);
-                        s5h1420_writereg(state, 0x31, 0x13 | inversion);
+                        vit08 = 0x08; vit09 = 0x13;
                         break;
 
                 case FEC_6_7:
-                        s5h1420_writereg(state, 0x30, 0x10);
-                        s5h1420_writereg(state, 0x31, 0x14 | inversion);
+                        vit08 = 0x10; vit09 = 0x14;
                         break;
 
                 case FEC_7_8:
-                        s5h1420_writereg(state, 0x30, 0x20);
-                        s5h1420_writereg(state, 0x31, 0x15 | inversion);
+                        vit08 = 0x20; vit09 = 0x15;
                         break;
 
                 default:
                         return;
                 }
         }
+        vit09 |= inversion;
+        dprintk("fec: %02x %02x\n", vit08, vit09);
+        s5h1420_writereg(state, Vit08, vit08);
+        s5h1420_writereg(state, Vit09, vit09);
+        dprintk("leave %s\n", __func__);
 }
 
 static fe_code_rate_t s5h1420_getfec(struct s5h1420_state* state)
@@ -583,16 +631,19 @@ static int s5h1420_set_frontend(struct dvb_frontend* fe,
         struct s5h1420_state* state = fe->demodulator_priv;
         int frequency_delta;
         struct dvb_frontend_tune_settings fesettings;
+        uint8_t clock_settting;
+
+        dprintk("enter %s\n", __func__);
 
         /* check if we should do a fast-tune */
         memcpy(&fesettings.parameters, p, sizeof(struct dvb_frontend_parameters));
         s5h1420_get_tune_settings(fe, &fesettings);
         frequency_delta = p->frequency - state->tunedfreq;
         if ((frequency_delta > -fesettings.max_drift) &&
-            (frequency_delta < fesettings.max_drift) &&
-            (frequency_delta != 0) &&
-            (state->fec_inner == p->u.qpsk.fec_inner) &&
-            (state->symbol_rate == p->u.qpsk.symbol_rate)) {
+                        (frequency_delta < fesettings.max_drift) &&
+                        (frequency_delta != 0) &&
+                        (state->fec_inner == p->u.qpsk.fec_inner) &&
+                        (state->symbol_rate == p->u.qpsk.symbol_rate)) {
 
                 if (fe->ops.tuner_ops.set_params) {
                         fe->ops.tuner_ops.set_params(fe, p);
@@ -606,54 +657,93 @@ static int s5h1420_set_frontend(struct dvb_frontend* fe,
                 } else {
                         s5h1420_setfreqoffset(state, 0);
                 }
+                dprintk("simple tune\n");
                 return 0;
         }
+        dprintk("tuning demod\n");
 
         /* first of all, software reset */
         s5h1420_reset(state);
 
         /* set s5h1420 fclk PLL according to desired symbol rate */
-        if (p->u.qpsk.symbol_rate > 28000000) {
-                state->fclk = 88000000;
-                s5h1420_writereg(state, 0x03, 0x50);
-                s5h1420_writereg(state, 0x04, 0x40);
-                s5h1420_writereg(state, 0x05, 0xae);
-        } else if (p->u.qpsk.symbol_rate > 21000000) {
+        if (p->u.qpsk.symbol_rate > 33000000)
+                state->fclk = 80000000;
+        else if (p->u.qpsk.symbol_rate > 28500000)
                 state->fclk = 59000000;
-                s5h1420_writereg(state, 0x03, 0x33);
-                s5h1420_writereg(state, 0x04, 0x40);
-                s5h1420_writereg(state, 0x05, 0xae);
-        } else {
+        else if (p->u.qpsk.symbol_rate > 25000000)
+                state->fclk = 86000000;
+        else if (p->u.qpsk.symbol_rate > 1900000)
                 state->fclk = 88000000;
-                s5h1420_writereg(state, 0x03, 0x50);
-                s5h1420_writereg(state, 0x04, 0x40);
-                s5h1420_writereg(state, 0x05, 0xac);
+        else
+                state->fclk = 44000000;
+
+        /* Clock */
+        switch (state->fclk) {
+        default:
+        case 88000000:
+                clock_settting = 80;
+                break;
+        case 86000000:
+                clock_settting = 78;
+                break;
+        case 80000000:
+                clock_settting = 72;
+                break;
+        case 59000000:
+                clock_settting = 51;
+                break;
+        case 44000000:
+                clock_settting = 36;
+                break;
         }
+        dprintk("pll01: %d, ToneFreq: %d\n", state->fclk/1000000 - 8, (state->fclk + (TONE_FREQ * 32) - 1) / (TONE_FREQ * 32));
+        s5h1420_writereg(state, PLL01, state->fclk/1000000 - 8);
+        s5h1420_writereg(state, PLL02, 0x40);
+        s5h1420_writereg(state, DiS01, (state->fclk + (TONE_FREQ * 32) - 1) / (TONE_FREQ * 32));
 
-        /* set misc registers */
-        s5h1420_writereg(state, 0x02, 0x00);
-        s5h1420_writereg(state, 0x06, 0x00);
-        s5h1420_writereg(state, 0x07, 0xb0);
-        s5h1420_writereg(state, 0x0a, 0xe7);
-        s5h1420_writereg(state, 0x0b, 0x78);
-        s5h1420_writereg(state, 0x0c, 0x48);
-        s5h1420_writereg(state, 0x0d, 0x6b);
-        s5h1420_writereg(state, 0x2e, 0x8e);
-        s5h1420_writereg(state, 0x35, 0x33);
-        s5h1420_writereg(state, 0x38, 0x01);
-        s5h1420_writereg(state, 0x39, 0x7d);
-        s5h1420_writereg(state, 0x3a, (state->fclk + (TONE_FREQ * 32) - 1) / (TONE_FREQ * 32));
-        s5h1420_writereg(state, 0x3c, 0x00);
-        s5h1420_writereg(state, 0x45, 0x61);
-        s5h1420_writereg(state, 0x46, 0x1d);
+        /* TODO DC offset removal, config parameter ? */
+        if (p->u.qpsk.symbol_rate > 29000000)
+                s5h1420_writereg(state, QPSK01, 0xae | 0x10);
+        else
+                s5h1420_writereg(state, QPSK01, 0xac | 0x10);
 
-        /* start QPSK */
-        s5h1420_writereg(state, 0x05, s5h1420_readreg(state, 0x05) | 1);
+        /* set misc registers */
+        s5h1420_writereg(state, CON_1, 0x00);
+        s5h1420_writereg(state, QPSK02, 0x00);
+        s5h1420_writereg(state, Pre01, 0xb0);
+
+        s5h1420_writereg(state, Loop01, 0xF0);
+        s5h1420_writereg(state, Loop02, 0x2a); /* e7 for s5h1420 */
+        s5h1420_writereg(state, Loop03, 0x79); /* 78 for s5h1420 */
+        if (p->u.qpsk.symbol_rate > 20000000)
+                s5h1420_writereg(state, Loop04, 0x79);
+        else
+                s5h1420_writereg(state, Loop04, 0x58);
+        s5h1420_writereg(state, Loop05, 0x6b);
+
+        if (p->u.qpsk.symbol_rate >= 8000000)
+                s5h1420_writereg(state, Post01, (0 << 6) | 0x10);
+        else if (p->u.qpsk.symbol_rate >= 4000000)
+                s5h1420_writereg(state, Post01, (1 << 6) | 0x10);
+        else
+                s5h1420_writereg(state, Post01, (3 << 6) | 0x10);
+
+        s5h1420_writereg(state, Monitor12, 0x00); /* unfreeze DC compensation */
+
+        s5h1420_writereg(state, Sync01, 0x33);
+        s5h1420_writereg(state, Mpeg01, state->config->cdclk_polarity);
+        s5h1420_writereg(state, Mpeg02, 0x3d); /* Parallel output more, disabled -> enabled later */
+        s5h1420_writereg(state, Err01, 0x03); /* 0x1d for s5h1420 */
+
+        s5h1420_writereg(state, Vit06, 0x6e); /* 0x8e for s5h1420 */
+        s5h1420_writereg(state, DiS03, 0x00);
+        s5h1420_writereg(state, Rf01, 0x61); /* Tuner i2c address - for the gate controller */
 
         /* set tuner PLL */
         if (fe->ops.tuner_ops.set_params) {
                 fe->ops.tuner_ops.set_params(fe, p);
-                if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 0);
                 s5h1420_setfreqoffset(state, 0);
         }
 
@@ -661,10 +751,15 @@ static int s5h1420_set_frontend(struct dvb_frontend* fe,
         s5h1420_setsymbolrate(state, p);
         s5h1420_setfec_inversion(state, p);
 
+        /* start QPSK */
+        s5h1420_writereg(state, QPSK01, s5h1420_readreg(state, QPSK01) | 1);
+
         state->fec_inner = p->u.qpsk.fec_inner;
         state->symbol_rate = p->u.qpsk.symbol_rate;
         state->postlocked = 0;
         state->tunedfreq = p->frequency;
+
+        dprintk("leave %s\n", __func__);
         return 0;
 }
 
@@ -717,11 +812,10 @@ static int s5h1420_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 {
         struct s5h1420_state* state = fe->demodulator_priv;
 
-        if (enable) {
-                return s5h1420_writereg (state, 0x02, s5h1420_readreg(state,0x02) | 1);
-        } else {
-                return s5h1420_writereg (state, 0x02, s5h1420_readreg(state,0x02) & 0xfe);
-        }
+        if (enable)
+                return s5h1420_writereg(state, 0x02, state->CON_1_val | 1);
+        else
+                return s5h1420_writereg(state, 0x02, state->CON_1_val & 0xfe);
 }
 
 static int s5h1420_init (struct dvb_frontend* fe)
@@ -729,7 +823,8 @@ static int s5h1420_init (struct dvb_frontend* fe)
         struct s5h1420_state* state = fe->demodulator_priv;
 
         /* disable power down and do reset */
-        s5h1420_writereg(state, 0x02, 0x10);
+        state->CON_1_val = 0x10;
+        s5h1420_writereg(state, 0x02, state->CON_1_val);
         msleep(10);
         s5h1420_reset(state);
 
@@ -739,26 +834,60 @@ static int s5h1420_init (struct dvb_frontend* fe)
 static int s5h1420_sleep(struct dvb_frontend* fe)
 {
         struct s5h1420_state* state = fe->demodulator_priv;
-
-        return s5h1420_writereg(state, 0x02, 0x12);
+        state->CON_1_val = 0x12;
+        return s5h1420_writereg(state, 0x02, state->CON_1_val);
 }
 
 static void s5h1420_release(struct dvb_frontend* fe)
 {
         struct s5h1420_state* state = fe->demodulator_priv;
+        i2c_del_adapter(&state->tuner_i2c_adapter);
         kfree(state);
 }
 
-static struct dvb_frontend_ops s5h1420_ops;
+static u32 s5h1420_tuner_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static int s5h1420_tuner_i2c_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
+{
+        struct s5h1420_state *state = i2c_get_adapdata(i2c_adap);
+        struct i2c_msg m[1 + num];
+        u8 tx_open[2] = { CON_1, state->CON_1_val | 1 }; /* repeater stops once there was a stop condition */
+
+        memset(m, 0, sizeof(struct i2c_msg) * (1 + num));
+
+        m[0].addr = state->config->demod_address;
+        m[0].buf  = tx_open;
+        m[0].len  = 2;
 
-struct dvb_frontend* s5h1420_attach(const struct s5h1420_config* config,
-                                    struct i2c_adapter* i2c)
+        memcpy(&m[1], msg, sizeof(struct i2c_msg) * num);
+
+        return i2c_transfer(state->i2c, m, 1+num) == 1 + num ? num : -EIO;
+}
+
+static struct i2c_algorithm s5h1420_tuner_i2c_algo = {
+        .master_xfer   = s5h1420_tuner_i2c_tuner_xfer,
+        .functionality = s5h1420_tuner_i2c_func,
+};
+
+struct i2c_adapter *s5h1420_get_tuner_i2c_adapter(struct dvb_frontend *fe)
 {
-        struct s5h1420_state* state = NULL;
-        u8 identity;
+        struct s5h1420_state *state = fe->demodulator_priv;
+        return &state->tuner_i2c_adapter;
+}
+EXPORT_SYMBOL(s5h1420_get_tuner_i2c_adapter);
+
+static struct dvb_frontend_ops s5h1420_ops;
 
+struct dvb_frontend *s5h1420_attach(const struct s5h1420_config *config,
+                                    struct i2c_adapter *i2c)
+{
         /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct s5h1420_state), GFP_KERNEL);
+        struct s5h1420_state *state = kzalloc(sizeof(struct s5h1420_state), GFP_KERNEL);
+        u8 i;
+
         if (state == NULL)
                 goto error;
 
@@ -772,24 +901,42 @@ struct dvb_frontend* s5h1420_attach(const struct s5h1420_config* config,
         state->symbol_rate = 0;
 
         /* check if the demod is there + identify it */
-        identity = s5h1420_readreg(state, 0x00);
-        if (identity != 0x03)
+        i = s5h1420_readreg(state, ID01);
+        if (i != 0x03)
                 goto error;
 
+        memset(state->shadow, 0xff, sizeof(state->shadow));
+
+        for (i = 0; i < 0x50; i++)
+                state->shadow[i] = s5h1420_readreg(state, i);
+
         /* create dvb_frontend */
         memcpy(&state->frontend.ops, &s5h1420_ops, sizeof(struct dvb_frontend_ops));
         state->frontend.demodulator_priv = state;
+
+        /* create tuner i2c adapter */
+        strncpy(state->tuner_i2c_adapter.name, "S5H1420-PN1010 tuner I2C bus", I2C_NAME_SIZE);
+        state->tuner_i2c_adapter.class     = I2C_CLASS_TV_DIGITAL,
+        state->tuner_i2c_adapter.algo      = &s5h1420_tuner_i2c_algo;
+        state->tuner_i2c_adapter.algo_data = NULL;
+        i2c_set_adapdata(&state->tuner_i2c_adapter, state);
+        if (i2c_add_adapter(&state->tuner_i2c_adapter) < 0) {
+                printk(KERN_ERR "S5H1420/PN1010: tuner i2c bus could not be initialized\n");
+                goto error;
+        }
+
         return &state->frontend;
 
 error:
         kfree(state);
         return NULL;
 }
+EXPORT_SYMBOL(s5h1420_attach);
 
 static struct dvb_frontend_ops s5h1420_ops = {
 
         .info = {
-                .name     = "Samsung S5H1420 DVB-S",
+                .name     = "Samsung S5H1420/PnpNetwork PN1010 DVB-S",
                 .type     = FE_QPSK,
                 .frequency_min    = 950000,
                 .frequency_max    = 2150000,
@@ -826,10 +973,6 @@ static struct dvb_frontend_ops s5h1420_ops = {
         .set_voltage = s5h1420_set_voltage,
 };
 
-module_param(debug, int, 0644);
-
-MODULE_DESCRIPTION("Samsung S5H1420 DVB-S Demodulator driver");
-MODULE_AUTHOR("Andrew de Quincey");
+MODULE_DESCRIPTION("Samsung S5H1420/PnpNetwork PN1010 DVB-S Demodulator driver");
+MODULE_AUTHOR("Andrew de Quincey, Patrick Boettcher");
 MODULE_LICENSE("GPL");
-
-EXPORT_SYMBOL(s5h1420_attach);
diff --git a/drivers/media/dvb/frontends/s5h1420.h b/drivers/media/dvb/frontends/s5h1420.h
index 1555870f7226..4c913f142bc4 100644
--- a/drivers/media/dvb/frontends/s5h1420.h
+++ b/drivers/media/dvb/frontends/s5h1420.h
@@ -1,25 +1,26 @@
 /*
-    Driver for S5H1420 QPSK Demodulators
-
-    Copyright (C) 2005 Andrew de Quincey <adq_dvb@lidskialf.net>
-
-    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.
-
-*/
-
+ * Driver for
+ *    Samsung S5H1420 and
+ *    PnpNetwork PN1010 QPSK Demodulator
+ *
+ * Copyright (C) 2005 Andrew de Quincey <adq_dvb@lidskialf.net>
+ * Copyright (C) 2005-8 Patrick Boettcher <pb@linuxtv.org>
+ *
+ * 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 S5H1420_H
 #define S5H1420_H
 
@@ -31,17 +32,26 @@ struct s5h1420_config
         u8 demod_address;
 
         /* does the inversion require inversion? */
-        u8 invert:1;
+        u8 invert : 1;
+
+        u8 repeated_start_workaround : 1;
+        u8 cdclk_polarity : 1; /* 1 == falling edge, 0 == raising edge */
 };
 
 #if defined(CONFIG_DVB_S5H1420) || (defined(CONFIG_DVB_S5H1420_MODULE) && defined(MODULE))
-extern struct dvb_frontend* s5h1420_attach(const struct s5h1420_config* config,
-             struct i2c_adapter* i2c);
+extern struct dvb_frontend *s5h1420_attach(const struct s5h1420_config *config,
+             struct i2c_adapter *i2c);
+extern struct i2c_adapter *s5h1420_get_tuner_i2c_adapter(struct dvb_frontend *fe);
 #else
-static inline struct dvb_frontend* s5h1420_attach(const struct s5h1420_config* config,
-                                           struct i2c_adapter* i2c)
+static inline struct dvb_frontend *s5h1420_attach(const struct s5h1420_config *config,
+                                           struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+
+static inline struct i2c_adapter *s5h1420_get_tuner_i2c_adapter(struct dvb_frontend *fe)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
         return NULL;
 }
 #endif // CONFIG_DVB_S5H1420
diff --git a/drivers/media/dvb/frontends/s5h1420_priv.h b/drivers/media/dvb/frontends/s5h1420_priv.h
new file mode 100644
index 000000000000..d9c58d281816
--- /dev/null
+++ b/drivers/media/dvb/frontends/s5h1420_priv.h
@@ -0,0 +1,102 @@
+/*
+ * Driver for
+ *    Samsung S5H1420 and
+ *    PnpNetwork PN1010 QPSK Demodulator
+ *
+ * Copyright (C) 2005 Andrew de Quincey <adq_dvb@lidskialf.net>
+ * Copyright (C) 2005 Patrick Boettcher <pb@linuxtv.org>
+ *
+ * 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 S5H1420_PRIV
+#define S5H1420_PRIV
+
+#include <asm/types.h>
+
+enum s5h1420_register {
+        ID01      = 0x00,
+        CON_0     = 0x01,
+        CON_1     = 0x02,
+        PLL01     = 0x03,
+        PLL02     = 0x04,
+        QPSK01    = 0x05,
+        QPSK02    = 0x06,
+        Pre01     = 0x07,
+        Post01    = 0x08,
+        Loop01    = 0x09,
+        Loop02    = 0x0a,
+        Loop03    = 0x0b,
+        Loop04    = 0x0c,
+        Loop05    = 0x0d,
+        Pnco01    = 0x0e,
+        Pnco02    = 0x0f,
+        Pnco03    = 0x10,
+        Tnco01    = 0x11,
+        Tnco02    = 0x12,
+        Tnco03    = 0x13,
+        Monitor01 = 0x14,
+        Monitor02 = 0x15,
+        Monitor03 = 0x16,
+        Monitor04 = 0x17,
+        Monitor05 = 0x18,
+        Monitor06 = 0x19,
+        Monitor07 = 0x1a,
+        Monitor12 = 0x1f,
+
+        FEC01     = 0x22,
+        Soft01    = 0x23,
+        Soft02    = 0x24,
+        Soft03    = 0x25,
+        Soft04    = 0x26,
+        Soft05    = 0x27,
+        Soft06    = 0x28,
+        Vit01     = 0x29,
+        Vit02     = 0x2a,
+        Vit03     = 0x2b,
+        Vit04     = 0x2c,
+        Vit05     = 0x2d,
+        Vit06     = 0x2e,
+        Vit07     = 0x2f,
+        Vit08     = 0x30,
+        Vit09     = 0x31,
+        Vit10     = 0x32,
+        Vit11     = 0x33,
+        Vit12     = 0x34,
+        Sync01    = 0x35,
+        Sync02    = 0x36,
+        Rs01      = 0x37,
+        Mpeg01    = 0x38,
+        Mpeg02    = 0x39,
+        DiS01     = 0x3a,
+        DiS02     = 0x3b,
+        DiS03     = 0x3c,
+        DiS04     = 0x3d,
+        DiS05     = 0x3e,
+        DiS06     = 0x3f,
+        DiS07     = 0x40,
+        DiS08     = 0x41,
+        DiS09     = 0x42,
+        DiS10     = 0x43,
+        DiS11     = 0x44,
+        Rf01      = 0x45,
+        Err01     = 0x46,
+        Err02     = 0x47,
+        Err03     = 0x48,
+        Err04     = 0x49,
+};
+
+
+#endif
diff --git a/drivers/media/dvb/frontends/sp8870.c b/drivers/media/dvb/frontends/sp8870.c
index da876f7bfe32..aa78aa14aad9 100644
--- a/drivers/media/dvb/frontends/sp8870.c
+++ b/drivers/media/dvb/frontends/sp8870.c
@@ -70,7 +70,7 @@ static int sp8870_writereg (struct sp8870_state* state, u16 reg, u16 data)
         int err;
 
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
-                dprintk ("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __FUNCTION__, err, reg, data);
+                dprintk ("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __func__, err, reg, data);
                 return -EREMOTEIO;
         }
 
@@ -88,7 +88,7 @@ static int sp8870_readreg (struct sp8870_state* state, u16 reg)
         ret = i2c_transfer (state->i2c, msg, 2);
 
         if (ret != 2) {
-                dprintk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
+                dprintk("%s: readreg error (ret == %i)\n", __func__, ret);
                 return -1;
         }
 
@@ -104,7 +104,7 @@ static int sp8870_firmware_upload (struct sp8870_state* state, const struct firm
         int tx_len;
         int err = 0;
 
-        dprintk ("%s: ...\n", __FUNCTION__);
+        dprintk ("%s: ...\n", __func__);
 
         if (fw->size < SP8870_FIRMWARE_SIZE + SP8870_FIRMWARE_OFFSET)
                 return -EINVAL;
@@ -131,14 +131,14 @@ static int sp8870_firmware_upload (struct sp8870_state* state, const struct firm
                 msg.buf = tx_buf;
                 msg.len = tx_len + 2;
                 if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
-                        printk("%s: firmware upload failed!\n", __FUNCTION__);
-                        printk ("%s: i2c error (err == %i)\n", __FUNCTION__, err);
+                        printk("%s: firmware upload failed!\n", __func__);
+                        printk ("%s: i2c error (err == %i)\n", __func__, err);
                         return err;
                 }
                 fw_pos += tx_len;
         }
 
-        dprintk ("%s: done!\n", __FUNCTION__);
+        dprintk ("%s: done!\n", __func__);
         return 0;
 };
 
@@ -310,7 +310,7 @@ static int sp8870_init (struct dvb_frontend* fe)
         if (state->initialised) return 0;
         state->initialised = 1;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
 
         /* request the firmware, this will block until someone uploads it */
@@ -449,15 +449,15 @@ static int sp8870_read_uncorrected_blocks (struct dvb_frontend* fe, u32* ublocks
         return 0;
 }
 
-// number of trials to recover from lockup
+/* number of trials to recover from lockup */
 #define MAXTRIALS 5
-// maximum checks for data valid signal
+/* maximum checks for data valid signal */
 #define MAXCHECKS 100
 
-// only for debugging: counter for detected lockups
-static int lockups = 0;
-// only for debugging: counter for channel switches
-static int switches = 0;
+/* only for debugging: counter for detected lockups */
+static int lockups;
+/* only for debugging: counter for channel switches */
+static int switches;
 
 static int sp8870_set_frontend (struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 {
@@ -475,7 +475,7 @@ static int sp8870_set_frontend (struct dvb_frontend* fe, struct dvb_frontend_par
         int trials = 0;
         int check_count = 0;
 
-        dprintk("%s: frequency = %i\n", __FUNCTION__, p->frequency);
+        dprintk("%s: frequency = %i\n", __func__, p->frequency);
 
         for (trials = 1; trials <= MAXTRIALS; trials++) {
 
@@ -487,7 +487,7 @@ static int sp8870_set_frontend (struct dvb_frontend* fe, struct dvb_frontend_par
                         valid = sp8870_read_data_valid_signal(state);
                         if (valid) {
                                 dprintk("%s: delay = %i usec\n",
-                                        __FUNCTION__, check_count * 10);
+                                        __func__, check_count * 10);
                                 break;
                         }
                         udelay(10);
@@ -497,20 +497,20 @@ static int sp8870_set_frontend (struct dvb_frontend* fe, struct dvb_frontend_par
         }
 
         if (!valid) {
-                printk("%s: firmware crash!!!!!!\n", __FUNCTION__);
+                printk("%s: firmware crash!!!!!!\n", __func__);
                 return -EIO;
         }
 
         if (debug) {
                 if (valid) {
                         if (trials > 1) {
-                                printk("%s: firmware lockup!!!\n", __FUNCTION__);
-                                printk("%s: recovered after %i trial(s))\n",  __FUNCTION__, trials - 1);
+                                printk("%s: firmware lockup!!!\n", __func__);
+                                printk("%s: recovered after %i trial(s))\n",  __func__, trials - 1);
                                 lockups++;
                         }
                 }
                 switches++;
-                printk("%s: switches = %i lockups = %i\n", __FUNCTION__, switches, lockups);
+                printk("%s: switches = %i lockups = %i\n", __func__, switches, lockups);
         }
 
         return 0;
diff --git a/drivers/media/dvb/frontends/sp8870.h b/drivers/media/dvb/frontends/sp8870.h
index 909cefe7139e..a764a793c7d8 100644
--- a/drivers/media/dvb/frontends/sp8870.h
+++ b/drivers/media/dvb/frontends/sp8870.h
@@ -42,7 +42,7 @@ extern struct dvb_frontend* sp8870_attach(const struct sp8870_config* config,
 static inline struct dvb_frontend* sp8870_attach(const struct sp8870_config* config,
                                           struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_SP8870
diff --git a/drivers/media/dvb/frontends/sp887x.c b/drivers/media/dvb/frontends/sp887x.c
index 1aa2539f5099..49f55877f513 100644
--- a/drivers/media/dvb/frontends/sp887x.c
+++ b/drivers/media/dvb/frontends/sp887x.c
@@ -43,7 +43,7 @@ static int i2c_writebytes (struct sp887x_state* state, u8 *buf, u8 len)
 
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
                 printk ("%s: i2c write error (addr %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
+                        __func__, state->config->demod_address, err);
                 return -EREMOTEIO;
         }
 
@@ -65,7 +65,7 @@ static int sp887x_writereg (struct sp887x_state* state, u16 reg, u16 data)
                 {
                         printk("%s: writereg error "
                                "(reg %03x, data %03x, ret == %i)\n",
-                               __FUNCTION__, reg & 0xffff, data & 0xffff, ret);
+                               __func__, reg & 0xffff, data & 0xffff, ret);
                         return ret;
                 }
         }
@@ -82,7 +82,7 @@ static int sp887x_readreg (struct sp887x_state* state, u16 reg)
                          { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 2 }};
 
         if ((ret = i2c_transfer(state->i2c, msg, 2)) != 2) {
-                printk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
+                printk("%s: readreg error (ret == %i)\n", __func__, ret);
                 return -1;
         }
 
@@ -91,7 +91,7 @@ static int sp887x_readreg (struct sp887x_state* state, u16 reg)
 
 static void sp887x_microcontroller_stop (struct sp887x_state* state)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         sp887x_writereg(state, 0xf08, 0x000);
         sp887x_writereg(state, 0xf09, 0x000);
 
@@ -101,7 +101,7 @@ static void sp887x_microcontroller_stop (struct sp887x_state* state)
 
 static void sp887x_microcontroller_start (struct sp887x_state* state)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         sp887x_writereg(state, 0xf08, 0x000);
         sp887x_writereg(state, 0xf09, 0x000);
 
@@ -112,7 +112,7 @@ static void sp887x_microcontroller_start (struct sp887x_state* state)
 static void sp887x_setup_agc (struct sp887x_state* state)
 {
         /* setup AGC parameters */
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         sp887x_writereg(state, 0x33c, 0x054);
         sp887x_writereg(state, 0x33b, 0x04c);
         sp887x_writereg(state, 0x328, 0x000);
@@ -142,7 +142,7 @@ static int sp887x_initial_setup (struct dvb_frontend* fe, const struct firmware
         int fw_size = fw->size;
         unsigned char *mem = fw->data;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         /* ignore the first 10 bytes, then we expect 0x4000 bytes of firmware */
         if (fw_size < FW_SIZE+10)
@@ -155,7 +155,7 @@ static int sp887x_initial_setup (struct dvb_frontend* fe, const struct firmware
 
         sp887x_microcontroller_stop (state);
 
-        printk ("%s: firmware upload... ", __FUNCTION__);
+        printk ("%s: firmware upload... ", __func__);
 
         /* setup write pointer to -1 (end of memory) */
         /* bit 0x8000 in address is set to enable 13bit mode */
@@ -181,7 +181,7 @@ static int sp887x_initial_setup (struct dvb_frontend* fe, const struct firmware
 
                 if ((err = i2c_writebytes (state, buf, c+2)) < 0) {
                         printk ("failed.\n");
-                        printk ("%s: i2c error (err == %i)\n", __FUNCTION__, err);
+                        printk ("%s: i2c error (err == %i)\n", __func__, err);
                         return err;
                 }
         }
diff --git a/drivers/media/dvb/frontends/sp887x.h b/drivers/media/dvb/frontends/sp887x.h
index 7ee78d7d916d..04eff6e0eef3 100644
--- a/drivers/media/dvb/frontends/sp887x.h
+++ b/drivers/media/dvb/frontends/sp887x.h
@@ -24,7 +24,7 @@ extern struct dvb_frontend* sp887x_attach(const struct sp887x_config* config,
 static inline struct dvb_frontend* sp887x_attach(const struct sp887x_config* config,
                                           struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_SP887X
diff --git a/drivers/media/dvb/frontends/stv0297.c b/drivers/media/dvb/frontends/stv0297.c
index 7c23775f77db..62caf802ed99 100644
--- a/drivers/media/dvb/frontends/stv0297.c
+++ b/drivers/media/dvb/frontends/stv0297.c
@@ -58,7 +58,7 @@ static int stv0297_writereg(struct stv0297_state *state, u8 reg, u8 data)
 
         if (ret != 1)
                 dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
-                        "ret == %i)\n", __FUNCTION__, reg, data, ret);
+                        "ret == %i)\n", __func__, reg, data, ret);
 
         return (ret != 1) ? -1 : 0;
 }
@@ -75,16 +75,16 @@ static int stv0297_readreg(struct stv0297_state *state, u8 reg)
         // this device needs a STOP between the register and data
         if (state->config->stop_during_read) {
                 if ((ret = i2c_transfer(state->i2c, &msg[0], 1)) != 1) {
-                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg, ret);
+                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __func__, reg, ret);
                         return -1;
                 }
                 if ((ret = i2c_transfer(state->i2c, &msg[1], 1)) != 1) {
-                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg, ret);
+                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __func__, reg, ret);
                         return -1;
                 }
         } else {
                 if ((ret = i2c_transfer(state->i2c, msg, 2)) != 2) {
-                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg, ret);
+                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __func__, reg, ret);
                         return -1;
                 }
         }
@@ -115,16 +115,16 @@ static int stv0297_readregs(struct stv0297_state *state, u8 reg1, u8 * b, u8 len
         // this device needs a STOP between the register and data
         if (state->config->stop_during_read) {
                 if ((ret = i2c_transfer(state->i2c, &msg[0], 1)) != 1) {
-                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg1, ret);
+                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __func__, reg1, ret);
                         return -1;
                 }
                 if ((ret = i2c_transfer(state->i2c, &msg[1], 1)) != 1) {
-                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg1, ret);
+                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __func__, reg1, ret);
                         return -1;
                 }
         } else {
                 if ((ret = i2c_transfer(state->i2c, msg, 2)) != 2) {
-                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg1, ret);
+                        dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __func__, reg1, ret);
                         return -1;
                 }
         }
diff --git a/drivers/media/dvb/frontends/stv0297.h b/drivers/media/dvb/frontends/stv0297.h
index 69f4515df2b9..3f8f9468f387 100644
--- a/drivers/media/dvb/frontends/stv0297.h
+++ b/drivers/media/dvb/frontends/stv0297.h
@@ -49,7 +49,7 @@ extern struct dvb_frontend* stv0297_attach(const struct stv0297_config* config,
 static inline struct dvb_frontend* stv0297_attach(const struct stv0297_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_STV0297
diff --git a/drivers/media/dvb/frontends/stv0299.c b/drivers/media/dvb/frontends/stv0299.c
index 035dd7ba6519..17556183e871 100644
--- a/drivers/media/dvb/frontends/stv0299.c
+++ b/drivers/media/dvb/frontends/stv0299.c
@@ -86,7 +86,7 @@ static int stv0299_writeregI (struct stv0299_state* state, u8 reg, u8 data)
 
         if (ret != 1)
                 dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
-                        "ret == %i)\n", __FUNCTION__, reg, data, ret);
+                        "ret == %i)\n", __func__, reg, data, ret);
 
         return (ret != 1) ? -EREMOTEIO : 0;
 }
@@ -113,7 +113,7 @@ static u8 stv0299_readreg (struct stv0299_state* state, u8 reg)
 
         if (ret != 2)
                 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n",
-                                __FUNCTION__, reg, ret);
+                                __func__, reg, ret);
 
         return b1[0];
 }
@@ -127,14 +127,14 @@ static int stv0299_readregs (struct stv0299_state* state, u8 reg1, u8 *b, u8 len
         ret = i2c_transfer (state->i2c, msg, 2);
 
         if (ret != 2)
-                dprintk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
+                dprintk("%s: readreg error (ret == %i)\n", __func__, ret);
 
         return ret == 2 ? 0 : ret;
 }
 
 static int stv0299_set_FEC (struct stv0299_state* state, fe_code_rate_t fec)
 {
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         switch (fec) {
         case FEC_AUTO:
@@ -174,7 +174,7 @@ static fe_code_rate_t stv0299_get_fec (struct stv0299_state* state)
                                              FEC_7_8, FEC_1_2 };
         u8 index;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         index = stv0299_readreg (state, 0x1b);
         index &= 0x7;
@@ -189,11 +189,11 @@ static int stv0299_wait_diseqc_fifo (struct stv0299_state* state, int timeout)
 {
         unsigned long start = jiffies;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         while (stv0299_readreg(state, 0x0a) & 1) {
                 if (jiffies - start > timeout) {
-                        dprintk ("%s: timeout!!\n", __FUNCTION__);
+                        dprintk ("%s: timeout!!\n", __func__);
                         return -ETIMEDOUT;
                 }
                 msleep(10);
@@ -206,11 +206,11 @@ static int stv0299_wait_diseqc_idle (struct stv0299_state* state, int timeout)
 {
         unsigned long start = jiffies;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         while ((stv0299_readreg(state, 0x0a) & 3) != 2 ) {
                 if (jiffies - start > timeout) {
-                        dprintk ("%s: timeout!!\n", __FUNCTION__);
+                        dprintk ("%s: timeout!!\n", __func__);
                         return -ETIMEDOUT;
                 }
                 msleep(10);
@@ -245,7 +245,7 @@ static int stv0299_get_symbolrate (struct stv0299_state* state)
         u8 sfr[3];
         s8 rtf;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         stv0299_readregs (state, 0x1f, sfr, 3);
         stv0299_readregs (state, 0x1a, (u8 *)&rtf, 1);
@@ -257,8 +257,8 @@ static int stv0299_get_symbolrate (struct stv0299_state* state)
         offset = (s32) rtf * (srate / 4096L);
         offset /= 128;
 
-        dprintk ("%s : srate = %i\n", __FUNCTION__, srate);
-        dprintk ("%s : ofset = %i\n", __FUNCTION__, offset);
+        dprintk ("%s : srate = %i\n", __func__, srate);
+        dprintk ("%s : ofset = %i\n", __func__, offset);
 
         srate += offset;
 
@@ -276,7 +276,7 @@ static int stv0299_send_diseqc_msg (struct dvb_frontend* fe,
         u8 val;
         int i;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (stv0299_wait_diseqc_idle (state, 100) < 0)
                 return -ETIMEDOUT;
@@ -305,7 +305,7 @@ static int stv0299_send_diseqc_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t
         struct stv0299_state* state = fe->demodulator_priv;
         u8 val;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (stv0299_wait_diseqc_idle (state, 100) < 0)
                 return -ETIMEDOUT;
@@ -355,7 +355,7 @@ static int stv0299_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltag
         u8 reg0x08;
         u8 reg0x0c;
 
-        dprintk("%s: %s\n", __FUNCTION__,
+        dprintk("%s: %s\n", __func__,
                 voltage == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
                 voltage == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
 
@@ -366,26 +366,32 @@ static int stv0299_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltag
          *  H/V switching over OP0, OP1 and OP2 are LNB power enable bits
          */
         reg0x0c &= 0x0f;
-
-        if (voltage == SEC_VOLTAGE_OFF) {
-                stv0299_writeregI (state, 0x0c, 0x00); /*       LNB power off! */
-                return stv0299_writeregI (state, 0x08, 0x00); /*        LNB power off! */
-        }
-
-        stv0299_writeregI (state, 0x08, (reg0x08 & 0x3f) | (state->config->lock_output << 6));
+        reg0x08 = (reg0x08 & 0x3f) | (state->config->lock_output << 6);
 
         switch (voltage) {
         case SEC_VOLTAGE_13:
-                if (state->config->volt13_op0_op1 == STV0299_VOLT13_OP0) reg0x0c |= 0x10;
-                else reg0x0c |= 0x40;
-
-                return stv0299_writeregI(state, 0x0c, reg0x0c);
-
+                if (state->config->volt13_op0_op1 == STV0299_VOLT13_OP0)
+                        reg0x0c |= 0x10; /* OP1 off, OP0 on */
+                else
+                        reg0x0c |= 0x40; /* OP1 on, OP0 off */
+                break;
         case SEC_VOLTAGE_18:
-                return stv0299_writeregI(state, 0x0c, reg0x0c | 0x50);
+                reg0x0c |= 0x50; /* OP1 on, OP0 on */
+                break;
+        case SEC_VOLTAGE_OFF:
+                /* LNB power off! */
+                reg0x08 = 0x00;
+                reg0x0c = 0x00;
+                break;
         default:
                 return -EINVAL;
         };
+
+        if (state->config->op0_off)
+                reg0x0c &= ~0x10;
+
+        stv0299_writeregI(state, 0x08, reg0x08);
+        return stv0299_writeregI(state, 0x0c, reg0x0c);
 }
 
 static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long cmd)
@@ -408,7 +414,7 @@ static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long
 
         cmd = cmd << 1;
         if (debug_legacy_dish_switch)
-                printk ("%s switch command: 0x%04lx\n",__FUNCTION__, cmd);
+                printk ("%s switch command: 0x%04lx\n",__func__, cmd);
 
         do_gettimeofday (&nexttime);
         if (debug_legacy_dish_switch)
@@ -433,7 +439,7 @@ static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long
         }
         if (debug_legacy_dish_switch) {
                 printk ("%s(%d): switch delay (should be 32k followed by all 8k\n",
-                        __FUNCTION__, fe->dvb->num);
+                        __func__, fe->dvb->num);
                 for (i = 1; i < 10; i++)
                         printk ("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i]));
         }
@@ -445,11 +451,20 @@ static int stv0299_init (struct dvb_frontend* fe)
 {
         struct stv0299_state* state = fe->demodulator_priv;
         int i;
+        u8 reg;
+        u8 val;
 
         dprintk("stv0299: init chip\n");
 
-        for (i=0; !(state->config->inittab[i] == 0xff && state->config->inittab[i+1] == 0xff); i+=2)
-                stv0299_writeregI(state, state->config->inittab[i], state->config->inittab[i+1]);
+        for (i = 0; ; i += 2)  {
+                reg = state->config->inittab[i];
+                val = state->config->inittab[i+1];
+                if (reg == 0xff && val == 0xff)
+                        break;
+                if (reg == 0x0c && state->config->op0_off)
+                        val &= ~0x10;
+                stv0299_writeregI(state, reg, val);
+        }
 
         return 0;
 }
@@ -461,7 +476,7 @@ static int stv0299_read_status(struct dvb_frontend* fe, fe_status_t* status)
         u8 signal = 0xff - stv0299_readreg (state, 0x18);
         u8 sync = stv0299_readreg (state, 0x1b);
 
-        dprintk ("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __FUNCTION__, sync);
+        dprintk ("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);
         *status = 0;
 
         if (signal > 10)
@@ -499,7 +514,7 @@ static int stv0299_read_signal_strength(struct dvb_frontend* fe, u16* strength)
         s32 signal =  0xffff - ((stv0299_readreg (state, 0x18) << 8)
                                | stv0299_readreg (state, 0x19));
 
-        dprintk ("%s : FE_READ_SIGNAL_STRENGTH : AGC2I: 0x%02x%02x, signal=0x%04x\n", __FUNCTION__,
+        dprintk ("%s : FE_READ_SIGNAL_STRENGTH : AGC2I: 0x%02x%02x, signal=0x%04x\n", __func__,
                  stv0299_readreg (state, 0x18),
                  stv0299_readreg (state, 0x19), (int) signal);
 
@@ -536,7 +551,7 @@ static int stv0299_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_par
         struct stv0299_state* state = fe->demodulator_priv;
         int invval = 0;
 
-        dprintk ("%s : FE_SET_FRONTEND\n", __FUNCTION__);
+        dprintk ("%s : FE_SET_FRONTEND\n", __func__);
 
         // set the inversion
         if (p->inversion == INVERSION_OFF) invval = 0;
diff --git a/drivers/media/dvb/frontends/stv0299.h b/drivers/media/dvb/frontends/stv0299.h
index 33df9495908f..3282f43022f5 100644
--- a/drivers/media/dvb/frontends/stv0299.h
+++ b/drivers/media/dvb/frontends/stv0299.h
@@ -48,10 +48,10 @@
 #include <linux/dvb/frontend.h>
 #include "dvb_frontend.h"
 
-#define STV0229_LOCKOUTPUT_0  0
-#define STV0229_LOCKOUTPUT_1  1
-#define STV0229_LOCKOUTPUT_CF 2
-#define STV0229_LOCKOUTPUT_LK 3
+#define STV0299_LOCKOUTPUT_0  0
+#define STV0299_LOCKOUTPUT_1  1
+#define STV0299_LOCKOUTPUT_CF 2
+#define STV0299_LOCKOUTPUT_LK 3
 
 #define STV0299_VOLT13_OP0 0
 #define STV0299_VOLT13_OP1 1
@@ -82,6 +82,9 @@ struct stv0299_config
         /* Is 13v controlled by OP0 or OP1? */
         u8 volt13_op0_op1:1;
 
+        /* Turn-off OP0? */
+        u8 op0_off:1;
+
         /* minimum delay before retuning */
         int min_delay_ms;
 
@@ -96,7 +99,7 @@ extern struct dvb_frontend* stv0299_attach(const struct stv0299_config* config,
 static inline struct dvb_frontend* stv0299_attach(const struct stv0299_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_STV0299
diff --git a/drivers/media/dvb/frontends/tda10021.c b/drivers/media/dvb/frontends/tda10021.c
index 45137d2ebfb9..f648fdb64bb7 100644
--- a/drivers/media/dvb/frontends/tda10021.c
+++ b/drivers/media/dvb/frontends/tda10021.c
@@ -79,7 +79,7 @@ static int _tda10021_writereg (struct tda10021_state* state, u8 reg, u8 data)
         if (ret != 1)
                 printk("DVB: TDA10021(%d): %s, writereg error "
                         "(reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        state->frontend.dvb->num, __FUNCTION__, reg, data, ret);
+                        state->frontend.dvb->num, __func__, reg, data, ret);
 
         msleep(10);
         return (ret != 1) ? -EREMOTEIO : 0;
@@ -97,7 +97,7 @@ static u8 tda10021_readreg (struct tda10021_state* state, u8 reg)
         // Don't print an error message if the id is read.
         if (ret != 2 && reg != 0x1a)
                 printk("DVB: TDA10021: %s: readreg error (ret == %i)\n",
-                                __FUNCTION__, ret);
+                                __func__, ret);
         return b1[0];
 }
 
diff --git a/drivers/media/dvb/frontends/tda10023.c b/drivers/media/dvb/frontends/tda10023.c
index 364bc01971a0..0727b80bc4d2 100644
--- a/drivers/media/dvb/frontends/tda10023.c
+++ b/drivers/media/dvb/frontends/tda10023.c
@@ -118,7 +118,7 @@ static u8 tda10023_readreg (struct tda10023_state* state, u8 reg)
         ret = i2c_transfer (state->i2c, msg, 2);
         if (ret != 2)
                 printk("DVB: TDA10023: %s: readreg error (ret == %i)\n",
-                                 __FUNCTION__, ret);
+                                 __func__, ret);
         return b1[0];
 }
 
@@ -132,7 +132,7 @@ static int tda10023_writereg (struct tda10023_state* state, u8 reg, u8 data)
         if (ret != 1)
                 printk("DVB: TDA10023(%d): %s, writereg error "
                         "(reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        state->frontend.dvb->num, __FUNCTION__, reg, data, ret);
+                        state->frontend.dvb->num, __func__, reg, data, ret);
 
         return (ret != 1) ? -EREMOTEIO : 0;
 }
diff --git a/drivers/media/dvb/frontends/tda1002x.h b/drivers/media/dvb/frontends/tda1002x.h
index e9094d8123f6..1bcc0d44b90b 100644
--- a/drivers/media/dvb/frontends/tda1002x.h
+++ b/drivers/media/dvb/frontends/tda1002x.h
@@ -40,7 +40,7 @@ extern struct dvb_frontend* tda10021_attach(const struct tda1002x_config* config
 static inline struct dvb_frontend* tda10021_attach(const struct tda1002x_config* config,
                                             struct i2c_adapter* i2c, u8 pwm)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TDA10021
@@ -52,7 +52,7 @@ extern struct dvb_frontend* tda10023_attach(const struct tda1002x_config* config
 static inline struct dvb_frontend* tda10023_attach(const struct tda1002x_config* config,
                                             struct i2c_adapter* i2c, u8 pwm)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TDA10023
diff --git a/drivers/media/dvb/frontends/tda10048.c b/drivers/media/dvb/frontends/tda10048.c
new file mode 100644
index 000000000000..090fb7dd93c6
--- /dev/null
+++ b/drivers/media/dvb/frontends/tda10048.c
@@ -0,0 +1,841 @@
+/*
+    NXP TDA10048HN DVB OFDM demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.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/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include "dvb_frontend.h"
+#include "dvb_math.h"
+#include "tda10048.h"
+
+#define TDA10048_DEFAULT_FIRMWARE "dvb-fe-tda10048-1.0.fw"
+#define TDA10048_DEFAULT_FIRMWARE_SIZE 24878
+
+/* Register name definitions */
+#define TDA10048_IDENTITY          0x00
+#define TDA10048_VERSION           0x01
+#define TDA10048_DSP_CODE_CPT      0x0C
+#define TDA10048_DSP_CODE_IN       0x0E
+#define TDA10048_IN_CONF1          0x10
+#define TDA10048_IN_CONF2          0x11
+#define TDA10048_IN_CONF3          0x12
+#define TDA10048_OUT_CONF1         0x14
+#define TDA10048_OUT_CONF2         0x15
+#define TDA10048_OUT_CONF3         0x16
+#define TDA10048_AUTO              0x18
+#define TDA10048_SYNC_STATUS       0x1A
+#define TDA10048_CONF_C4_1         0x1E
+#define TDA10048_CONF_C4_2         0x1F
+#define TDA10048_CODE_IN_RAM       0x20
+#define TDA10048_CHANNEL_INFO_1_R  0x22
+#define TDA10048_CHANNEL_INFO_2_R  0x23
+#define TDA10048_CHANNEL_INFO1     0x24
+#define TDA10048_CHANNEL_INFO2     0x25
+#define TDA10048_TIME_ERROR_R      0x26
+#define TDA10048_TIME_ERROR        0x27
+#define TDA10048_FREQ_ERROR_LSB_R  0x28
+#define TDA10048_FREQ_ERROR_MSB_R  0x29
+#define TDA10048_FREQ_ERROR_LSB    0x2A
+#define TDA10048_FREQ_ERROR_MSB    0x2B
+#define TDA10048_IT_SEL            0x30
+#define TDA10048_IT_STAT           0x32
+#define TDA10048_DSP_AD_LSB        0x3C
+#define TDA10048_DSP_AD_MSB        0x3D
+#define TDA10048_DSP_REF_LSB       0x3E
+#define TDA10048_DSP_REF_MSB       0x3F
+#define TDA10048_CONF_TRISTATE1    0x44
+#define TDA10048_CONF_TRISTATE2    0x45
+#define TDA10048_CONF_POLARITY     0x46
+#define TDA10048_GPIO_SP_DS0       0x48
+#define TDA10048_GPIO_SP_DS1       0x49
+#define TDA10048_GPIO_SP_DS2       0x4A
+#define TDA10048_GPIO_SP_DS3       0x4B
+#define TDA10048_GPIO_OUT_SEL      0x4C
+#define TDA10048_GPIO_SELECT       0x4D
+#define TDA10048_IC_MODE           0x4E
+#define TDA10048_CONF_XO           0x50
+#define TDA10048_CONF_PLL1         0x51
+#define TDA10048_CONF_PLL2         0x52
+#define TDA10048_CONF_PLL3         0x53
+#define TDA10048_CONF_ADC          0x54
+#define TDA10048_CONF_ADC_2        0x55
+#define TDA10048_CONF_C1_1         0x60
+#define TDA10048_CONF_C1_3         0x62
+#define TDA10048_AGC_CONF          0x70
+#define TDA10048_AGC_THRESHOLD_LSB 0x72
+#define TDA10048_AGC_THRESHOLD_MSB 0x73
+#define TDA10048_AGC_RENORM        0x74
+#define TDA10048_AGC_GAINS         0x76
+#define TDA10048_AGC_TUN_MIN       0x78
+#define TDA10048_AGC_TUN_MAX       0x79
+#define TDA10048_AGC_IF_MIN        0x7A
+#define TDA10048_AGC_IF_MAX        0x7B
+#define TDA10048_AGC_TUN_LEVEL     0x7E
+#define TDA10048_AGC_IF_LEVEL      0x7F
+#define TDA10048_DIG_AGC_LEVEL     0x81
+#define TDA10048_FREQ_PHY2_LSB     0x86
+#define TDA10048_FREQ_PHY2_MSB     0x87
+#define TDA10048_TIME_INVWREF_LSB  0x88
+#define TDA10048_TIME_INVWREF_MSB  0x89
+#define TDA10048_TIME_WREF_LSB     0x8A
+#define TDA10048_TIME_WREF_MID1    0x8B
+#define TDA10048_TIME_WREF_MID2    0x8C
+#define TDA10048_TIME_WREF_MSB     0x8D
+#define TDA10048_NP_OUT            0xA2
+#define TDA10048_CELL_ID_LSB       0xA4
+#define TDA10048_CELL_ID_MSB       0xA5
+#define TDA10048_EXTTPS_ODD        0xAA
+#define TDA10048_EXTTPS_EVEN       0xAB
+#define TDA10048_TPS_LENGTH        0xAC
+#define TDA10048_FREE_REG_1        0xB2
+#define TDA10048_FREE_REG_2        0xB3
+#define TDA10048_CONF_C3_1         0xC0
+#define TDA10048_CYBER_CTRL        0xC2
+#define TDA10048_CBER_NMAX_LSB     0xC4
+#define TDA10048_CBER_NMAX_MSB     0xC5
+#define TDA10048_CBER_LSB          0xC6
+#define TDA10048_CBER_MSB          0xC7
+#define TDA10048_VBER_LSB          0xC8
+#define TDA10048_VBER_MID          0xC9
+#define TDA10048_VBER_MSB          0xCA
+#define TDA10048_CYBER_LUT         0xCC
+#define TDA10048_UNCOR_CTRL        0xCD
+#define TDA10048_UNCOR_CPT_LSB     0xCE
+#define TDA10048_UNCOR_CPT_MSB     0xCF
+#define TDA10048_SOFT_IT_C3        0xD6
+#define TDA10048_CONF_TS2          0xE0
+#define TDA10048_CONF_TS1          0xE1
+
+static unsigned int debug;
+
+#define dprintk(level, fmt, arg...)\
+        do { if (debug >= level)\
+                printk(KERN_DEBUG "tda10048: " fmt, ## arg);\
+        } while (0)
+
+struct tda10048_state {
+
+        struct i2c_adapter *i2c;
+
+        /* configuration settings */
+        const struct tda10048_config *config;
+        struct dvb_frontend frontend;
+
+        int fwloaded;
+};
+
+static struct init_tab {
+        u8      reg;
+        u16     data;
+} init_tab[] = {
+        { TDA10048_CONF_PLL1, 0x08 },
+        { TDA10048_CONF_ADC_2, 0x00 },
+        { TDA10048_CONF_C4_1, 0x00 },
+        { TDA10048_CONF_PLL1, 0x0f },
+        { TDA10048_CONF_PLL2, 0x0a },
+        { TDA10048_CONF_PLL3, 0x43 },
+        { TDA10048_FREQ_PHY2_LSB, 0x02 },
+        { TDA10048_FREQ_PHY2_MSB, 0x0a },
+        { TDA10048_TIME_WREF_LSB, 0xbd },
+        { TDA10048_TIME_WREF_MID1, 0xe4 },
+        { TDA10048_TIME_WREF_MID2, 0xa8 },
+        { TDA10048_TIME_WREF_MSB, 0x02 },
+        { TDA10048_TIME_INVWREF_LSB, 0x04 },
+        { TDA10048_TIME_INVWREF_MSB, 0x06 },
+        { TDA10048_CONF_C4_1, 0x00 },
+        { TDA10048_CONF_C1_1, 0xa8 },
+        { TDA10048_AGC_CONF, 0x16 },
+        { TDA10048_CONF_C1_3, 0x0b },
+        { TDA10048_AGC_TUN_MIN, 0x00 },
+        { TDA10048_AGC_TUN_MAX, 0xff },
+        { TDA10048_AGC_IF_MIN, 0x00 },
+        { TDA10048_AGC_IF_MAX, 0xff },
+        { TDA10048_AGC_THRESHOLD_MSB, 0x00 },
+        { TDA10048_AGC_THRESHOLD_LSB, 0x70 },
+        { TDA10048_CYBER_CTRL, 0x38 },
+        { TDA10048_AGC_GAINS, 0x12 },
+        { TDA10048_CONF_XO, 0x00 },
+        { TDA10048_CONF_TS1, 0x07 },
+        { TDA10048_IC_MODE, 0x00 },
+        { TDA10048_CONF_TS2, 0xc0 },
+        { TDA10048_CONF_TRISTATE1, 0x21 },
+        { TDA10048_CONF_TRISTATE2, 0x00 },
+        { TDA10048_CONF_POLARITY, 0x00 },
+        { TDA10048_CONF_C4_2, 0x04 },
+        { TDA10048_CONF_ADC, 0x60 },
+        { TDA10048_CONF_ADC_2, 0x10 },
+        { TDA10048_CONF_ADC, 0x60 },
+        { TDA10048_CONF_ADC_2, 0x00 },
+        { TDA10048_CONF_C1_1, 0xa8 },
+        { TDA10048_UNCOR_CTRL, 0x00 },
+        { TDA10048_CONF_C4_2, 0x04 },
+};
+
+static int tda10048_writereg(struct tda10048_state *state, u8 reg, u8 data)
+{
+        int ret;
+        u8 buf [] = { reg, data };
+        struct i2c_msg msg = {
+                .addr = state->config->demod_address,
+                .flags = 0, .buf = buf, .len = 2 };
+
+        dprintk(2, "%s(reg = 0x%02x, data = 0x%02x)\n", __func__, reg, data);
+
+        ret = i2c_transfer(state->i2c, &msg, 1);
+
+        if (ret != 1)
+                printk("%s: writereg error (ret == %i)\n", __func__, ret);
+
+        return (ret != 1) ? -1 : 0;
+}
+
+static u8 tda10048_readreg(struct tda10048_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 } };
+
+        dprintk(2, "%s(reg = 0x%02x)\n", __func__, reg);
+
+        ret = i2c_transfer(state->i2c, msg, 2);
+
+        if (ret != 2)
+                printk(KERN_ERR "%s: readreg error (ret == %i)\n",
+                        __func__, ret);
+
+        return b1[0];
+}
+
+static int tda10048_writeregbulk(struct tda10048_state *state, u8 reg,
+        u8 *data, u16 len)
+{
+        int ret = -EREMOTEIO;
+        struct i2c_msg msg;
+        u8 *buf;
+
+        dprintk(2, "%s(%d, ?, len = %d)\n", __func__, reg, len);
+
+        buf = kmalloc(len + 1, GFP_KERNEL);
+        if (buf == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        *buf = reg;
+        memcpy(buf + 1, data, len);
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.buf = buf;
+        msg.len = len + 1;
+
+        dprintk(2, "%s():  write len = %d\n",
+                __func__, msg.len);
+
+        ret = i2c_transfer(state->i2c, &msg, 1);
+        if (ret != 1) {
+                printk(KERN_ERR "%s(): writereg error err %i\n",
+                         __func__, ret);
+                ret = -EREMOTEIO;
+        }
+
+error:
+        kfree(buf);
+
+        return ret;
+}
+
+static int tda10048_firmware_upload(struct dvb_frontend *fe)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        const struct firmware *fw;
+        int ret;
+        int pos = 0;
+        int cnt;
+        u8 wlen = state->config->fwbulkwritelen;
+
+        if ((wlen != TDA10048_BULKWRITE_200) && (wlen != TDA10048_BULKWRITE_50))
+                wlen = TDA10048_BULKWRITE_200;
+
+        /* request the firmware, this will block and timeout */
+        printk(KERN_INFO "%s: waiting for firmware upload (%s)...\n",
+                __func__,
+                TDA10048_DEFAULT_FIRMWARE);
+
+        ret = request_firmware(&fw, TDA10048_DEFAULT_FIRMWARE,
+                &state->i2c->dev);
+        if (ret) {
+                printk(KERN_ERR "%s: Upload failed. (file not found?)\n",
+                        __func__);
+                return -EIO;
+        } else {
+                printk(KERN_INFO "%s: firmware read %Zu bytes.\n",
+                        __func__,
+                        fw->size);
+                ret = 0;
+        }
+
+        if (fw->size != TDA10048_DEFAULT_FIRMWARE_SIZE) {
+                printk(KERN_ERR "%s: firmware incorrect size\n", __func__);
+                return -EIO;
+        } else {
+                printk(KERN_INFO "%s: firmware uploading\n", __func__);
+
+                /* Soft reset */
+                tda10048_writereg(state, TDA10048_CONF_TRISTATE1,
+                        tda10048_readreg(state, TDA10048_CONF_TRISTATE1)
+                                & 0xfe);
+                tda10048_writereg(state, TDA10048_CONF_TRISTATE1,
+                        tda10048_readreg(state, TDA10048_CONF_TRISTATE1)
+                                | 0x01);
+
+                /* Put the demod into host download mode */
+                tda10048_writereg(state, TDA10048_CONF_C4_1,
+                        tda10048_readreg(state, TDA10048_CONF_C4_1) & 0xf9);
+
+                /* Boot the DSP */
+                tda10048_writereg(state, TDA10048_CONF_C4_1,
+                        tda10048_readreg(state, TDA10048_CONF_C4_1) | 0x08);
+
+                /* Prepare for download */
+                tda10048_writereg(state, TDA10048_DSP_CODE_CPT, 0);
+
+                /* Download the firmware payload */
+                while (pos < fw->size) {
+
+                        if ((fw->size - pos) > wlen)
+                                cnt = wlen;
+                        else
+                                cnt = fw->size - pos;
+
+                        tda10048_writeregbulk(state, TDA10048_DSP_CODE_IN,
+                                &fw->data[pos], cnt);
+
+                        pos += cnt;
+                }
+
+                ret = -EIO;
+                /* Wait up to 250ms for the DSP to boot */
+                for (cnt = 0; cnt < 250 ; cnt += 10) {
+
+                        msleep(10);
+
+                        if (tda10048_readreg(state, TDA10048_SYNC_STATUS)
+                                & 0x40) {
+                                ret = 0;
+                                break;
+                        }
+                }
+        }
+
+        release_firmware(fw);
+
+        if (ret == 0) {
+                printk(KERN_INFO "%s: firmware uploaded\n", __func__);
+                state->fwloaded = 1;
+        } else
+                printk(KERN_ERR "%s: firmware upload failed\n", __func__);
+
+        return ret;
+}
+
+static int tda10048_set_inversion(struct dvb_frontend *fe, int inversion)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+
+        dprintk(1, "%s(%d)\n", __func__, inversion);
+
+        if (inversion == TDA10048_INVERSION_ON)
+                tda10048_writereg(state, TDA10048_CONF_C1_1,
+                        tda10048_readreg(state, TDA10048_CONF_C1_1) | 0x20);
+        else
+                tda10048_writereg(state, TDA10048_CONF_C1_1,
+                        tda10048_readreg(state, TDA10048_CONF_C1_1) & 0xdf);
+
+        return 0;
+}
+
+/* Retrieve the demod settings */
+static int tda10048_get_tps(struct tda10048_state *state,
+        struct dvb_ofdm_parameters *p)
+{
+        u8 val;
+
+        /* Make sure the TPS regs are valid */
+        if (!(tda10048_readreg(state, TDA10048_AUTO) & 0x01))
+                return -EAGAIN;
+
+        val = tda10048_readreg(state, TDA10048_OUT_CONF2);
+        switch ((val & 0x60) >> 5) {
+        case 0: p->constellation =   QPSK; break;
+        case 1: p->constellation = QAM_16; break;
+        case 2: p->constellation = QAM_64; break;
+        }
+        switch ((val & 0x18) >> 3) {
+        case 0: p->hierarchy_information = HIERARCHY_NONE; break;
+        case 1: p->hierarchy_information =    HIERARCHY_1; break;
+        case 2: p->hierarchy_information =    HIERARCHY_2; break;
+        case 3: p->hierarchy_information =    HIERARCHY_4; break;
+        }
+        switch (val & 0x07) {
+        case 0: p->code_rate_HP = FEC_1_2; break;
+        case 1: p->code_rate_HP = FEC_2_3; break;
+        case 2: p->code_rate_HP = FEC_3_4; break;
+        case 3: p->code_rate_HP = FEC_5_6; break;
+        case 4: p->code_rate_HP = FEC_7_8; break;
+        }
+
+        val = tda10048_readreg(state, TDA10048_OUT_CONF3);
+        switch (val & 0x07) {
+        case 0: p->code_rate_LP = FEC_1_2; break;
+        case 1: p->code_rate_LP = FEC_2_3; break;
+        case 2: p->code_rate_LP = FEC_3_4; break;
+        case 3: p->code_rate_LP = FEC_5_6; break;
+        case 4: p->code_rate_LP = FEC_7_8; break;
+        }
+
+        val = tda10048_readreg(state, TDA10048_OUT_CONF1);
+        switch ((val & 0x0c) >> 2) {
+        case 0: p->guard_interval = GUARD_INTERVAL_1_32; break;
+        case 1: p->guard_interval = GUARD_INTERVAL_1_16; break;
+        case 2: p->guard_interval =  GUARD_INTERVAL_1_8; break;
+        case 3: p->guard_interval =  GUARD_INTERVAL_1_4; break;
+        }
+        switch (val & 0x02) {
+        case 0: p->transmission_mode = TRANSMISSION_MODE_2K; break;
+        case 1: p->transmission_mode = TRANSMISSION_MODE_8K; break;
+        }
+
+        return 0;
+}
+
+static int tda10048_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        dprintk(1, "%s(%d)\n", __func__, enable);
+
+        if (enable)
+                return tda10048_writereg(state, TDA10048_CONF_C4_1,
+                        tda10048_readreg(state, TDA10048_CONF_C4_1) | 0x02);
+        else
+                return tda10048_writereg(state, TDA10048_CONF_C4_1,
+                        tda10048_readreg(state, TDA10048_CONF_C4_1) & 0xfd);
+}
+
+static int tda10048_output_mode(struct dvb_frontend *fe, int serial)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        dprintk(1, "%s(%d)\n", __func__, serial);
+
+        /* Ensure pins are out of tri-state */
+        tda10048_writereg(state, TDA10048_CONF_TRISTATE1, 0x21);
+        tda10048_writereg(state, TDA10048_CONF_TRISTATE2, 0x00);
+
+        if (serial) {
+                tda10048_writereg(state, TDA10048_IC_MODE, 0x80 | 0x20);
+                tda10048_writereg(state, TDA10048_CONF_TS2, 0xc0);
+        } else {
+                tda10048_writereg(state, TDA10048_IC_MODE, 0x00);
+                tda10048_writereg(state, TDA10048_CONF_TS2, 0x01);
+        }
+
+        return 0;
+}
+
+/* Talk to the demod, set the FEC, GUARD, QAM settings etc */
+/* TODO: Support manual tuning with specific params */
+static int tda10048_set_frontend(struct dvb_frontend *fe,
+        struct dvb_frontend_parameters *p)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+
+        dprintk(1, "%s(frequency=%d)\n", __func__, p->frequency);
+
+        if (fe->ops.tuner_ops.set_params) {
+
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 1);
+
+                fe->ops.tuner_ops.set_params(fe, p);
+
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 0);
+        }
+
+        /* Enable demod TPS auto detection and begin acquisition */
+        tda10048_writereg(state, TDA10048_AUTO, 0x57);
+
+        return 0;
+}
+
+/* Establish sane defaults and load firmware. */
+static int tda10048_init(struct dvb_frontend *fe)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        int ret = 0, i;
+
+        dprintk(1, "%s()\n", __func__);
+
+        /* Apply register defaults */
+        for (i = 0; i < ARRAY_SIZE(init_tab); i++)
+                tda10048_writereg(state, init_tab[i].reg, init_tab[i].data);
+
+        if (state->fwloaded == 0)
+                ret = tda10048_firmware_upload(fe);
+
+        /* Set either serial or parallel */
+        tda10048_output_mode(fe, state->config->output_mode);
+
+        /* set inversion */
+        tda10048_set_inversion(fe, state->config->inversion);
+
+        /* Ensure we leave the gate closed */
+        tda10048_i2c_gate_ctrl(fe, 0);
+
+        return ret;
+}
+
+static int tda10048_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        u8 reg;
+
+        *status = 0;
+
+        reg = tda10048_readreg(state, TDA10048_SYNC_STATUS);
+
+        dprintk(1, "%s() status =0x%02x\n", __func__, reg);
+
+        if (reg & 0x02)
+                *status |= FE_HAS_CARRIER;
+
+        if (reg & 0x04)
+                *status |= FE_HAS_SIGNAL;
+
+        if (reg & 0x08) {
+                *status |= FE_HAS_LOCK;
+                *status |= FE_HAS_VITERBI;
+                *status |= FE_HAS_SYNC;
+        }
+
+        return 0;
+}
+
+static int tda10048_read_ber(struct dvb_frontend *fe, u32 *ber)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+
+        dprintk(1, "%s()\n", __func__);
+
+        /* TODO: A reset may be required here */
+        *ber = tda10048_readreg(state, TDA10048_CBER_MSB) << 8 |
+                tda10048_readreg(state, TDA10048_CBER_LSB);
+
+        return 0;
+}
+
+static int tda10048_read_signal_strength(struct dvb_frontend *fe,
+        u16 *signal_strength)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        u8 v;
+
+        dprintk(1, "%s()\n", __func__);
+
+        *signal_strength = 65535;
+
+        v = tda10048_readreg(state, TDA10048_NP_OUT);
+        if (v > 0)
+                *signal_strength -= (v << 8) | v;
+
+        return 0;
+}
+
+/* SNR lookup table */
+static struct snr_tab {
+        u8 val;
+        u8 data;
+} snr_tab[] = {
+        {   0,   0 },
+        {   1, 246 },
+        {   2, 215 },
+        {   3, 198 },
+        {   4, 185 },
+        {   5, 176 },
+        {   6, 168 },
+        {   7, 161 },
+        {   8, 155 },
+        {   9, 150 },
+        {  10, 146 },
+        {  11, 141 },
+        {  12, 138 },
+        {  13, 134 },
+        {  14, 131 },
+        {  15, 128 },
+        {  16, 125 },
+        {  17, 122 },
+        {  18, 120 },
+        {  19, 118 },
+        {  20, 115 },
+        {  21, 113 },
+        {  22, 111 },
+        {  23, 109 },
+        {  24, 107 },
+        {  25, 106 },
+        {  26, 104 },
+        {  27, 102 },
+        {  28, 101 },
+        {  29,  99 },
+        {  30,  98 },
+        {  31,  96 },
+        {  32,  95 },
+        {  33,  94 },
+        {  34,  92 },
+        {  35,  91 },
+        {  36,  90 },
+        {  37,  89 },
+        {  38,  88 },
+        {  39,  86 },
+        {  40,  85 },
+        {  41,  84 },
+        {  42,  83 },
+        {  43,  82 },
+        {  44,  81 },
+        {  45,  80 },
+        {  46,  79 },
+        {  47,  78 },
+        {  48,  77 },
+        {  49,  76 },
+        {  50,  76 },
+        {  51,  75 },
+        {  52,  74 },
+        {  53,  73 },
+        {  54,  72 },
+        {  56,  71 },
+        {  57,  70 },
+        {  58,  69 },
+        {  60,  68 },
+        {  61,  67 },
+        {  63,  66 },
+        {  64,  65 },
+        {  66,  64 },
+        {  67,  63 },
+        {  68,  62 },
+        {  69,  62 },
+        {  70,  61 },
+        {  72,  60 },
+        {  74,  59 },
+        {  75,  58 },
+        {  77,  57 },
+        {  79,  56 },
+        {  81,  55 },
+        {  83,  54 },
+        {  85,  53 },
+        {  87,  52 },
+        {  89,  51 },
+        {  91,  50 },
+        {  93,  49 },
+        {  95,  48 },
+        {  97,  47 },
+        { 100,  46 },
+        { 102,  45 },
+        { 104,  44 },
+        { 107,  43 },
+        { 109,  42 },
+        { 112,  41 },
+        { 114,  40 },
+        { 117,  39 },
+        { 120,  38 },
+        { 123,  37 },
+        { 125,  36 },
+        { 128,  35 },
+        { 131,  34 },
+        { 134,  33 },
+        { 138,  32 },
+        { 141,  31 },
+        { 144,  30 },
+        { 147,  29 },
+        { 151,  28 },
+        { 154,  27 },
+        { 158,  26 },
+        { 162,  25 },
+        { 165,  24 },
+        { 169,  23 },
+        { 173,  22 },
+        { 177,  21 },
+        { 181,  20 },
+        { 186,  19 },
+        { 190,  18 },
+        { 194,  17 },
+        { 199,  16 },
+        { 204,  15 },
+        { 208,  14 },
+        { 213,  13 },
+        { 218,  12 },
+        { 223,  11 },
+        { 229,  10 },
+        { 234,   9 },
+        { 239,   8 },
+        { 245,   7 },
+        { 251,   6 },
+        { 255,   5 },
+};
+
+static int tda10048_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        u8 v;
+        int i, ret = -EINVAL;
+
+        dprintk(1, "%s()\n", __func__);
+
+        v = tda10048_readreg(state, TDA10048_NP_OUT);
+        for (i = 0; i < ARRAY_SIZE(snr_tab); i++) {
+                if (v <= snr_tab[i].val) {
+                        *snr = snr_tab[i].data;
+                        ret = 0;
+                        break;
+                }
+        }
+
+        return ret;
+}
+
+static int tda10048_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+
+        dprintk(1, "%s()\n", __func__);
+
+        *ucblocks = tda10048_readreg(state, TDA10048_UNCOR_CPT_MSB) << 8 |
+                tda10048_readreg(state, TDA10048_UNCOR_CPT_LSB);
+
+        return 0;
+}
+
+static int tda10048_get_frontend(struct dvb_frontend *fe,
+        struct dvb_frontend_parameters *p)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+
+        dprintk(1, "%s()\n", __func__);
+
+        p->inversion = tda10048_readreg(state, TDA10048_CONF_C1_1)
+                & 0x20 ? INVERSION_ON : INVERSION_OFF;
+
+        return tda10048_get_tps(state, &p->u.ofdm);
+}
+
+static int tda10048_get_tune_settings(struct dvb_frontend *fe,
+        struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 1000;
+        return 0;
+}
+
+static void tda10048_release(struct dvb_frontend *fe)
+{
+        struct tda10048_state *state = fe->demodulator_priv;
+        dprintk(1, "%s()\n", __func__);
+        kfree(state);
+}
+
+static struct dvb_frontend_ops tda10048_ops;
+
+struct dvb_frontend *tda10048_attach(const struct tda10048_config *config,
+        struct i2c_adapter *i2c)
+{
+        struct tda10048_state *state = NULL;
+
+        dprintk(1, "%s()\n", __func__);
+
+        /* allocate memory for the internal state */
+        state = kmalloc(sizeof(struct tda10048_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        /* setup the state */
+        state->config = config;
+        state->i2c = i2c;
+        state->fwloaded = 0;
+
+        /* check if the demod is present */
+        if (tda10048_readreg(state, TDA10048_IDENTITY) != 0x048)
+                goto error;
+
+        /* create dvb_frontend */
+        memcpy(&state->frontend.ops, &tda10048_ops,
+                sizeof(struct dvb_frontend_ops));
+        state->frontend.demodulator_priv = state;
+
+        /* Leave the gate closed */
+        tda10048_i2c_gate_ctrl(&state->frontend, 0);
+
+        return &state->frontend;
+
+error:
+        kfree(state);
+        return NULL;
+}
+EXPORT_SYMBOL(tda10048_attach);
+
+static struct dvb_frontend_ops tda10048_ops = {
+
+        .info = {
+                .name                   = "NXP TDA10048HN DVB-T",
+                .type                   = FE_OFDM,
+                .frequency_min          = 177000000,
+                .frequency_max          = 858000000,
+                .frequency_stepsize     = 166666,
+                .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_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+                FE_CAN_HIERARCHY_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
+                FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_RECOVER
+        },
+
+        .release = tda10048_release,
+        .init = tda10048_init,
+        .i2c_gate_ctrl = tda10048_i2c_gate_ctrl,
+        .set_frontend = tda10048_set_frontend,
+        .get_frontend = tda10048_get_frontend,
+        .get_tune_settings = tda10048_get_tune_settings,
+        .read_status = tda10048_read_status,
+        .read_ber = tda10048_read_ber,
+        .read_signal_strength = tda10048_read_signal_strength,
+        .read_snr = tda10048_read_snr,
+        .read_ucblocks = tda10048_read_ucblocks,
+};
+
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Enable verbose debug messages");
+
+MODULE_DESCRIPTION("NXP TDA10048HN DVB-T Demodulator driver");
+MODULE_AUTHOR("Steven Toth");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/tda10048.h b/drivers/media/dvb/frontends/tda10048.h
new file mode 100644
index 000000000000..2b5c78e62c86
--- /dev/null
+++ b/drivers/media/dvb/frontends/tda10048.h
@@ -0,0 +1,63 @@
+/*
+    NXP TDA10048HN DVB OFDM demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.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 TDA10048_H
+#define TDA10048_H
+
+#include <linux/dvb/frontend.h>
+#include <linux/firmware.h>
+
+struct tda10048_config {
+
+        /* the demodulator's i2c address */
+        u8 demod_address;
+
+        /* serial/parallel output */
+#define TDA10048_PARALLEL_OUTPUT 0
+#define TDA10048_SERIAL_OUTPUT   1
+        u8 output_mode;
+
+#define TDA10048_BULKWRITE_200  200
+#define TDA10048_BULKWRITE_50   50
+        u8 fwbulkwritelen;
+
+        /* Spectral Inversion */
+#define TDA10048_INVERSION_OFF 0
+#define TDA10048_INVERSION_ON  1
+        u8 inversion;
+};
+
+#if defined(CONFIG_DVB_TDA10048) || \
+        (defined(CONFIG_DVB_TDA10048_MODULE) && defined(MODULE))
+extern struct dvb_frontend *tda10048_attach(
+        const struct tda10048_config *config,
+        struct i2c_adapter *i2c);
+#else
+static inline struct dvb_frontend *tda10048_attach(
+        const struct tda10048_config *config,
+        struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+#endif /* CONFIG_DVB_TDA10048 */
+
+#endif /* TDA10048_H */
diff --git a/drivers/media/dvb/frontends/tda1004x.c b/drivers/media/dvb/frontends/tda1004x.c
index 8415a8a5247a..49973846373e 100644
--- a/drivers/media/dvb/frontends/tda1004x.c
+++ b/drivers/media/dvb/frontends/tda1004x.c
@@ -131,16 +131,16 @@ static int tda1004x_write_byteI(struct tda1004x_state *state, int reg, int data)
         u8 buf[] = { reg, data };
         struct i2c_msg msg = { .flags = 0, .buf = buf, .len = 2 };
 
-        dprintk("%s: reg=0x%x, data=0x%x\n", __FUNCTION__, reg, data);
+        dprintk("%s: reg=0x%x, data=0x%x\n", __func__, reg, data);
 
         msg.addr = state->config->demod_address;
         ret = i2c_transfer(state->i2c, &msg, 1);
 
         if (ret != 1)
                 dprintk("%s: error reg=0x%x, data=0x%x, ret=%i\n",
-                        __FUNCTION__, reg, data, ret);
+                        __func__, reg, data, ret);
 
-        dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __FUNCTION__,
+        dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __func__,
                 reg, data, ret);
         return (ret != 1) ? -1 : 0;
 }
@@ -153,19 +153,19 @@ static int tda1004x_read_byte(struct tda1004x_state *state, int reg)
         struct i2c_msg msg[] = {{ .flags = 0, .buf = b0, .len = 1 },
                                 { .flags = I2C_M_RD, .buf = b1, .len = 1 }};
 
-        dprintk("%s: reg=0x%x\n", __FUNCTION__, reg);
+        dprintk("%s: reg=0x%x\n", __func__, reg);
 
         msg[0].addr = state->config->demod_address;
         msg[1].addr = state->config->demod_address;
         ret = i2c_transfer(state->i2c, msg, 2);
 
         if (ret != 2) {
-                dprintk("%s: error reg=0x%x, ret=%i\n", __FUNCTION__, reg,
+                dprintk("%s: error reg=0x%x, ret=%i\n", __func__, reg,
                         ret);
                 return -1;
         }
 
-        dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __FUNCTION__,
+        dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __func__,
                 reg, b1[0], ret);
         return b1[0];
 }
@@ -173,7 +173,7 @@ static int tda1004x_read_byte(struct tda1004x_state *state, int reg)
 static int tda1004x_write_mask(struct tda1004x_state *state, int reg, int mask, int data)
 {
         int val;
-        dprintk("%s: reg=0x%x, mask=0x%x, data=0x%x\n", __FUNCTION__, reg,
+        dprintk("%s: reg=0x%x, mask=0x%x, data=0x%x\n", __func__, reg,
                 mask, data);
 
         // read a byte and check
@@ -194,7 +194,7 @@ static int tda1004x_write_buf(struct tda1004x_state *state, int reg, unsigned ch
         int i;
         int result;
 
-        dprintk("%s: reg=0x%x, len=0x%x\n", __FUNCTION__, reg, len);
+        dprintk("%s: reg=0x%x, len=0x%x\n", __func__, reg, len);
 
         result = 0;
         for (i = 0; i < len; i++) {
@@ -209,7 +209,7 @@ static int tda1004x_write_buf(struct tda1004x_state *state, int reg, unsigned ch
 static int tda1004x_enable_tuner_i2c(struct tda1004x_state *state)
 {
         int result;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         result = tda1004x_write_mask(state, TDA1004X_CONFC4, 2, 2);
         msleep(20);
@@ -218,7 +218,7 @@ static int tda1004x_enable_tuner_i2c(struct tda1004x_state *state)
 
 static int tda1004x_disable_tuner_i2c(struct tda1004x_state *state)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         return tda1004x_write_mask(state, TDA1004X_CONFC4, 2, 0);
 }
@@ -345,7 +345,7 @@ static int tda1004x_do_upload(struct tda1004x_state *state,
                 }
                 pos += tx_size;
 
-                dprintk("%s: fw_pos=0x%x\n", __FUNCTION__, pos);
+                dprintk("%s: fw_pos=0x%x\n", __func__, pos);
         }
         // give the DSP a chance to settle 03/10/05 Hac
         msleep(100);
@@ -444,10 +444,10 @@ static void tda10046_init_plls(struct dvb_frontend* fe)
                 tda1004x_write_byteI(state, TDA10046H_CONFPLL2, 0x03); // PLL M = 3
         }
         if (state->config->xtal_freq == TDA10046_XTAL_4M ) {
-                dprintk("%s: setting up PLLs for a 4 MHz Xtal\n", __FUNCTION__);
+                dprintk("%s: setting up PLLs for a 4 MHz Xtal\n", __func__);
                 tda1004x_write_byteI(state, TDA10046H_CONFPLL3, 0); // PLL P = N = 0
         } else {
-                dprintk("%s: setting up PLLs for a 16 MHz Xtal\n", __FUNCTION__);
+                dprintk("%s: setting up PLLs for a 16 MHz Xtal\n", __func__);
                 tda1004x_write_byteI(state, TDA10046H_CONFPLL3, 3); // PLL P = 0, N = 3
         }
         if(tda10046_clk53m)
@@ -488,7 +488,7 @@ static int tda10046_fwupload(struct dvb_frontend* fe)
         if (state->config->xtal_freq == TDA10046_XTAL_4M) {
                 tda1004x_write_byteI(state, TDA1004X_CONFC4, 0);
         } else {
-                dprintk("%s: 16MHz Xtal, reducing I2C speed\n", __FUNCTION__);
+                dprintk("%s: 16MHz Xtal, reducing I2C speed\n", __func__);
                 tda1004x_write_byteI(state, TDA1004X_CONFC4, 0x80);
         }
         tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 1, 0);
@@ -594,7 +594,7 @@ static int tda10045_init(struct dvb_frontend* fe)
 {
         struct tda1004x_state* state = fe->demodulator_priv;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (tda10045_fwupload(fe)) {
                 printk("tda1004x: firmware upload failed\n");
@@ -624,7 +624,7 @@ static int tda10045_init(struct dvb_frontend* fe)
 static int tda10046_init(struct dvb_frontend* fe)
 {
         struct tda1004x_state* state = fe->demodulator_priv;
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (tda10046_fwupload(fe)) {
                 printk("tda1004x: firmware upload failed\n");
@@ -686,7 +686,7 @@ static int tda1004x_set_fe(struct dvb_frontend* fe,
         int tmp;
         int inversion;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (state->demod_type == TDA1004X_DEMOD_TDA10046) {
                 // setup auto offset
@@ -881,7 +881,7 @@ static int tda1004x_get_fe(struct dvb_frontend* fe, struct dvb_frontend_paramete
 {
         struct tda1004x_state* state = fe->demodulator_priv;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         // inversion status
         fe_params->inversion = INVERSION_OFF;
@@ -989,7 +989,7 @@ static int tda1004x_read_status(struct dvb_frontend* fe, fe_status_t * fe_status
         int cber;
         int vber;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         // read status
         status = tda1004x_read_byte(state, TDA1004X_STATUS_CD);
@@ -1048,7 +1048,7 @@ static int tda1004x_read_status(struct dvb_frontend* fe, fe_status_t * fe_status
         }
 
         // success
-        dprintk("%s: fe_status=0x%x\n", __FUNCTION__, *fe_status);
+        dprintk("%s: fe_status=0x%x\n", __func__, *fe_status);
         return 0;
 }
 
@@ -1058,7 +1058,7 @@ static int tda1004x_read_signal_strength(struct dvb_frontend* fe, u16 * signal)
         int tmp;
         int reg = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         // determine the register to use
         switch (state->demod_type) {
@@ -1077,7 +1077,7 @@ static int tda1004x_read_signal_strength(struct dvb_frontend* fe, u16 * signal)
                 return -EIO;
 
         *signal = (tmp << 8) | tmp;
-        dprintk("%s: signal=0x%x\n", __FUNCTION__, *signal);
+        dprintk("%s: signal=0x%x\n", __func__, *signal);
         return 0;
 }
 
@@ -1086,7 +1086,7 @@ static int tda1004x_read_snr(struct dvb_frontend* fe, u16 * snr)
         struct tda1004x_state* state = fe->demodulator_priv;
         int tmp;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         // read it
         tmp = tda1004x_read_byte(state, TDA1004X_SNR);
@@ -1095,7 +1095,7 @@ static int tda1004x_read_snr(struct dvb_frontend* fe, u16 * snr)
         tmp = 255 - tmp;
 
         *snr = ((tmp << 8) | tmp);
-        dprintk("%s: snr=0x%x\n", __FUNCTION__, *snr);
+        dprintk("%s: snr=0x%x\n", __func__, *snr);
         return 0;
 }
 
@@ -1106,7 +1106,7 @@ static int tda1004x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
         int tmp2;
         int counter;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         // read the UCBLOCKS and reset
         counter = 0;
@@ -1132,7 +1132,7 @@ static int tda1004x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
         else
                 *ucblocks = 0xffffffff;
 
-        dprintk("%s: ucblocks=0x%x\n", __FUNCTION__, *ucblocks);
+        dprintk("%s: ucblocks=0x%x\n", __func__, *ucblocks);
         return 0;
 }
 
@@ -1141,7 +1141,7 @@ static int tda1004x_read_ber(struct dvb_frontend* fe, u32* ber)
         struct tda1004x_state* state = fe->demodulator_priv;
         int tmp;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         // read it in
         tmp = tda1004x_read_byte(state, TDA1004X_CBER_LSB);
@@ -1155,7 +1155,7 @@ static int tda1004x_read_ber(struct dvb_frontend* fe, u32* ber)
         // The address 0x20 should be read to cope with a TDA10046 bug
         tda1004x_read_byte(state, TDA1004X_CBER_RESET);
 
-        dprintk("%s: ber=0x%x\n", __FUNCTION__, *ber);
+        dprintk("%s: ber=0x%x\n", __func__, *ber);
         return 0;
 }
 
diff --git a/drivers/media/dvb/frontends/tda1004x.h b/drivers/media/dvb/frontends/tda1004x.h
index abae84350142..4e27ffb0f14e 100644
--- a/drivers/media/dvb/frontends/tda1004x.h
+++ b/drivers/media/dvb/frontends/tda1004x.h
@@ -94,7 +94,6 @@ struct tda1004x_config
 
         /* slave address and configuration of the tuner */
         u8 tuner_address;
-        u8 tuner_config;
         u8 antenna_switch;
 
         /* if the board uses another I2c Bridge (tda8290), its address */
@@ -128,13 +127,13 @@ extern struct dvb_frontend* tda10046_attach(const struct tda1004x_config* config
 static inline struct dvb_frontend* tda10045_attach(const struct tda1004x_config* config,
                                             struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 static inline struct dvb_frontend* tda10046_attach(const struct tda1004x_config* config,
                                             struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TDA1004X
diff --git a/drivers/media/dvb/frontends/tda10086.c b/drivers/media/dvb/frontends/tda10086.c
index 0d2b69a99ad4..a17ce3c4ad86 100644
--- a/drivers/media/dvb/frontends/tda10086.c
+++ b/drivers/media/dvb/frontends/tda10086.c
@@ -43,7 +43,7 @@ struct tda10086_state {
         bool has_lock;
 };
 
-static int debug = 0;
+static int debug;
 #define dprintk(args...) \
         do { \
                 if (debug) printk(KERN_DEBUG "tda10086: " args); \
@@ -60,7 +60,7 @@ static int tda10086_write_byte(struct tda10086_state *state, int reg, int data)
 
         if (ret != 1)
                 dprintk("%s: error reg=0x%x, data=0x%x, ret=%i\n",
-                        __FUNCTION__, reg, data, ret);
+                        __func__, reg, data, ret);
 
         return (ret != 1) ? ret : 0;
 }
@@ -78,7 +78,7 @@ static int tda10086_read_byte(struct tda10086_state *state, int reg)
         ret = i2c_transfer(state->i2c, msg, 2);
 
         if (ret != 2) {
-                dprintk("%s: error reg=0x%x, ret=%i\n", __FUNCTION__, reg,
+                dprintk("%s: error reg=0x%x, ret=%i\n", __func__, reg,
                         ret);
                 return ret;
         }
@@ -90,16 +90,16 @@ static int tda10086_write_mask(struct tda10086_state *state, int reg, int mask,
 {
         int val;
 
-        // read a byte and check
+        /* read a byte and check */
         val = tda10086_read_byte(state, reg);
         if (val < 0)
                 return val;
 
-        // mask if off
+        /* mask if off */
         val = val & ~mask;
         val |= data & 0xff;
 
-        // write it out again
+        /* write it out again */
         return tda10086_write_byte(state, reg, val);
 }
 
@@ -108,62 +108,67 @@ static int tda10086_init(struct dvb_frontend* fe)
         struct tda10086_state* state = fe->demodulator_priv;
         u8 t22k_off = 0x80;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (state->config->diseqc_tone)
                 t22k_off = 0;
-        // reset
+        /* reset */
         tda10086_write_byte(state, 0x00, 0x00);
         msleep(10);
 
-        // misc setup
+        /* misc setup */
         tda10086_write_byte(state, 0x01, 0x94);
-        tda10086_write_byte(state, 0x02, 0x35); // NOTE: TT drivers appear to disable CSWP
+        tda10086_write_byte(state, 0x02, 0x35); /* NOTE: TT drivers appear to disable CSWP */
         tda10086_write_byte(state, 0x03, 0xe4);
         tda10086_write_byte(state, 0x04, 0x43);
         tda10086_write_byte(state, 0x0c, 0x0c);
-        tda10086_write_byte(state, 0x1b, 0xb0); // noise threshold
-        tda10086_write_byte(state, 0x20, 0x89); // misc
-        tda10086_write_byte(state, 0x30, 0x04); // acquisition period length
-        tda10086_write_byte(state, 0x32, 0x00); // irq off
-        tda10086_write_byte(state, 0x31, 0x56); // setup AFC
-
-        // setup PLL (assumes 16Mhz XIN)
-        tda10086_write_byte(state, 0x55, 0x2c); // misc PLL setup
-        tda10086_write_byte(state, 0x3a, 0x0b); // M=12
-        tda10086_write_byte(state, 0x3b, 0x01); // P=2
-        tda10086_write_mask(state, 0x55, 0x20, 0x00); // powerup PLL
-
-        // setup TS interface
+        tda10086_write_byte(state, 0x1b, 0xb0); /* noise threshold */
+        tda10086_write_byte(state, 0x20, 0x89); /* misc */
+        tda10086_write_byte(state, 0x30, 0x04); /* acquisition period length */
+        tda10086_write_byte(state, 0x32, 0x00); /* irq off */
+        tda10086_write_byte(state, 0x31, 0x56); /* setup AFC */
+
+        /* setup PLL (this assumes SACLK = 96MHz) */
+        tda10086_write_byte(state, 0x55, 0x2c); /* misc PLL setup */
+        if (state->config->xtal_freq == TDA10086_XTAL_16M) {
+                tda10086_write_byte(state, 0x3a, 0x0b); /* M=12 */
+                tda10086_write_byte(state, 0x3b, 0x01); /* P=2 */
+        } else {
+                tda10086_write_byte(state, 0x3a, 0x17); /* M=24 */
+                tda10086_write_byte(state, 0x3b, 0x00); /* P=1 */
+        }
+        tda10086_write_mask(state, 0x55, 0x20, 0x00); /* powerup PLL */
+
+        /* setup TS interface */
         tda10086_write_byte(state, 0x11, 0x81);
         tda10086_write_byte(state, 0x12, 0x81);
-        tda10086_write_byte(state, 0x19, 0x40); // parallel mode A + MSBFIRST
-        tda10086_write_byte(state, 0x56, 0x80); // powerdown WPLL - unused in the mode we use
-        tda10086_write_byte(state, 0x57, 0x08); // bypass WPLL - unused in the mode we use
+        tda10086_write_byte(state, 0x19, 0x40); /* parallel mode A + MSBFIRST */
+        tda10086_write_byte(state, 0x56, 0x80); /* powerdown WPLL - unused in the mode we use */
+        tda10086_write_byte(state, 0x57, 0x08); /* bypass WPLL - unused in the mode we use */
         tda10086_write_byte(state, 0x10, 0x2a);
 
-        // setup ADC
-        tda10086_write_byte(state, 0x58, 0x61); // ADC setup
-        tda10086_write_mask(state, 0x58, 0x01, 0x00); // powerup ADC
+        /* setup ADC */
+        tda10086_write_byte(state, 0x58, 0x61); /* ADC setup */
+        tda10086_write_mask(state, 0x58, 0x01, 0x00); /* powerup ADC */
 
-        // setup AGC
+        /* setup AGC */
         tda10086_write_byte(state, 0x05, 0x0B);
         tda10086_write_byte(state, 0x37, 0x63);
-        tda10086_write_byte(state, 0x3f, 0x0a); // NOTE: flydvb varies it
+        tda10086_write_byte(state, 0x3f, 0x0a); /* NOTE: flydvb varies it */
         tda10086_write_byte(state, 0x40, 0x64);
         tda10086_write_byte(state, 0x41, 0x4f);
         tda10086_write_byte(state, 0x42, 0x43);
 
-        // setup viterbi
-        tda10086_write_byte(state, 0x1a, 0x11); // VBER 10^6, DVB, QPSK
+        /* setup viterbi */
+        tda10086_write_byte(state, 0x1a, 0x11); /* VBER 10^6, DVB, QPSK */
 
-        // setup carrier recovery
+        /* setup carrier recovery */
         tda10086_write_byte(state, 0x3d, 0x80);
 
-        // setup SEC
-        tda10086_write_byte(state, 0x36, t22k_off); // all SEC off, 22k tone
-        tda10086_write_byte(state, 0x34, (((1<<19) * (22000/1000)) / (SACLK/1000)));      // } tone frequency
-        tda10086_write_byte(state, 0x35, (((1<<19) * (22000/1000)) / (SACLK/1000)) >> 8); // }
+        /* setup SEC */
+        tda10086_write_byte(state, 0x36, t22k_off); /* all SEC off, 22k tone */
+        tda10086_write_byte(state, 0x34, (((1<<19) * (22000/1000)) / (SACLK/1000)));
+        tda10086_write_byte(state, 0x35, (((1<<19) * (22000/1000)) / (SACLK/1000)) >> 8);
 
         return 0;
 }
@@ -173,7 +178,7 @@ static void tda10086_diseqc_wait(struct tda10086_state *state)
         unsigned long timeout = jiffies + msecs_to_jiffies(200);
         while (!(tda10086_read_byte(state, 0x50) & 0x01)) {
                 if(time_after(jiffies, timeout)) {
-                        printk("%s: diseqc queue not ready, command may be lost.\n", __FUNCTION__);
+                        printk("%s: diseqc queue not ready, command may be lost.\n", __func__);
                         break;
                 }
                 msleep(10);
@@ -185,7 +190,7 @@ static int tda10086_set_tone (struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
         struct tda10086_state* state = fe->demodulator_priv;
         u8 t22k_off = 0x80;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (state->config->diseqc_tone)
                 t22k_off = 0;
@@ -211,7 +216,7 @@ static int tda10086_send_master_cmd (struct dvb_frontend* fe,
         u8 oldval;
         u8 t22k_off = 0x80;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (state->config->diseqc_tone)
                 t22k_off = 0;
@@ -239,7 +244,7 @@ static int tda10086_send_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t minic
         u8 oldval = tda10086_read_byte(state, 0x36);
         u8 t22k_off = 0x80;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (state->config->diseqc_tone)
                 t22k_off = 0;
@@ -266,7 +271,7 @@ static int tda10086_set_inversion(struct tda10086_state *state,
 {
         u8 invval = 0x80;
 
-        dprintk ("%s %i %i\n", __FUNCTION__, fe_params->inversion, state->config->invert);
+        dprintk ("%s %i %i\n", __func__, fe_params->inversion, state->config->invert);
 
         switch(fe_params->inversion) {
         case INVERSION_OFF:
@@ -300,9 +305,9 @@ static int tda10086_set_symbol_rate(struct tda10086_state *state,
         u32 bdri;
         u32 symbol_rate = fe_params->u.qpsk.symbol_rate;
 
-        dprintk ("%s %i\n", __FUNCTION__, symbol_rate);
+        dprintk ("%s %i\n", __func__, symbol_rate);
 
-        // setup the decimation and anti-aliasing filters..
+        /* setup the decimation and anti-aliasing filters.. */
         if (symbol_rate < (u32) (SACLK * 0.0137)) {
                 dfn=4;
                 afs=1;
@@ -339,13 +344,13 @@ static int tda10086_set_symbol_rate(struct tda10086_state *state,
                 byp=1;
         }
 
-        // calculate BDR
+        /* calculate BDR */
         big = (1ULL<<21) * ((u64) symbol_rate/1000ULL) * (1ULL<<dfn);
         big += ((SACLK/1000ULL)-1ULL);
         do_div(big, (SACLK/1000ULL));
         bdr = big & 0xfffff;
 
-        // calculate BDRI
+        /* calculate BDRI */
         tmp = (1<<dfn)*(symbol_rate/1000);
         bdri = ((32 * (SACLK/1000)) + (tmp-1)) / tmp;
 
@@ -366,7 +371,7 @@ static int tda10086_set_fec(struct tda10086_state *state,
 {
         u8 fecval;
 
-        dprintk ("%s %i\n", __FUNCTION__, fe_params->u.qpsk.fec_inner);
+        dprintk ("%s %i\n", __func__, fe_params->u.qpsk.fec_inner);
 
         switch(fe_params->u.qpsk.fec_inner) {
         case FEC_1_2:
@@ -412,13 +417,13 @@ static int tda10086_set_frontend(struct dvb_frontend* fe,
         u32 freq = 0;
         int freqoff;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
-        // modify parameters for tuning
+        /* modify parameters for tuning */
         tda10086_write_byte(state, 0x02, 0x35);
         state->has_lock = false;
 
-        // set params
+        /* set params */
         if (fe->ops.tuner_ops.set_params) {
                 fe->ops.tuner_ops.set_params(fe, fe_params);
                 if (fe->ops.i2c_gate_ctrl)
@@ -430,7 +435,7 @@ static int tda10086_set_frontend(struct dvb_frontend* fe,
                         fe->ops.i2c_gate_ctrl(fe, 0);
         }
 
-        // calcluate the frequency offset (in *Hz* not kHz)
+        /* calcluate the frequency offset (in *Hz* not kHz) */
         freqoff = fe_params->frequency - freq;
         freqoff = ((1<<16) * freqoff) / (SACLK/1000);
         tda10086_write_byte(state, 0x3d, 0x80 | ((freqoff >> 8) & 0x7f));
@@ -443,7 +448,7 @@ static int tda10086_set_frontend(struct dvb_frontend* fe,
         if ((ret = tda10086_set_fec(state, fe_params)) < 0)
                 return ret;
 
-        // soft reset + disable TS output until lock
+        /* soft reset + disable TS output until lock */
         tda10086_write_mask(state, 0x10, 0x40, 0x40);
         tda10086_write_mask(state, 0x00, 0x01, 0x00);
 
@@ -459,13 +464,13 @@ static int tda10086_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_pa
         int tmp;
         u64 tmp64;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
-        // check for invalid symbol rate
+        /* check for invalid symbol rate */
         if (fe_params->u.qpsk.symbol_rate < 500000)
                 return -EINVAL;
 
-        // calculate the updated frequency (note: we convert from Hz->kHz)
+        /* calculate the updated frequency (note: we convert from Hz->kHz) */
         tmp64 = tda10086_read_byte(state, 0x52);
         tmp64 |= (tda10086_read_byte(state, 0x51) << 8);
         if (tmp64 & 0x8000)
@@ -474,7 +479,7 @@ static int tda10086_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_pa
         do_div(tmp64, (1ULL<<15) * (1ULL<<1));
         fe_params->frequency = (int) state->frequency + (int) tmp64;
 
-        // the inversion
+        /* the inversion */
         val = tda10086_read_byte(state, 0x0c);
         if (val & 0x80) {
                 switch(val & 0x40) {
@@ -505,7 +510,7 @@ static int tda10086_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_pa
                 }
         }
 
-        // calculate the updated symbol rate
+        /* calculate the updated symbol rate */
         tmp = tda10086_read_byte(state, 0x1d);
         if (tmp & 0x80)
                 tmp |= 0xffffff00;
@@ -513,7 +518,7 @@ static int tda10086_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_pa
         tmp = ((state->symbol_rate/1000) * tmp) / (1000000/1000);
         fe_params->u.qpsk.symbol_rate = state->symbol_rate + tmp;
 
-        // the FEC
+        /* the FEC */
         val = (tda10086_read_byte(state, 0x0d) & 0x70) >> 4;
         switch(val) {
         case 0x00:
@@ -550,7 +555,7 @@ static int tda10086_read_status(struct dvb_frontend* fe, fe_status_t *fe_status)
         struct tda10086_state* state = fe->demodulator_priv;
         u8 val;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         val = tda10086_read_byte(state, 0x0e);
         *fe_status = 0;
@@ -566,7 +571,7 @@ static int tda10086_read_status(struct dvb_frontend* fe, fe_status_t *fe_status)
                 *fe_status |= FE_HAS_LOCK;
                 if (!state->has_lock) {
                         state->has_lock = true;
-                        // modify parameters for stable reception
+                        /* modify parameters for stable reception */
                         tda10086_write_byte(state, 0x02, 0x00);
                 }
         }
@@ -579,7 +584,7 @@ static int tda10086_read_signal_strength(struct dvb_frontend* fe, u16 * signal)
         struct tda10086_state* state = fe->demodulator_priv;
         u8 _str;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         _str = 0xff - tda10086_read_byte(state, 0x43);
         *signal = (_str << 8) | _str;
@@ -592,7 +597,7 @@ static int tda10086_read_snr(struct dvb_frontend* fe, u16 * snr)
         struct tda10086_state* state = fe->demodulator_priv;
         u8 _snr;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         _snr = 0xff - tda10086_read_byte(state, 0x1c);
         *snr = (_snr << 8) | _snr;
@@ -604,12 +609,12 @@ static int tda10086_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
         struct tda10086_state* state = fe->demodulator_priv;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
-        // read it
+        /* read it */
         *ucblocks = tda10086_read_byte(state, 0x18) & 0x7f;
 
-        // reset counter
+        /* reset counter */
         tda10086_write_byte(state, 0x18, 0x00);
         tda10086_write_byte(state, 0x18, 0x80);
 
@@ -620,9 +625,9 @@ static int tda10086_read_ber(struct dvb_frontend* fe, u32* ber)
 {
         struct tda10086_state* state = fe->demodulator_priv;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
-        // read it
+        /* read it */
         *ber = 0;
         *ber |= tda10086_read_byte(state, 0x15);
         *ber |= tda10086_read_byte(state, 0x16) << 8;
@@ -635,7 +640,7 @@ static int tda10086_sleep(struct dvb_frontend* fe)
 {
         struct tda10086_state* state = fe->demodulator_priv;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         tda10086_write_mask(state, 0x00, 0x08, 0x08);
 
@@ -646,7 +651,7 @@ static int tda10086_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 {
         struct tda10086_state* state = fe->demodulator_priv;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         if (enable) {
                 tda10086_write_mask(state, 0x00, 0x10, 0x10);
@@ -737,7 +742,7 @@ struct dvb_frontend* tda10086_attach(const struct tda10086_config* config,
 {
         struct tda10086_state *state;
 
-        dprintk ("%s\n", __FUNCTION__);
+        dprintk ("%s\n", __func__);
 
         /* allocate memory for the internal state */
         state = kmalloc(sizeof(struct tda10086_state), GFP_KERNEL);
diff --git a/drivers/media/dvb/frontends/tda10086.h b/drivers/media/dvb/frontends/tda10086.h
index eeceaeee78ff..61148c558d8d 100644
--- a/drivers/media/dvb/frontends/tda10086.h
+++ b/drivers/media/dvb/frontends/tda10086.h
@@ -26,6 +26,11 @@
 #include <linux/dvb/frontend.h>
 #include <linux/firmware.h>
 
+enum tda10086_xtal {
+        TDA10086_XTAL_16M,
+        TDA10086_XTAL_4M
+};
+
 struct tda10086_config
 {
         /* the demodulator's i2c address */
@@ -36,6 +41,9 @@ struct tda10086_config
 
         /* do we need the diseqc signal with carrier? */
         u8 diseqc_tone;
+
+        /* frequency of the reference xtal */
+        enum tda10086_xtal xtal_freq;
 };
 
 #if defined(CONFIG_DVB_TDA10086) || (defined(CONFIG_DVB_TDA10086_MODULE) && defined(MODULE))
@@ -45,9 +53,9 @@ extern struct dvb_frontend* tda10086_attach(const struct tda10086_config* config
 static inline struct dvb_frontend* tda10086_attach(const struct tda10086_config* config,
                                                    struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
-#endif // CONFIG_DVB_TDA10086
+#endif /* CONFIG_DVB_TDA10086 */
 
-#endif // TDA10086_H
+#endif /* TDA10086_H */
diff --git a/drivers/media/dvb/frontends/tda18271-common.c b/drivers/media/dvb/frontends/tda18271-common.c
index bca570990613..e27a7620a32f 100644
--- a/drivers/media/dvb/frontends/tda18271-common.c
+++ b/drivers/media/dvb/frontends/tda18271-common.c
@@ -125,16 +125,16 @@ int tda18271_read_regs(struct dvb_frontend *fe)
         unsigned char buf = 0x00;
         int ret;
         struct i2c_msg msg[] = {
-                { .addr = priv->i2c_addr, .flags = 0,
+                { .addr = priv->i2c_props.addr, .flags = 0,
                   .buf = &buf, .len = 1 },
-                { .addr = priv->i2c_addr, .flags = I2C_M_RD,
+                { .addr = priv->i2c_props.addr, .flags = I2C_M_RD,
                   .buf = regs, .len = 16 }
         };
 
         tda18271_i2c_gate_ctrl(fe, 1);
 
         /* read all registers */
-        ret = i2c_transfer(priv->i2c_adap, msg, 2);
+        ret = i2c_transfer(priv->i2c_props.adap, msg, 2);
 
         tda18271_i2c_gate_ctrl(fe, 0);
 
@@ -155,16 +155,16 @@ int tda18271_read_extended(struct dvb_frontend *fe)
         unsigned char buf = 0x00;
         int ret, i;
         struct i2c_msg msg[] = {
-                { .addr = priv->i2c_addr, .flags = 0,
+                { .addr = priv->i2c_props.addr, .flags = 0,
                   .buf = &buf, .len = 1 },
-                { .addr = priv->i2c_addr, .flags = I2C_M_RD,
+                { .addr = priv->i2c_props.addr, .flags = I2C_M_RD,
                   .buf = regdump, .len = TDA18271_NUM_REGS }
         };
 
         tda18271_i2c_gate_ctrl(fe, 1);
 
         /* read all registers */
-        ret = i2c_transfer(priv->i2c_adap, msg, 2);
+        ret = i2c_transfer(priv->i2c_props.adap, msg, 2);
 
         tda18271_i2c_gate_ctrl(fe, 0);
 
@@ -192,7 +192,7 @@ int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len)
         struct tda18271_priv *priv = fe->tuner_priv;
         unsigned char *regs = priv->tda18271_regs;
         unsigned char buf[TDA18271_NUM_REGS + 1];
-        struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+        struct i2c_msg msg = { .addr = priv->i2c_props.addr, .flags = 0,
                                .buf = buf, .len = len + 1 };
         int i, ret;
 
@@ -205,7 +205,7 @@ int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len)
         tda18271_i2c_gate_ctrl(fe, 1);
 
         /* write registers */
-        ret = i2c_transfer(priv->i2c_adap, &msg, 1);
+        ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
 
         tda18271_i2c_gate_ctrl(fe, 0);
 
@@ -217,13 +217,29 @@ int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len)
 
 /*---------------------------------------------------------------------*/
 
+int tda18271_charge_pump_source(struct dvb_frontend *fe,
+                                enum tda18271_pll pll, int force)
+{
+        struct tda18271_priv *priv = fe->tuner_priv;
+        unsigned char *regs = priv->tda18271_regs;
+
+        int r_cp = (pll == TDA18271_CAL_PLL) ? R_EB7 : R_EB4;
+
+        regs[r_cp] &= ~0x20;
+        regs[r_cp] |= ((force & 1) << 5);
+        tda18271_write_regs(fe, r_cp, 1);
+
+        return 0;
+}
+
 int tda18271_init_regs(struct dvb_frontend *fe)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         unsigned char *regs = priv->tda18271_regs;
 
         tda_dbg("initializing registers for device @ %d-%04x\n",
-                i2c_adapter_id(priv->i2c_adap), priv->i2c_addr);
+                i2c_adapter_id(priv->i2c_props.adap),
+                priv->i2c_props.addr);
 
         /* initialize registers */
         switch (priv->id) {
@@ -310,7 +326,12 @@ int tda18271_init_regs(struct dvb_frontend *fe)
         regs[R_EB22] = 0x48;
         regs[R_EB23] = 0xb0;
 
-        tda18271_write_regs(fe, 0x00, TDA18271_NUM_REGS);
+        if (priv->small_i2c) {
+                tda18271_write_regs(fe, 0x00, 0x10);
+                tda18271_write_regs(fe, 0x10, 0x10);
+                tda18271_write_regs(fe, 0x20, 0x07);
+        } else
+                tda18271_write_regs(fe, 0x00, TDA18271_NUM_REGS);
 
         /* setup agc1 gain */
         regs[R_EB17] = 0x00;
@@ -349,24 +370,15 @@ int tda18271_init_regs(struct dvb_frontend *fe)
         regs[R_MD2] = 0x08;
         regs[R_MD3] = 0x00;
 
-        switch (priv->id) {
-        case TDA18271HDC1:
-                tda18271_write_regs(fe, R_EP3, 11);
-                break;
-        case TDA18271HDC2:
-                tda18271_write_regs(fe, R_EP3, 12);
-                break;
-        };
+        tda18271_write_regs(fe, R_EP3, 11);
 
         if ((priv->id) == TDA18271HDC2) {
                 /* main pll cp source on */
-                regs[R_EB4] = 0x61;
-                tda18271_write_regs(fe, R_EB4, 1);
+                tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
                 msleep(1);
 
                 /* main pll cp source off */
-                regs[R_EB4] = 0x41;
-                tda18271_write_regs(fe, R_EB4, 1);
+                tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
         }
 
         msleep(5); /* pll locking */
@@ -398,6 +410,7 @@ int tda18271_init_regs(struct dvb_frontend *fe)
         tda18271_write_regs(fe, R_EP3, 11);
         msleep(5); /* pll locking */
 
+        /* launch detector */
         tda18271_write_regs(fe, R_EP1, 1);
         msleep(5); /* wanted mid measurement */
 
diff --git a/drivers/media/dvb/frontends/tda18271-fe.c b/drivers/media/dvb/frontends/tda18271-fe.c
index dfe72aaec380..b262100ae897 100644
--- a/drivers/media/dvb/frontends/tda18271-fe.c
+++ b/drivers/media/dvb/frontends/tda18271-fe.c
@@ -31,30 +31,23 @@ static int tda18271_cal_on_startup;
 module_param_named(cal, tda18271_cal_on_startup, int, 0644);
 MODULE_PARM_DESC(cal, "perform RF tracking filter calibration on startup");
 
-static LIST_HEAD(tda18271_list);
 static DEFINE_MUTEX(tda18271_list_mutex);
+static LIST_HEAD(hybrid_tuner_instance_list);
 
 /*---------------------------------------------------------------------*/
 
-static int tda18271_ir_cal_init(struct dvb_frontend *fe)
+static inline int charge_pump_source(struct dvb_frontend *fe, int force)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
-        unsigned char *regs = priv->tda18271_regs;
-
-        tda18271_read_regs(fe);
-
-        /* test IR_CAL_OK to see if we need init */
-        if ((regs[R_EP1] & 0x08) == 0)
-                tda18271_init_regs(fe);
-
-        return 0;
+        return tda18271_charge_pump_source(fe,
+                                           (priv->role == TDA18271_SLAVE) ?
+                                           TDA18271_CAL_PLL :
+                                           TDA18271_MAIN_PLL, force);
 }
 
-/* ------------------------------------------------------------------ */
-
 static int tda18271_channel_configuration(struct dvb_frontend *fe,
-                                          u32 ifc, u32 freq, u32 bw, u8 std,
-                                          int radio)
+                                          struct tda18271_std_map_item *map,
+                                          u32 freq, u32 bw)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         unsigned char *regs = priv->tda18271_regs;
@@ -64,38 +57,34 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
 
         /* set standard */
         regs[R_EP3]  &= ~0x1f; /* clear std bits */
-        regs[R_EP3]  |= std;
+        regs[R_EP3]  |= (map->agc_mode << 3) | map->std;
+
+        /* set rfagc to high speed mode */
+        regs[R_EP3] &= ~0x04;
 
         /* set cal mode to normal */
         regs[R_EP4]  &= ~0x03;
 
         /* update IF output level & IF notch frequency */
         regs[R_EP4]  &= ~0x1c; /* clear if level bits */
+        regs[R_EP4]  |= (map->if_lvl << 2);
 
         switch (priv->mode) {
         case TDA18271_ANALOG:
                 regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
                 break;
         case TDA18271_DIGITAL:
-                regs[R_EP4]  |= 0x04; /* IF level = 1 */
                 regs[R_MPD]  |= 0x80; /* IF notch = 1 */
                 break;
         }
 
-        if (radio)
-                regs[R_EP4]  |=  0x80;
-        else
-                regs[R_EP4]  &= ~0x80;
+        /* update FM_RFn */
+        regs[R_EP4]  &= ~0x80;
+        regs[R_EP4]  |= map->fm_rfn << 7;
 
-        /* update RF_TOP / IF_TOP */
-        switch (priv->mode) {
-        case TDA18271_ANALOG:
-                regs[R_EB22]  = 0x2c;
-                break;
-        case TDA18271_DIGITAL:
-                regs[R_EB22]  = 0x37;
-                break;
-        }
+        /* update rf top / if top */
+        regs[R_EB22]  = 0x00;
+        regs[R_EB22] |= map->rfagc_top;
         tda18271_write_regs(fe, R_EB22, 1);
 
         /* --------------------------------------------------------------- */
@@ -117,8 +106,14 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
 
         /* dual tuner and agc1 extra configuration */
 
-        /* main vco when Master, cal vco when slave */
-        regs[R_EB1]  |= 0x04; /* FIXME: assumes master */
+        switch (priv->role) {
+        case TDA18271_MASTER:
+                regs[R_EB1]  |= 0x04; /* main vco */
+                break;
+        case TDA18271_SLAVE:
+                regs[R_EB1]  &= ~0x04; /* cal vco */
+                break;
+        }
 
         /* agc1 always active */
         regs[R_EB1]  &= ~0x02;
@@ -130,25 +125,40 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
 
         /* --------------------------------------------------------------- */
 
-        N = freq + ifc;
+        N = map->if_freq * 1000 + freq;
 
-        /* FIXME: assumes master */
-        tda18271_calc_main_pll(fe, N);
-        tda18271_write_regs(fe, R_MPD, 4);
+        switch (priv->role) {
+        case TDA18271_MASTER:
+                tda18271_calc_main_pll(fe, N);
+                tda18271_write_regs(fe, R_MPD, 4);
+                break;
+        case TDA18271_SLAVE:
+                tda18271_calc_cal_pll(fe, N);
+                tda18271_write_regs(fe, R_CPD, 4);
+
+                regs[R_MPD] = regs[R_CPD] & 0x7f;
+                tda18271_write_regs(fe, R_MPD, 1);
+                break;
+        }
 
         tda18271_write_regs(fe, R_TM, 7);
 
-        /* main pll charge pump source */
-        regs[R_EB4] |= 0x20;
-        tda18271_write_regs(fe, R_EB4, 1);
+        /* force charge pump source */
+        charge_pump_source(fe, 1);
 
         msleep(1);
 
-        /* normal operation for the main pll */
-        regs[R_EB4] &= ~0x20;
-        tda18271_write_regs(fe, R_EB4, 1);
+        /* return pll to normal operation */
+        charge_pump_source(fe, 0);
 
-        msleep(5);
+        msleep(20);
+
+        /* set rfagc to normal speed mode */
+        if (map->fm_rfn)
+                regs[R_EP3] &= ~0x04;
+        else
+                regs[R_EP3] |= 0x04;
+        tda18271_write_regs(fe, R_EP3, 1);
 
         return 0;
 }
@@ -195,8 +205,10 @@ static int tda18271_read_thermometer(struct dvb_frontend *fe)
         return tm;
 }
 
-static int tda18271_rf_tracking_filters_correction(struct dvb_frontend *fe,
-                                                   u32 freq)
+/* ------------------------------------------------------------------ */
+
+static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe,
+                                                     u32 freq)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
@@ -296,12 +308,10 @@ static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
         tda18271_write_regs(fe, R_EB13, 1);
 
         /* main pll charge pump source */
-        regs[R_EB4]  |= 0x20;
-        tda18271_write_regs(fe, R_EB4, 1);
+        tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
 
         /* cal pll charge pump source */
-        regs[R_EB7]  |= 0x20;
-        tda18271_write_regs(fe, R_EB7, 1);
+        tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 1);
 
         /* force dcdc converter to 0 V */
         regs[R_EB14] = 0x00;
@@ -320,8 +330,8 @@ static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
         /* set the internal calibration signal */
         N = freq;
 
-        tda18271_calc_main_pll(fe, N);
-        tda18271_write_regs(fe, R_MPD, 4);
+        tda18271_calc_cal_pll(fe, N);
+        tda18271_write_regs(fe, R_CPD, 4);
 
         /* downconvert internal calibration */
         N += 1000000;
@@ -339,14 +349,12 @@ static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
         /* --------------------------------------------------------------- */
 
         /* normal operation for the main pll */
-        regs[R_EB4] &= ~0x20;
-        tda18271_write_regs(fe, R_EB4, 1);
+        tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
 
         /* normal operation for the cal pll  */
-        regs[R_EB7] &= ~0x20;
-        tda18271_write_regs(fe, R_EB7, 1);
+        tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 0);
 
-        msleep(5); /* plls locking */
+        msleep(10); /* plls locking */
 
         /* launch the rf tracking filters calibration */
         regs[R_EB20]  |= 0x20;
@@ -443,7 +451,7 @@ static int tda18271_powerscan(struct dvb_frontend *fe,
 
                 count += 200;
 
-                if (count < count_limit)
+                if (count <= count_limit)
                         continue;
 
                 if (sgn <= 0)
@@ -587,7 +595,7 @@ static int tda18271_calc_rf_filter_curve(struct dvb_frontend *fe)
 
 /* ------------------------------------------------------------------ */
 
-static int tda18271_rf_cal_init(struct dvb_frontend *fe)
+static int tda18271c2_rf_cal_init(struct dvb_frontend *fe)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         unsigned char *regs = priv->tda18271_regs;
@@ -610,63 +618,13 @@ static int tda18271_rf_cal_init(struct dvb_frontend *fe)
         return 0;
 }
 
-static int tda18271_init(struct dvb_frontend *fe)
-{
-        struct tda18271_priv *priv = fe->tuner_priv;
-
-        mutex_lock(&priv->lock);
-
-        /* power up */
-        tda18271_set_standby_mode(fe, 0, 0, 0);
-
-        /* initialization */
-        tda18271_ir_cal_init(fe);
-
-        if (priv->id == TDA18271HDC2)
-                tda18271_rf_cal_init(fe);
-
-        mutex_unlock(&priv->lock);
-
-        return 0;
-}
-
-static int tda18271c2_tune(struct dvb_frontend *fe,
-                           u32 ifc, u32 freq, u32 bw, u8 std, int radio)
-{
-        struct tda18271_priv *priv = fe->tuner_priv;
-
-        tda_dbg("freq = %d, ifc = %d\n", freq, ifc);
-
-        tda18271_init(fe);
-
-        mutex_lock(&priv->lock);
-
-        tda18271_rf_tracking_filters_correction(fe, freq);
-
-        tda18271_channel_configuration(fe, ifc, freq, bw, std, radio);
-
-        mutex_unlock(&priv->lock);
-
-        return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda18271c1_tune(struct dvb_frontend *fe,
-                           u32 ifc, u32 freq, u32 bw, u8 std, int radio)
+static int tda18271c1_rf_tracking_filter_calibration(struct dvb_frontend *fe,
+                                                     u32 freq, u32 bw)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         unsigned char *regs = priv->tda18271_regs;
         u32 N = 0;
 
-        tda18271_init(fe);
-
-        mutex_lock(&priv->lock);
-
-        tda_dbg("freq = %d, ifc = %d\n", freq, ifc);
-
-        /* RF tracking filter calibration */
-
         /* calculate bp filter */
         tda18271_calc_bp_filter(fe, &freq);
         tda18271_write_regs(fe, R_EP1, 1);
@@ -737,7 +695,7 @@ static int tda18271c1_tune(struct dvb_frontend *fe,
 
         regs[R_EB7]   = 0x40;
         tda18271_write_regs(fe, R_EB7, 1);
-        msleep(10);
+        msleep(10); /* pll locking */
 
         regs[R_EB20]  = 0xec;
         tda18271_write_regs(fe, R_EB20, 1);
@@ -752,74 +710,70 @@ static int tda18271c1_tune(struct dvb_frontend *fe,
         if (0 == tda18271_calc_rf_cal(fe, &freq))
                 tda18271_write_regs(fe, R_EB14, 1);
 
-        /* Channel Configuration */
+        return 0;
+}
 
-        switch (priv->mode) {
-        case TDA18271_ANALOG:
-                regs[R_EB22]  = 0x2c;
-                break;
-        case TDA18271_DIGITAL:
-                regs[R_EB22]  = 0x37;
-                break;
-        }
-        tda18271_write_regs(fe, R_EB22, 1);
+/* ------------------------------------------------------------------ */
 
-        regs[R_EP1]  |= 0x40; /* set dis power level on */
+static int tda18271_ir_cal_init(struct dvb_frontend *fe)
+{
+        struct tda18271_priv *priv = fe->tuner_priv;
+        unsigned char *regs = priv->tda18271_regs;
 
-        /* set standard */
-        regs[R_EP3]  &= ~0x1f; /* clear std bits */
+        tda18271_read_regs(fe);
 
-        /* see table 22 */
-        regs[R_EP3]  |= std;
+        /* test IR_CAL_OK to see if we need init */
+        if ((regs[R_EP1] & 0x08) == 0)
+                tda18271_init_regs(fe);
 
-        regs[R_EP4]  &= ~0x03; /* set cal mode to normal */
+        return 0;
+}
 
-        regs[R_EP4]  &= ~0x1c; /* clear if level bits */
-        switch (priv->mode) {
-        case TDA18271_ANALOG:
-                regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
-                break;
-        case TDA18271_DIGITAL:
-                regs[R_EP4]  |= 0x04;
-                regs[R_MPD]  |= 0x80;
-                break;
-        }
+static int tda18271_init(struct dvb_frontend *fe)
+{
+        struct tda18271_priv *priv = fe->tuner_priv;
 
-        if (radio)
-                regs[R_EP4]  |=  0x80;
-        else
-                regs[R_EP4]  &= ~0x80;
+        mutex_lock(&priv->lock);
 
-        /* image rejection validity */
-        tda18271_calc_ir_measure(fe, &freq);
+        /* power up */
+        tda18271_set_standby_mode(fe, 0, 0, 0);
 
-        /* calculate MAIN PLL */
-        N = freq + ifc;
+        /* initialization */
+        tda18271_ir_cal_init(fe);
 
-        tda18271_calc_main_pll(fe, N);
+        if (priv->id == TDA18271HDC2)
+                tda18271c2_rf_cal_init(fe);
 
-        tda18271_write_regs(fe, R_TM, 15);
-        msleep(5);
         mutex_unlock(&priv->lock);
 
         return 0;
 }
 
-static inline int tda18271_tune(struct dvb_frontend *fe,
-                                u32 ifc, u32 freq, u32 bw, u8 std, int radio)
+static int tda18271_tune(struct dvb_frontend *fe,
+                         struct tda18271_std_map_item *map, u32 freq, u32 bw)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
-        int ret = -EINVAL;
+
+        tda_dbg("freq = %d, ifc = %d, bw = %d, agc_mode = %d, std = %d\n",
+                freq, map->if_freq, bw, map->agc_mode, map->std);
+
+        tda18271_init(fe);
+
+        mutex_lock(&priv->lock);
 
         switch (priv->id) {
         case TDA18271HDC1:
-                ret = tda18271c1_tune(fe, ifc, freq, bw, std, radio);
+                tda18271c1_rf_tracking_filter_calibration(fe, freq, bw);
                 break;
         case TDA18271HDC2:
-                ret = tda18271c2_tune(fe, ifc, freq, bw, std, radio);
+                tda18271c2_rf_tracking_filters_correction(fe, freq);
                 break;
         }
-        return ret;
+        tda18271_channel_configuration(fe, map, freq, bw);
+
+        mutex_unlock(&priv->lock);
+
+        return 0;
 }
 
 /* ------------------------------------------------------------------ */
@@ -829,9 +783,8 @@ static int tda18271_set_params(struct dvb_frontend *fe,
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         struct tda18271_std_map *std_map = &priv->std;
+        struct tda18271_std_map_item *map;
         int ret;
-        u8 std;
-        u16 sgIF;
         u32 bw, freq = params->frequency;
 
         priv->mode = TDA18271_DIGITAL;
@@ -840,13 +793,11 @@ static int tda18271_set_params(struct dvb_frontend *fe,
                 switch (params->u.vsb.modulation) {
                 case VSB_8:
                 case VSB_16:
-                        std  = std_map->atsc_6.std_bits;
-                        sgIF = std_map->atsc_6.if_freq;
+                        map = &std_map->atsc_6;
                         break;
                 case QAM_64:
                 case QAM_256:
-                        std  = std_map->qam_6.std_bits;
-                        sgIF = std_map->qam_6.if_freq;
+                        map = &std_map->qam_6;
                         break;
                 default:
                         tda_warn("modulation not set!\n");
@@ -861,18 +812,15 @@ static int tda18271_set_params(struct dvb_frontend *fe,
                 switch (params->u.ofdm.bandwidth) {
                 case BANDWIDTH_6_MHZ:
                         bw = 6000000;
-                        std  = std_map->dvbt_6.std_bits;
-                        sgIF = std_map->dvbt_6.if_freq;
+                        map = &std_map->dvbt_6;
                         break;
                 case BANDWIDTH_7_MHZ:
                         bw = 7000000;
-                        std  = std_map->dvbt_7.std_bits;
-                        sgIF = std_map->dvbt_7.if_freq;
+                        map = &std_map->dvbt_7;
                         break;
                 case BANDWIDTH_8_MHZ:
                         bw = 8000000;
-                        std  = std_map->dvbt_8.std_bits;
-                        sgIF = std_map->dvbt_8.if_freq;
+                        map = &std_map->dvbt_8;
                         break;
                 default:
                         tda_warn("bandwidth not set!\n");
@@ -887,7 +835,7 @@ static int tda18271_set_params(struct dvb_frontend *fe,
         if (fe->ops.analog_ops.standby)
                 fe->ops.analog_ops.standby(fe);
 
-        ret = tda18271_tune(fe, sgIF * 1000, freq, bw, std, 0);
+        ret = tda18271_tune(fe, map, freq, bw);
 
         if (ret < 0)
                 goto fail;
@@ -904,57 +852,46 @@ static int tda18271_set_analog_params(struct dvb_frontend *fe,
 {
         struct tda18271_priv *priv = fe->tuner_priv;
         struct tda18271_std_map *std_map = &priv->std;
+        struct tda18271_std_map_item *map;
         char *mode;
-        int ret, radio = 0;
-        u8 std;
-        u16 sgIF;
+        int ret;
         u32 freq = params->frequency * 62500;
 
         priv->mode = TDA18271_ANALOG;
 
         if (params->mode == V4L2_TUNER_RADIO) {
-                radio = 1;
                 freq = freq / 1000;
-                std  = std_map->fm_radio.std_bits;
-                sgIF = std_map->fm_radio.if_freq;
+                map = &std_map->fm_radio;
                 mode = "fm";
         } else if (params->std & V4L2_STD_MN) {
-                std  = std_map->atv_mn.std_bits;
-                sgIF = std_map->atv_mn.if_freq;
+                map = &std_map->atv_mn;
                 mode = "MN";
         } else if (params->std & V4L2_STD_B) {
-                std  = std_map->atv_b.std_bits;
-                sgIF = std_map->atv_b.if_freq;
+                map = &std_map->atv_b;
                 mode = "B";
         } else if (params->std & V4L2_STD_GH) {
-                std  = std_map->atv_gh.std_bits;
-                sgIF = std_map->atv_gh.if_freq;
+                map = &std_map->atv_gh;
                 mode = "GH";
         } else if (params->std & V4L2_STD_PAL_I) {
-                std  = std_map->atv_i.std_bits;
-                sgIF = std_map->atv_i.if_freq;
+                map = &std_map->atv_i;
                 mode = "I";
         } else if (params->std & V4L2_STD_DK) {
-                std  = std_map->atv_dk.std_bits;
-                sgIF = std_map->atv_dk.if_freq;
+                map = &std_map->atv_dk;
                 mode = "DK";
         } else if (params->std & V4L2_STD_SECAM_L) {
-                std  = std_map->atv_l.std_bits;
-                sgIF = std_map->atv_l.if_freq;
+                map = &std_map->atv_l;
                 mode = "L";
         } else if (params->std & V4L2_STD_SECAM_LC) {
-                std  = std_map->atv_lc.std_bits;
-                sgIF = std_map->atv_lc.if_freq;
+                map = &std_map->atv_lc;
                 mode = "L'";
         } else {
-                std  = std_map->atv_i.std_bits;
-                sgIF = std_map->atv_i.if_freq;
+                map = &std_map->atv_i;
                 mode = "xx";
         }
 
         tda_dbg("setting tda18271 to system %s\n", mode);
 
-        ret = tda18271_tune(fe, sgIF * 1000, freq, 0, std, radio);
+        ret = tda18271_tune(fe, map, freq, 0);
 
         if (ret < 0)
                 goto fail;
@@ -986,16 +923,9 @@ static int tda18271_release(struct dvb_frontend *fe)
 
         mutex_lock(&tda18271_list_mutex);
 
-        priv->count--;
+        if (priv)
+                hybrid_tuner_release_state(priv);
 
-        if (!priv->count) {
-                tda_dbg("destroying instance @ %d-%04x\n",
-                        i2c_adapter_id(priv->i2c_adap),
-                        priv->i2c_addr);
-                list_del(&priv->tda18271_list);
-
-                kfree(priv);
-        }
         mutex_unlock(&tda18271_list_mutex);
 
         fe->tuner_priv = NULL;
@@ -1020,15 +950,20 @@ static int tda18271_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 /* ------------------------------------------------------------------ */
 
 #define tda18271_update_std(std_cfg, name) do {                         \
-        if (map->std_cfg.if_freq + map->std_cfg.std_bits > 0) {         \
+        if (map->std_cfg.if_freq +                                      \
+                map->std_cfg.agc_mode + map->std_cfg.std +              \
+                map->std_cfg.if_lvl + map->std_cfg.rfagc_top > 0) {     \
                 tda_dbg("Using custom std config for %s\n", name);      \
                 memcpy(&std->std_cfg, &map->std_cfg,                    \
                         sizeof(struct tda18271_std_map_item));          \
         } } while (0)
 
 #define tda18271_dump_std_item(std_cfg, name) do {                      \
-        tda_dbg("(%s) if freq = %d, std bits = 0x%02x\n",               \
-                name, std->std_cfg.if_freq, std->std_cfg.std_bits);     \
+        tda_dbg("(%s) if_freq = %d, agc_mode = %d, std = %d, "          \
+                "if_lvl = %d, rfagc_top = 0x%02x\n",                    \
+                name, std->std_cfg.if_freq,                             \
+                std->std_cfg.agc_mode, std->std_cfg.std,                \
+                std->std_cfg.if_lvl, std->std_cfg.rfagc_top);           \
         } while (0)
 
 static int tda18271_dump_std_map(struct dvb_frontend *fe)
@@ -1037,20 +972,20 @@ static int tda18271_dump_std_map(struct dvb_frontend *fe)
         struct tda18271_std_map *std = &priv->std;
 
         tda_dbg("========== STANDARD MAP SETTINGS ==========\n");
-        tda18271_dump_std_item(fm_radio, "fm");
-        tda18271_dump_std_item(atv_b,  "pal b");
-        tda18271_dump_std_item(atv_dk, "pal dk");
-        tda18271_dump_std_item(atv_gh, "pal gh");
-        tda18271_dump_std_item(atv_i,  "pal i");
-        tda18271_dump_std_item(atv_l,  "pal l");
-        tda18271_dump_std_item(atv_lc, "pal l'");
+        tda18271_dump_std_item(fm_radio, "  fm  ");
+        tda18271_dump_std_item(atv_b,  "atv b ");
+        tda18271_dump_std_item(atv_dk, "atv dk");
+        tda18271_dump_std_item(atv_gh, "atv gh");
+        tda18271_dump_std_item(atv_i,  "atv i ");
+        tda18271_dump_std_item(atv_l,  "atv l ");
+        tda18271_dump_std_item(atv_lc, "atv l'");
         tda18271_dump_std_item(atv_mn, "atv mn");
         tda18271_dump_std_item(atsc_6, "atsc 6");
         tda18271_dump_std_item(dvbt_6, "dvbt 6");
         tda18271_dump_std_item(dvbt_7, "dvbt 7");
         tda18271_dump_std_item(dvbt_8, "dvbt 8");
-        tda18271_dump_std_item(qam_6,  "qam 6");
-        tda18271_dump_std_item(qam_8,  "qam 8");
+        tda18271_dump_std_item(qam_6,  "qam 6 ");
+        tda18271_dump_std_item(qam_8,  "qam 8 ");
 
         return 0;
 }
@@ -1109,7 +1044,8 @@ static int tda18271_get_id(struct dvb_frontend *fe)
         }
 
         tda_info("%s detected @ %d-%04x%s\n", name,
-                 i2c_adapter_id(priv->i2c_adap), priv->i2c_addr,
+                 i2c_adapter_id(priv->i2c_props.adap),
+                 priv->i2c_props.addr,
                  (0 == ret) ? "" : ", device not supported.");
 
         return ret;
@@ -1136,45 +1072,28 @@ struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
                                      struct tda18271_config *cfg)
 {
         struct tda18271_priv *priv = NULL;
-        int state_found = 0;
+        int instance;
 
         mutex_lock(&tda18271_list_mutex);
 
-        list_for_each_entry(priv, &tda18271_list, tda18271_list) {
-                if ((i2c_adapter_id(priv->i2c_adap) == i2c_adapter_id(i2c)) &&
-                    (priv->i2c_addr == addr)) {
-                        tda_dbg("attaching existing tuner @ %d-%04x\n",
-                                i2c_adapter_id(priv->i2c_adap),
-                                priv->i2c_addr);
-                        priv->count++;
-                        fe->tuner_priv = priv;
-                        state_found = 1;
-                        /* allow dvb driver to override i2c gate setting */
-                        if ((cfg) && (cfg->gate != TDA18271_GATE_ANALOG))
-                                priv->gate = cfg->gate;
-                        break;
-                }
-        }
-        if (state_found == 0) {
-                tda_dbg("creating new tuner instance @ %d-%04x\n",
-                        i2c_adapter_id(i2c), addr);
-
-                priv = kzalloc(sizeof(struct tda18271_priv), GFP_KERNEL);
-                if (priv == NULL) {
-                        mutex_unlock(&tda18271_list_mutex);
-                        return NULL;
-                }
-
-                priv->i2c_addr = addr;
-                priv->i2c_adap = i2c;
+        instance = hybrid_tuner_request_state(struct tda18271_priv, priv,
+                                              hybrid_tuner_instance_list,
+                                              i2c, addr, "tda18271");
+        switch (instance) {
+        case 0:
+                goto fail;
+                break;
+        case 1:
+                /* new tuner instance */
                 priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO;
+                priv->role = (cfg) ? cfg->role : TDA18271_MASTER;
                 priv->cal_initialized = false;
                 mutex_init(&priv->lock);
-                priv->count++;
 
                 fe->tuner_priv = priv;
 
-                list_add_tail(&priv->tda18271_list, &tda18271_list);
+                if (cfg)
+                        priv->small_i2c = cfg->small_i2c;
 
                 if (tda18271_get_id(fe) < 0)
                         goto fail;
@@ -1186,9 +1105,18 @@ struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
                 tda18271_init_regs(fe);
 
                 if ((tda18271_cal_on_startup) && (priv->id == TDA18271HDC2))
-                        tda18271_rf_cal_init(fe);
+                        tda18271c2_rf_cal_init(fe);
 
                 mutex_unlock(&priv->lock);
+                break;
+        default:
+                /* existing tuner instance */
+                fe->tuner_priv = priv;
+
+                /* allow dvb driver to override i2c gate setting */
+                if ((cfg) && (cfg->gate != TDA18271_GATE_ANALOG))
+                        priv->gate = cfg->gate;
+                break;
         }
 
         /* override default std map with values in config struct */
@@ -1200,7 +1128,7 @@ struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
         memcpy(&fe->ops.tuner_ops, &tda18271_tuner_ops,
                sizeof(struct dvb_tuner_ops));
 
-        if (tda18271_debug & DBG_MAP)
+        if (tda18271_debug & (DBG_MAP | DBG_ADV))
                 tda18271_dump_std_map(fe);
 
         return fe;
@@ -1214,7 +1142,7 @@ EXPORT_SYMBOL_GPL(tda18271_attach);
 MODULE_DESCRIPTION("NXP TDA18271HD analog / digital tuner driver");
 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("0.2");
+MODULE_VERSION("0.3");
 
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
diff --git a/drivers/media/dvb/frontends/tda18271-priv.h b/drivers/media/dvb/frontends/tda18271-priv.h
index 7b939a5325fb..2bc5eb368ea2 100644
--- a/drivers/media/dvb/frontends/tda18271-priv.h
+++ b/drivers/media/dvb/frontends/tda18271-priv.h
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/mutex.h>
+#include "tuner-i2c.h"
 #include "tda18271.h"
 
 #define R_ID     0x00   /* ID byte                */
@@ -85,6 +86,11 @@ struct tda18271_rf_tracking_filter_cal {
         int rf_b2;
 };
 
+enum tda18271_pll {
+        TDA18271_MAIN_PLL,
+        TDA18271_CAL_PLL,
+};
+
 enum tda18271_mode {
         TDA18271_ANALOG,
         TDA18271_DIGITAL,
@@ -98,19 +104,19 @@ enum tda18271_ver {
 };
 
 struct tda18271_priv {
-        u8 i2c_addr;
-        struct i2c_adapter *i2c_adap;
         unsigned char tda18271_regs[TDA18271_NUM_REGS];
 
-        struct list_head tda18271_list;
+        struct list_head        hybrid_tuner_instance_list;
+        struct tuner_i2c_props  i2c_props;
 
         enum tda18271_mode mode;
+        enum tda18271_role role;
         enum tda18271_i2c_gate gate;
         enum tda18271_ver id;
 
-        unsigned int count;
         unsigned int tm_rfcal;
         unsigned int cal_initialized:1;
+        unsigned int small_i2c:1;
 
         struct tda18271_map_layout *maps;
         struct tda18271_std_map std;
@@ -133,7 +139,7 @@ extern int tda18271_debug;
 #define DBG_CAL  16
 
 #define tda_printk(kern, fmt, arg...) \
-        printk(kern "%s: " fmt, __FUNCTION__, ##arg)
+        printk(kern "%s: " fmt, __func__, ##arg)
 
 #define dprintk(kern, lvl, fmt, arg...) do {\
         if (tda18271_debug & lvl) \
@@ -188,6 +194,8 @@ extern int tda18271_read_extended(struct dvb_frontend *fe);
 extern int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len);
 extern int tda18271_init_regs(struct dvb_frontend *fe);
 
+extern int tda18271_charge_pump_source(struct dvb_frontend *fe,
+                                       enum tda18271_pll pll, int force);
 extern int tda18271_set_standby_mode(struct dvb_frontend *fe,
                                      int sm, int sm_lt, int sm_xt);
 
diff --git a/drivers/media/dvb/frontends/tda18271-tables.c b/drivers/media/dvb/frontends/tda18271-tables.c
index e94afcfdc5bc..83e7561960c1 100644
--- a/drivers/media/dvb/frontends/tda18271-tables.c
+++ b/drivers/media/dvb/frontends/tda18271-tables.c
@@ -1187,37 +1187,65 @@ fail:
 /*---------------------------------------------------------------------*/
 
 static struct tda18271_std_map tda18271c1_std_map = {
-        .fm_radio = { .if_freq = 1250, .std_bits = 0x18 },
-        .atv_b    = { .if_freq = 6750, .std_bits = 0x0e },
-        .atv_dk   = { .if_freq = 7750, .std_bits = 0x0f },
-        .atv_gh   = { .if_freq = 7750, .std_bits = 0x0f },
-        .atv_i    = { .if_freq = 7750, .std_bits = 0x0f },
-        .atv_l    = { .if_freq = 7750, .std_bits = 0x0f },
-        .atv_lc   = { .if_freq = 1250, .std_bits = 0x0f },
-        .atv_mn   = { .if_freq = 5750, .std_bits = 0x0d },
-        .atsc_6   = { .if_freq = 3250, .std_bits = 0x1c },
-        .dvbt_6   = { .if_freq = 3300, .std_bits = 0x1c },
-        .dvbt_7   = { .if_freq = 3800, .std_bits = 0x1d },
-        .dvbt_8   = { .if_freq = 4300, .std_bits = 0x1e },
-        .qam_6    = { .if_freq = 4000, .std_bits = 0x1d },
-        .qam_8    = { .if_freq = 5000, .std_bits = 0x1f },
+        .fm_radio = { .if_freq = 1250, .fm_rfn = 1, .agc_mode = 3, .std = 0,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x18 */
+        .atv_b    = { .if_freq = 6750, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+        .atv_dk   = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+        .atv_gh   = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+        .atv_i    = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+        .atv_l    = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+        .atv_lc   = { .if_freq = 1250, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+        .atv_mn   = { .if_freq = 5750, .fm_rfn = 0, .agc_mode = 1, .std = 5,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0d */
+        .atsc_6   = { .if_freq = 3250, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+        .dvbt_6   = { .if_freq = 3300, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+        .dvbt_7   = { .if_freq = 3800, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+        .dvbt_8   = { .if_freq = 4300, .fm_rfn = 0, .agc_mode = 3, .std = 6,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1e */
+        .qam_6    = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+        .qam_8    = { .if_freq = 5000, .fm_rfn = 0, .agc_mode = 3, .std = 7,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1f */
 };
 
 static struct tda18271_std_map tda18271c2_std_map = {
-        .fm_radio = { .if_freq = 1250, .std_bits = 0x18 },
-        .atv_b    = { .if_freq = 6000, .std_bits = 0x0d },
-        .atv_dk   = { .if_freq = 6900, .std_bits = 0x0e },
-        .atv_gh   = { .if_freq = 7100, .std_bits = 0x0e },
-        .atv_i    = { .if_freq = 7250, .std_bits = 0x0e },
-        .atv_l    = { .if_freq = 6900, .std_bits = 0x0e },
-        .atv_lc   = { .if_freq = 1250, .std_bits = 0x0e },
-        .atv_mn   = { .if_freq = 5400, .std_bits = 0x0c },
-        .atsc_6   = { .if_freq = 3250, .std_bits = 0x1c },
-        .dvbt_6   = { .if_freq = 3300, .std_bits = 0x1c },
-        .dvbt_7   = { .if_freq = 3500, .std_bits = 0x1c },
-        .dvbt_8   = { .if_freq = 4000, .std_bits = 0x1d },
-        .qam_6    = { .if_freq = 4000, .std_bits = 0x1d },
-        .qam_8    = { .if_freq = 5000, .std_bits = 0x1f },
+        .fm_radio = { .if_freq = 1250, .fm_rfn = 1, .agc_mode = 3, .std = 0,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x18 */
+        .atv_b    = { .if_freq = 6000, .fm_rfn = 0, .agc_mode = 1, .std = 5,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0d */
+        .atv_dk   = { .if_freq = 6900, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+        .atv_gh   = { .if_freq = 7100, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+        .atv_i    = { .if_freq = 7250, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+        .atv_l    = { .if_freq = 6900, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+        .atv_lc   = { .if_freq = 1250, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+        .atv_mn   = { .if_freq = 5400, .fm_rfn = 0, .agc_mode = 1, .std = 4,
+                      .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0c */
+        .atsc_6   = { .if_freq = 3250, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+        .dvbt_6   = { .if_freq = 3300, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+        .dvbt_7   = { .if_freq = 3500, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+        .dvbt_8   = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+        .qam_6    = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+        .qam_8    = { .if_freq = 5000, .fm_rfn = 0, .agc_mode = 3, .std = 7,
+                      .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1f */
 };
 
 /*---------------------------------------------------------------------*/
diff --git a/drivers/media/dvb/frontends/tda18271.h b/drivers/media/dvb/frontends/tda18271.h
index 24b0e35a2ab3..0e7af8d05a38 100644
--- a/drivers/media/dvb/frontends/tda18271.h
+++ b/drivers/media/dvb/frontends/tda18271.h
@@ -26,7 +26,17 @@
 
 struct tda18271_std_map_item {
         u16 if_freq;
-        u8 std_bits;
+
+        /* EP3[4:3] */
+        unsigned int agc_mode:2;
+        /* EP3[2:0] */
+        unsigned int std:3;
+        /* EP4[7] */
+        unsigned int fm_rfn:1;
+        /* EP4[4:2] */
+        unsigned int if_lvl:3;
+        /* EB22[6:0] */
+        unsigned int rfagc_top:7;
 };
 
 struct tda18271_std_map {
@@ -46,6 +56,11 @@ struct tda18271_std_map {
         struct tda18271_std_map_item qam_8;
 };
 
+enum tda18271_role {
+        TDA18271_MASTER = 0,
+        TDA18271_SLAVE,
+};
+
 enum tda18271_i2c_gate {
         TDA18271_GATE_AUTO = 0,
         TDA18271_GATE_ANALOG,
@@ -56,8 +71,14 @@ struct tda18271_config {
         /* override default if freq / std settings (optional) */
         struct tda18271_std_map *std_map;
 
+        /* master / slave tuner: master uses main pll, slave uses cal pll */
+        enum tda18271_role role;
+
         /* use i2c gate provided by analog or digital demod */
         enum tda18271_i2c_gate gate;
+
+        /* some i2c providers cant write all 39 registers at once */
+        unsigned int small_i2c:1;
 };
 
 #if defined(CONFIG_DVB_TDA18271) || (defined(CONFIG_DVB_TDA18271_MODULE) && defined(MODULE))
@@ -70,7 +91,7 @@ static inline struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe,
                                                    struct i2c_adapter *i2c,
                                                    struct tda18271_config *cfg)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif
diff --git a/drivers/media/dvb/frontends/tda8083.c b/drivers/media/dvb/frontends/tda8083.c
index 011b74f798a0..5b843b2e67e8 100644
--- a/drivers/media/dvb/frontends/tda8083.c
+++ b/drivers/media/dvb/frontends/tda8083.c
@@ -68,7 +68,7 @@ static int tda8083_writereg (struct tda8083_state* state, u8 reg, u8 data)
 
         if (ret != 1)
                 dprintk ("%s: writereg error (reg %02x, ret == %i)\n",
-                        __FUNCTION__, reg, ret);
+                        __func__, reg, ret);
 
         return (ret != 1) ? -1 : 0;
 }
@@ -83,7 +83,7 @@ static int tda8083_readregs (struct tda8083_state* state, u8 reg1, u8 *b, u8 len
 
         if (ret != 2)
                 dprintk ("%s: readreg error (reg %02x, ret == %i)\n",
-                        __FUNCTION__, reg1, ret);
+                        __func__, reg1, ret);
 
         return ret == 2 ? 0 : -1;
 }
diff --git a/drivers/media/dvb/frontends/tda8083.h b/drivers/media/dvb/frontends/tda8083.h
index 2d3307999f21..5a03c14a10e8 100644
--- a/drivers/media/dvb/frontends/tda8083.h
+++ b/drivers/media/dvb/frontends/tda8083.h
@@ -42,7 +42,7 @@ extern struct dvb_frontend* tda8083_attach(const struct tda8083_config* config,
 static inline struct dvb_frontend* tda8083_attach(const struct tda8083_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TDA8083
diff --git a/drivers/media/dvb/frontends/tda826x.c b/drivers/media/dvb/frontends/tda826x.c
index bd3ebc284835..a051554b5e25 100644
--- a/drivers/media/dvb/frontends/tda826x.c
+++ b/drivers/media/dvb/frontends/tda826x.c
@@ -26,7 +26,7 @@
 
 #include "tda826x.h"
 
-static int debug = 0;
+static int debug;
 #define dprintk(args...) \
         do { \
                 if (debug) printk(KERN_DEBUG "tda826x: " args); \
@@ -54,7 +54,7 @@ static int tda826x_sleep(struct dvb_frontend *fe)
         u8 buf [] = { 0x00, 0x8d };
         struct i2c_msg msg = { .addr = priv->i2c_address, .flags = 0, .buf = buf, .len = 2 };
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
 
         if (!priv->has_loopthrough)
                 buf[1] = 0xad;
@@ -62,7 +62,7 @@ static int tda826x_sleep(struct dvb_frontend *fe)
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if ((ret = i2c_transfer (priv->i2c, &msg, 1)) != 1) {
-                dprintk("%s: i2c error\n", __FUNCTION__);
+                dprintk("%s: i2c error\n", __func__);
         }
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 0);
@@ -75,13 +75,24 @@ static int tda826x_set_params(struct dvb_frontend *fe, struct dvb_frontend_param
         struct tda826x_priv *priv = fe->tuner_priv;
         int ret;
         u32 div;
+        u32 ksyms;
+        u32 bandwidth;
         u8 buf [11];
         struct i2c_msg msg = { .addr = priv->i2c_address, .flags = 0, .buf = buf, .len = 11 };
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
 
         div = (params->frequency + (1000-1)) / 1000;
 
+        /* BW = ((1 + RO) * SR/2 + 5) * 1.3      [SR in MSPS, BW in MHz] */
+        /* with R0 = 0.35 and some transformations: */
+        ksyms = params->u.qpsk.symbol_rate / 1000;
+        bandwidth = (878 * ksyms + 6500000) / 1000000 + 1;
+        if (bandwidth < 5)
+                bandwidth = 5;
+        else if (bandwidth > 36)
+                bandwidth = 36;
+
         buf[0] = 0x00; // subaddress
         buf[1] = 0x09; // powerdown RSSI + the magic value 1
         if (!priv->has_loopthrough)
@@ -89,7 +100,7 @@ static int tda826x_set_params(struct dvb_frontend *fe, struct dvb_frontend_param
         buf[2] = (1<<5) | 0x0b; // 1Mhz + 0.45 VCO
         buf[3] = div >> 7;
         buf[4] = div << 1;
-        buf[5] = 0x77; // baseband cut-off 19 MHz
+        buf[5] = ((bandwidth - 5) << 3) | 7; /* baseband cut-off */
         buf[6] = 0xfe; // baseband gain 9 db + no RF attenuation
         buf[7] = 0x83; // charge pumps at high, tests off
         buf[8] = 0x80; // recommended value 4 for AMPVCO + disable ports.
@@ -99,7 +110,7 @@ static int tda826x_set_params(struct dvb_frontend *fe, struct dvb_frontend_param
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if ((ret = i2c_transfer (priv->i2c, &msg, 1)) != 1) {
-                dprintk("%s: i2c error\n", __FUNCTION__);
+                dprintk("%s: i2c error\n", __func__);
         }
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 0);
@@ -138,7 +149,7 @@ struct dvb_frontend *tda826x_attach(struct dvb_frontend *fe, int addr, struct i2
         };
         int ret;
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
 
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
diff --git a/drivers/media/dvb/frontends/tda826x.h b/drivers/media/dvb/frontends/tda826x.h
index ad9981195961..89e97926ab23 100644
--- a/drivers/media/dvb/frontends/tda826x.h
+++ b/drivers/media/dvb/frontends/tda826x.h
@@ -45,7 +45,7 @@ static inline struct dvb_frontend* tda826x_attach(struct dvb_frontend *fe,
                                                   struct i2c_adapter *i2c,
                                                   int has_loopthrough)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TDA826X
diff --git a/drivers/media/dvb/frontends/tda827x.c b/drivers/media/dvb/frontends/tda827x.c
index 229b11987a58..d30d2c9094d9 100644
--- a/drivers/media/dvb/frontends/tda827x.c
+++ b/drivers/media/dvb/frontends/tda827x.c
@@ -25,7 +25,7 @@
 
 #include "tda827x.h"
 
-static int debug = 0;
+static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 
@@ -142,7 +142,7 @@ static int tda827xo_set_params(struct dvb_frontend *fe,
         int i, tuner_freq, if_freq;
         u32 N;
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
         switch (params->u.ofdm.bandwidth) {
         case BANDWIDTH_6_MHZ:
                 if_freq = 4000000;
@@ -186,7 +186,7 @@ static int tda827xo_set_params(struct dvb_frontend *fe,
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
                 printk("%s: could not write to tuner at addr: 0x%02x\n",
-                       __FUNCTION__, priv->i2c_addr << 1);
+                       __func__, priv->i2c_addr << 1);
                 return -EIO;
         }
         msleep(500);
@@ -212,7 +212,7 @@ static int tda827xo_sleep(struct dvb_frontend *fe)
         struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
                                .buf = buf, .len = sizeof(buf) };
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(priv->i2c_adap, &msg, 1);
@@ -389,6 +389,79 @@ static struct tda827xa_data tda827xa_analog[] = {
         { .lomax =         0, .svco = 0, .spd = 0, .scr = 0, .sbs = 0, .gc3 = 0}
 };
 
+static int tda827xa_sleep(struct dvb_frontend *fe)
+{
+        struct tda827x_priv *priv = fe->tuner_priv;
+        static u8 buf[] = { 0x30, 0x90 };
+        struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                               .buf = buf, .len = sizeof(buf) };
+
+        dprintk("%s:\n", __func__);
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
+
+        i2c_transfer(priv->i2c_adap, &msg, 1);
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 0);
+
+        if (priv->cfg && priv->cfg->sleep)
+                priv->cfg->sleep(fe);
+
+        return 0;
+}
+
+static void tda827xa_lna_gain(struct dvb_frontend *fe, int high,
+                              struct analog_parameters *params)
+{
+        struct tda827x_priv *priv = fe->tuner_priv;
+        unsigned char buf[] = {0x22, 0x01};
+        int arg;
+        int gp_func;
+        struct i2c_msg msg = { .addr = priv->cfg->switch_addr, .flags = 0,
+                               .buf = buf, .len = sizeof(buf) };
+
+        if (NULL == priv->cfg) {
+                dprintk("tda827x_config not defined, cannot set LNA gain!\n");
+                return;
+        }
+        if (priv->cfg->config) {
+                if (high)
+                        dprintk("setting LNA to high gain\n");
+                else
+                        dprintk("setting LNA to low gain\n");
+        }
+        switch (priv->cfg->config) {
+        case 0: /* no LNA */
+                break;
+        case 1: /* switch is GPIO 0 of tda8290 */
+        case 2:
+                if (params == NULL) {
+                        gp_func = 0;
+                        arg  = 0;
+                } else {
+                        /* turn Vsync on */
+                        gp_func = 1;
+                        if (params->std & V4L2_STD_MN)
+                                arg = 1;
+                        else
+                                arg = 0;
+                }
+                if (priv->cfg->tuner_callback)
+                        priv->cfg->tuner_callback(priv->i2c_adap->algo_data,
+                                                                gp_func, arg);
+                buf[1] = high ? 0 : 1;
+                if (priv->cfg->config == 2)
+                        buf[1] = high ? 1 : 0;
+                i2c_transfer(priv->i2c_adap, &msg, 1);
+                break;
+        case 3: /* switch with GPIO of saa713x */
+                if (priv->cfg->tuner_callback)
+                        priv->cfg->tuner_callback(priv->i2c_adap->algo_data, 0, high);
+                break;
+        }
+}
+
 static int tda827xa_set_params(struct dvb_frontend *fe,
                                struct dvb_frontend_parameters *params)
 {
@@ -401,9 +474,9 @@ static int tda827xa_set_params(struct dvb_frontend *fe,
         int i, tuner_freq, if_freq;
         u32 N;
 
-        dprintk("%s:\n", __FUNCTION__);
-        if (priv->cfg && priv->cfg->lna_gain)
-                priv->cfg->lna_gain(fe, 1);
+        dprintk("%s:\n", __func__);
+
+        tda827xa_lna_gain(fe, 1, NULL);
         msleep(20);
 
         switch (params->u.ofdm.bandwidth) {
@@ -444,7 +517,7 @@ static int tda827xa_set_params(struct dvb_frontend *fe,
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
                 printk("%s: could not write to tuner at addr: 0x%02x\n",
-                       __FUNCTION__, priv->i2c_addr << 1);
+                       __func__, priv->i2c_addr << 1);
                 return -EIO;
         }
         buf[0] = 0x90;
@@ -474,8 +547,7 @@ static int tda827xa_set_params(struct dvb_frontend *fe,
         buf[1] >>= 4;
         dprintk("tda8275a AGC2 gain is: %d\n", buf[1]);
         if ((buf[1]) < 2) {
-                if (priv->cfg && priv->cfg->lna_gain)
-                        priv->cfg->lna_gain(fe, 0);
+                tda827xa_lna_gain(fe, 0, NULL);
                 buf[0] = 0x60;
                 buf[1] = 0x0c;
                 if (fe->ops.i2c_gate_ctrl)
@@ -523,75 +595,6 @@ static int tda827xa_set_params(struct dvb_frontend *fe,
         return 0;
 }
 
-static int tda827xa_sleep(struct dvb_frontend *fe)
-{
-        struct tda827x_priv *priv = fe->tuner_priv;
-        static u8 buf[] = { 0x30, 0x90 };
-        struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                               .buf = buf, .len = sizeof(buf) };
-
-        dprintk("%s:\n", __FUNCTION__);
-        if (fe->ops.i2c_gate_ctrl)
-                fe->ops.i2c_gate_ctrl(fe, 1);
-
-        i2c_transfer(priv->i2c_adap, &msg, 1);
-
-        if (fe->ops.i2c_gate_ctrl)
-                fe->ops.i2c_gate_ctrl(fe, 0);
-
-        if (priv->cfg && priv->cfg->sleep)
-                priv->cfg->sleep(fe);
-
-        return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-static void tda827xa_lna_gain(struct dvb_frontend *fe, int high,
-                              struct analog_parameters *params)
-{
-        struct tda827x_priv *priv = fe->tuner_priv;
-        unsigned char buf[] = {0x22, 0x01};
-        int arg;
-        struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                               .buf = buf, .len = sizeof(buf) };
-
-        if (NULL == priv->cfg) {
-                dprintk("tda827x_config not defined, cannot set LNA gain!\n");
-                return;
-        }
-
-        if (priv->cfg->config) {
-                if (high)
-                        dprintk("setting LNA to high gain\n");
-                else
-                        dprintk("setting LNA to low gain\n");
-        }
-        switch (*priv->cfg->config) {
-        case 0: /* no LNA */
-                break;
-        case 1: /* switch is GPIO 0 of tda8290 */
-        case 2:
-                /* turn Vsync on */
-                if (params->std & V4L2_STD_MN)
-                        arg = 1;
-                else
-                        arg = 0;
-                if (priv->cfg->tuner_callback)
-                        priv->cfg->tuner_callback(priv->i2c_adap->algo_data,
-                                                  1, arg);
-                buf[1] = high ? 0 : 1;
-                if (*priv->cfg->config == 2)
-                        buf[1] = high ? 1 : 0;
-                i2c_transfer(priv->i2c_adap, &msg, 1);
-                break;
-        case 3: /* switch with GPIO of saa713x */
-                if (priv->cfg->tuner_callback)
-                        priv->cfg->tuner_callback(priv->i2c_adap->algo_data,
-                                                  0, high);
-                break;
-        }
-}
 
 static int tda827xa_set_analog_params(struct dvb_frontend *fe,
                                       struct analog_parameters *params)
@@ -726,7 +729,7 @@ static int tda827x_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 static int tda827x_init(struct dvb_frontend *fe)
 {
         struct tda827x_priv *priv = fe->tuner_priv;
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
         if (priv->cfg && priv->cfg->init)
                 priv->cfg->init(fe);
 
@@ -794,7 +797,7 @@ static int tda827x_probe_version(struct dvb_frontend *fe)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
                 printk("%s: could not read from tuner at addr: 0x%02x\n",
-                       __FUNCTION__, msg.addr << 1);
+                       __func__, msg.addr << 1);
                 return -EIO;
         }
         if ((data & 0x3c) == 0) {
@@ -818,7 +821,7 @@ struct dvb_frontend *tda827x_attach(struct dvb_frontend *fe, int addr,
 {
         struct tda827x_priv *priv = NULL;
 
-        dprintk("%s:\n", __FUNCTION__);
+        dprintk("%s:\n", __func__);
         priv = kzalloc(sizeof(struct tda827x_priv), GFP_KERNEL);
         if (priv == NULL)
                 return NULL;
diff --git a/drivers/media/dvb/frontends/tda827x.h b/drivers/media/dvb/frontends/tda827x.h
index 92eb65b4012b..b73c23570dab 100644
--- a/drivers/media/dvb/frontends/tda827x.h
+++ b/drivers/media/dvb/frontends/tda827x.h
@@ -30,12 +30,12 @@
 struct tda827x_config
 {
         /* saa7134 - provided callbacks */
-        void (*lna_gain) (struct dvb_frontend *fe, int high);
         int (*init) (struct dvb_frontend *fe);
         int (*sleep) (struct dvb_frontend *fe);
 
         /* interface to tda829x driver */
-        unsigned int *config;
+        unsigned int config;
+        int          switch_addr;
         int (*tuner_callback) (void *dev, int command, int arg);
 
         void (*agcf)(struct dvb_frontend *fe);
@@ -61,7 +61,7 @@ static inline struct dvb_frontend* tda827x_attach(struct dvb_frontend *fe,
                                                   struct i2c_adapter *i2c,
                                                   struct tda827x_config *cfg)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TDA827X
diff --git a/drivers/media/dvb/frontends/tua6100.c b/drivers/media/dvb/frontends/tua6100.c
index 6ba0029dcf2e..1790baee014c 100644
--- a/drivers/media/dvb/frontends/tua6100.c
+++ b/drivers/media/dvb/frontends/tua6100.c
@@ -58,7 +58,7 @@ static int tua6100_sleep(struct dvb_frontend *fe)
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if ((ret = i2c_transfer (priv->i2c, &msg, 1)) != 1) {
-                printk("%s: i2c error\n", __FUNCTION__);
+                printk("%s: i2c error\n", __func__);
         }
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 0);
diff --git a/drivers/media/dvb/frontends/tua6100.h b/drivers/media/dvb/frontends/tua6100.h
index 03a665e7df6d..f83dbd5e42ae 100644
--- a/drivers/media/dvb/frontends/tua6100.h
+++ b/drivers/media/dvb/frontends/tua6100.h
@@ -39,7 +39,7 @@ extern struct dvb_frontend *tua6100_attach(struct dvb_frontend *fe, int addr, st
 #else
 static inline struct dvb_frontend* tua6100_attach(struct dvb_frontend *fe, int addr, struct i2c_adapter *i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TUA6100
diff --git a/drivers/media/dvb/frontends/ves1820.c b/drivers/media/dvb/frontends/ves1820.c
index 8791701c8f25..a184597f1d9b 100644
--- a/drivers/media/dvb/frontends/ves1820.c
+++ b/drivers/media/dvb/frontends/ves1820.c
@@ -66,7 +66,7 @@ static int ves1820_writereg(struct ves1820_state *state, u8 reg, u8 data)
 
         if (ret != 1)
                 printk("ves1820: %s(): writereg error (reg == 0x%02x, "
-                        "val == 0x%02x, ret == %i)\n", __FUNCTION__, reg, data, ret);
+                        "val == 0x%02x, ret == %i)\n", __func__, reg, data, ret);
 
         return (ret != 1) ? -EREMOTEIO : 0;
 }
@@ -85,7 +85,7 @@ static u8 ves1820_readreg(struct ves1820_state *state, u8 reg)
 
         if (ret != 2)
                 printk("ves1820: %s(): readreg error (reg == 0x%02x, "
-                "ret == %i)\n", __FUNCTION__, reg, ret);
+                "ret == %i)\n", __func__, reg, ret);
 
         return b1[0];
 }
diff --git a/drivers/media/dvb/frontends/ves1820.h b/drivers/media/dvb/frontends/ves1820.h
index e4a2a324046a..e902ed634ec3 100644
--- a/drivers/media/dvb/frontends/ves1820.h
+++ b/drivers/media/dvb/frontends/ves1820.h
@@ -48,7 +48,7 @@ extern struct dvb_frontend* ves1820_attach(const struct ves1820_config* config,
 static inline struct dvb_frontend* ves1820_attach(const struct ves1820_config* config,
                                            struct i2c_adapter* i2c, u8 pwm)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_VES1820
diff --git a/drivers/media/dvb/frontends/ves1x93.c b/drivers/media/dvb/frontends/ves1x93.c
index 23fd0303c91b..bd558960bd87 100644
--- a/drivers/media/dvb/frontends/ves1x93.c
+++ b/drivers/media/dvb/frontends/ves1x93.c
@@ -48,7 +48,7 @@ struct ves1x93_state {
         u8 demod_type;
 };
 
-static int debug = 0;
+static int debug;
 #define dprintk if (debug) printk
 
 #define DEMOD_VES1893           0
@@ -98,7 +98,7 @@ static int ves1x93_writereg (struct ves1x93_state* state, u8 reg, u8 data)
         int err;
 
         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
-                dprintk ("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __FUNCTION__, err, reg, data);
+                dprintk ("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __func__, err, reg, data);
                 return -EREMOTEIO;
         }
 
@@ -179,7 +179,7 @@ static int ves1x93_set_symbolrate (struct ves1x93_state* state, u32 srate)
         u32 tmp;
         u32 FIN;
 
-        dprintk("%s: srate == %d\n", __FUNCTION__, (unsigned int) srate);
+        dprintk("%s: srate == %d\n", __func__, (unsigned int) srate);
 
         if (srate > state->config->xin/2)
                 srate = state->config->xin/2;
@@ -266,7 +266,7 @@ static int ves1x93_init (struct dvb_frontend* fe)
         int i;
         int val;
 
-        dprintk("%s: init chip\n", __FUNCTION__);
+        dprintk("%s: init chip\n", __func__);
 
         for (i = 0; i < state->tab_size; i++) {
                 if (state->init_1x93_wtab[i]) {
diff --git a/drivers/media/dvb/frontends/ves1x93.h b/drivers/media/dvb/frontends/ves1x93.h
index d507f8966f81..8a5a49e808f6 100644
--- a/drivers/media/dvb/frontends/ves1x93.h
+++ b/drivers/media/dvb/frontends/ves1x93.h
@@ -47,7 +47,7 @@ extern struct dvb_frontend* ves1x93_attach(const struct ves1x93_config* config,
 static inline struct dvb_frontend* ves1x93_attach(const struct ves1x93_config* config,
                                            struct i2c_adapter* i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_VES1X93
diff --git a/drivers/media/dvb/frontends/xc5000.c b/drivers/media/dvb/frontends/xc5000.c
index f642ca200b59..43d35bdb221f 100644
--- a/drivers/media/dvb/frontends/xc5000.c
+++ b/drivers/media/dvb/frontends/xc5000.c
@@ -151,7 +151,7 @@ typedef struct {
 #define FM_Radio_INPUT2         21
 #define FM_Radio_INPUT1         22
 
-XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
+static XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
         {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
         {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
         {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
@@ -209,7 +209,7 @@ static void xc5000_TunerReset(struct dvb_frontend *fe)
         struct xc5000_priv *priv = fe->tuner_priv;
         int ret;
 
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         if (priv->cfg->tuner_callback) {
                 ret = priv->cfg->tuner_callback(priv->cfg->priv,
@@ -330,7 +330,7 @@ static int xc_load_i2c_sequence(struct dvb_frontend *fe, u8 i2c_sequence[])
 
 static int xc_initialize(struct xc5000_priv *priv)
 {
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
         return xc_write_reg(priv, XREG_INIT, 0);
 }
 
@@ -338,9 +338,9 @@ static int xc_SetTVStandard(struct xc5000_priv *priv,
         u16 VideoMode, u16 AudioMode)
 {
         int ret;
-        dprintk(1, "%s(0x%04x,0x%04x)\n", __FUNCTION__, VideoMode, AudioMode);
+        dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
         dprintk(1, "%s() Standard = %s\n",
-                __FUNCTION__,
+                __func__,
                 XC5000_Standard[priv->video_standard].Name);
 
         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
@@ -361,7 +361,7 @@ static int xc_shutdown(struct xc5000_priv *priv)
 
 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
 {
-        dprintk(1, "%s(%d) Source = %s\n", __FUNCTION__, rf_mode,
+        dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
 
         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE))
@@ -369,7 +369,7 @@ static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
                 rf_mode = XC_RF_MODE_CABLE;
                 printk(KERN_ERR
                         "%s(), Invalid mode, defaulting to CABLE",
-                        __FUNCTION__);
+                        __func__);
         }
         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
 }
@@ -380,7 +380,7 @@ static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
 {
         u16 freq_code;
 
-        dprintk(1, "%s(%u)\n", __FUNCTION__, freq_hz);
+        dprintk(1, "%s(%u)\n", __func__, freq_hz);
 
         if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
                 (freq_hz < xc5000_tuner_ops.info.frequency_min))
@@ -396,7 +396,7 @@ static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
 {
         u32 freq_code = (freq_khz * 1024)/1000;
         dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
-                __FUNCTION__, freq_khz, freq_code);
+                __func__, freq_khz, freq_code);
 
         return xc_write_reg(priv, XREG_IF_OUT, freq_code);
 }
@@ -488,7 +488,7 @@ static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz)
 {
         int found = 0;
 
-        dprintk(1, "%s(%u)\n", __FUNCTION__, freq_hz);
+        dprintk(1, "%s(%u)\n", __func__, freq_hz);
 
         if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
                 return 0;
@@ -627,12 +627,12 @@ static int xc5000_set_params(struct dvb_frontend *fe,
         struct xc5000_priv *priv = fe->tuner_priv;
         int ret;
 
-        dprintk(1, "%s() frequency=%d (Hz)\n", __FUNCTION__, params->frequency);
+        dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
 
         switch(params->u.vsb.modulation) {
         case VSB_8:
         case VSB_16:
-                dprintk(1, "%s() VSB modulation\n", __FUNCTION__);
+                dprintk(1, "%s() VSB modulation\n", __func__);
                 priv->rf_mode = XC_RF_MODE_AIR;
                 priv->freq_hz = params->frequency - 1750000;
                 priv->bandwidth = BANDWIDTH_6_MHZ;
@@ -641,7 +641,7 @@ static int xc5000_set_params(struct dvb_frontend *fe,
         case QAM_64:
         case QAM_256:
         case QAM_AUTO:
-                dprintk(1, "%s() QAM modulation\n", __FUNCTION__);
+                dprintk(1, "%s() QAM modulation\n", __func__);
                 priv->rf_mode = XC_RF_MODE_CABLE;
                 priv->freq_hz = params->frequency - 1750000;
                 priv->bandwidth = BANDWIDTH_6_MHZ;
@@ -652,7 +652,7 @@ static int xc5000_set_params(struct dvb_frontend *fe,
         }
 
         dprintk(1, "%s() frequency=%d (compensated)\n",
-                __FUNCTION__, priv->freq_hz);
+                __func__, priv->freq_hz);
 
         ret = xc_SetSignalSource(priv, priv->rf_mode);
         if (ret != XC_RESULT_SUCCESS) {
@@ -697,7 +697,7 @@ static int xc5000_set_analog_params(struct dvb_frontend *fe,
                 xc_load_fw_and_init_tuner(fe);
 
         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
-                __FUNCTION__, params->frequency);
+                __func__, params->frequency);
 
         priv->rf_mode = XC_RF_MODE_CABLE; /* Fix me: it could be air. */
 
@@ -775,7 +775,7 @@ tune_channel:
 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 {
         struct xc5000_priv *priv = fe->tuner_priv;
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
         *freq = priv->freq_hz;
         return 0;
 }
@@ -783,7 +783,7 @@ static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
 {
         struct xc5000_priv *priv = fe->tuner_priv;
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         *bw = priv->bandwidth;
         return 0;
@@ -796,7 +796,7 @@ static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
 
         xc_get_lock_status(priv, &lock_status);
 
-        dprintk(1, "%s() lock_status = 0x%08x\n", __FUNCTION__, lock_status);
+        dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
 
         *status = lock_status;
 
@@ -836,7 +836,7 @@ static int xc5000_sleep(struct dvb_frontend *fe)
         struct xc5000_priv *priv = fe->tuner_priv;
         int ret;
 
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         /* On Pinnacle PCTV HD 800i, the tuner cannot be reinitialized
          * once shutdown without reloading the driver. Maybe I am not
@@ -848,7 +848,7 @@ static int xc5000_sleep(struct dvb_frontend *fe)
         if(ret != XC_RESULT_SUCCESS) {
                 printk(KERN_ERR
                         "xc5000: %s() unable to shutdown tuner\n",
-                        __FUNCTION__);
+                        __func__);
                 return -EREMOTEIO;
         }
         else {
@@ -860,7 +860,7 @@ static int xc5000_sleep(struct dvb_frontend *fe)
 static int xc5000_init(struct dvb_frontend *fe)
 {
         struct xc5000_priv *priv = fe->tuner_priv;
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
@@ -875,7 +875,7 @@ static int xc5000_init(struct dvb_frontend *fe)
 
 static int xc5000_release(struct dvb_frontend *fe)
 {
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
         kfree(fe->tuner_priv);
         fe->tuner_priv = NULL;
         return 0;
@@ -907,7 +907,7 @@ struct dvb_frontend * xc5000_attach(struct dvb_frontend *fe,
         struct xc5000_priv *priv = NULL;
         u16 id = 0;
 
-        dprintk(1, "%s()\n", __FUNCTION__);
+        dprintk(1, "%s()\n", __func__);
 
         priv = kzalloc(sizeof(struct xc5000_priv), GFP_KERNEL);
         if (priv == NULL)
diff --git a/drivers/media/dvb/frontends/xc5000.h b/drivers/media/dvb/frontends/xc5000.h
index 32a5f1c86a16..b890883a0cdc 100644
--- a/drivers/media/dvb/frontends/xc5000.h
+++ b/drivers/media/dvb/frontends/xc5000.h
@@ -55,7 +55,7 @@ static inline struct dvb_frontend* xc5000_attach(struct dvb_frontend *fe,
                                                  struct i2c_adapter *i2c,
                                                  struct xc5000_config *cfg)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif // CONFIG_DVB_TUNER_XC5000
diff --git a/drivers/media/dvb/frontends/zl10353.c b/drivers/media/dvb/frontends/zl10353.c
index 276e3b631dc2..36a5a1c101d5 100644
--- a/drivers/media/dvb/frontends/zl10353.c
+++ b/drivers/media/dvb/frontends/zl10353.c
@@ -46,7 +46,7 @@ static int debug;
                 if (debug) printk(KERN_DEBUG "zl10353: " args); \
         } while (0)
 
-static int debug_regs = 0;
+static int debug_regs;
 
 static int zl10353_single_write(struct dvb_frontend *fe, u8 reg, u8 val)
 {
@@ -88,7 +88,7 @@ static int zl10353_read_register(struct zl10353_state *state, u8 reg)
 
         if (ret != 2) {
                 printk("%s: readreg error (reg=%d, ret==%i)\n",
-                       __FUNCTION__, reg, ret);
+                       __func__, reg, ret);
                 return ret;
         }
 
@@ -152,7 +152,7 @@ static void zl10353_calc_nominal_rate(struct dvb_frontend *fe,
         *nominal_rate = value;
 
         dprintk("%s: bw %d, adc_clock %d => 0x%x\n",
-                __FUNCTION__, bw, adc_clock, *nominal_rate);
+                __func__, bw, adc_clock, *nominal_rate);
 }
 
 static void zl10353_calc_input_freq(struct dvb_frontend *fe,
@@ -181,7 +181,7 @@ static void zl10353_calc_input_freq(struct dvb_frontend *fe,
         *input_freq = -value;
 
         dprintk("%s: if2 %d, ife %d, adc_clock %d => %d / 0x%x\n",
-                __FUNCTION__, if2, ife, adc_clock, -(int)value, *input_freq);
+                __func__, if2, ife, adc_clock, -(int)value, *input_freq);
 }
 
 static int zl10353_sleep(struct dvb_frontend *fe)
diff --git a/drivers/media/dvb/frontends/zl10353.h b/drivers/media/dvb/frontends/zl10353.h
index fc734c22b5fa..fdbb88ff75fe 100644
--- a/drivers/media/dvb/frontends/zl10353.h
+++ b/drivers/media/dvb/frontends/zl10353.h
@@ -47,7 +47,7 @@ extern struct dvb_frontend* zl10353_attach(const struct zl10353_config *config,
 static inline struct dvb_frontend* zl10353_attach(const struct zl10353_config *config,
                                            struct i2c_adapter *i2c)
 {
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
 }
 #endif /* CONFIG_DVB_ZL10353 */
diff --git a/drivers/media/dvb/pluto2/pluto2.c b/drivers/media/dvb/pluto2/pluto2.c
index 08a2599ed74a..960ed5763ae1 100644
--- a/drivers/media/dvb/pluto2/pluto2.c
+++ b/drivers/media/dvb/pluto2/pluto2.c
@@ -39,6 +39,8 @@
 #include "dvbdev.h"
 #include "tda1004x.h"
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define DRIVER_NAME             "pluto2"
 
 #define REG_PIDn(n)             ((n) << 2)      /* PID n pattern registers */
@@ -662,7 +664,8 @@ static int __devinit pluto2_probe(struct pci_dev *pdev,
                 goto err_pluto_hw_exit;
 
         /* dvb */
-        ret = dvb_register_adapter(&pluto->dvb_adapter, DRIVER_NAME, THIS_MODULE, &pdev->dev);
+        ret = dvb_register_adapter(&pluto->dvb_adapter, DRIVER_NAME,
+                                   THIS_MODULE, &pdev->dev, adapter_nr);
         if (ret < 0)
                 goto err_i2c_del_adapter;
 
diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c
index 0e5701bdff19..747e7f1a6267 100644
--- a/drivers/media/dvb/ttpci/av7110.c
+++ b/drivers/media/dvb/ttpci/av7110.c
@@ -112,6 +112,8 @@ MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14:
 module_param(tv_standard, int, 0444);
 MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 static void restart_feeds(struct av7110 *av7110);
 
 static int av7110_num;
@@ -359,7 +361,7 @@ static inline void start_debi_dma(struct av7110 *av7110, int dir,
 {
         dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
         if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
-                printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__);
+                printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
                 return;
         }
 
@@ -497,7 +499,7 @@ static void gpioirq(unsigned long data)
                        saa7146_read(av7110->dev, SSR));
 
         if (saa7146_wait_for_debi_done(av7110->dev, 0)) {
-                printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __FUNCTION__);
+                printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
                 BUG(); /* maybe we should try resetting the debi? */
         }
 
@@ -827,7 +829,7 @@ static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
         if (ret != 0 || handle >= 32) {
                 printk("dvb-ttpci: %s error  buf %04x %04x %04x %04x  "
                                 "ret %d  handle %04x\n",
-                                __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
+                                __func__, buf[0], buf[1], buf[2], buf[3],
                                 ret, handle);
                 dvbdmxfilter->hw_handle = 0xffff;
                 if (!ret)
@@ -854,7 +856,7 @@ static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
         handle = dvbdmxfilter->hw_handle;
         if (handle >= 32) {
                 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
-                                __FUNCTION__, handle, dvbdmxfilter->type);
+                                __func__, handle, dvbdmxfilter->type);
                 return -EINVAL;
         }
 
@@ -867,7 +869,7 @@ static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
         if (ret != 0 || answ[1] != handle) {
                 printk("dvb-ttpci: %s error  cmd %04x %04x %04x  ret %x  "
                                 "resp %04x %04x  pid %d\n",
-                                __FUNCTION__, buf[0], buf[1], buf[2], ret,
+                                __func__, buf[0], buf[1], buf[2], ret,
                                 answ[0], answ[1], dvbdmxfilter->feed->pid);
                 if (!ret)
                         ret = -1;
@@ -1122,7 +1124,7 @@ static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
 
         ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
         if (ret) {
-                printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
+                printk(KERN_ERR "%s: av7110_fw_request error\n", __func__);
                 return ret;
         }
         dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
@@ -2461,7 +2463,7 @@ static int __devinit av7110_attach(struct saa7146_dev* dev,
                 goto err_kfree_0;
 
         ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
-                                   THIS_MODULE, &dev->pci->dev);
+                                   THIS_MODULE, &dev->pci->dev, adapter_nr);
         if (ret < 0)
                 goto err_put_firmware_1;
 
diff --git a/drivers/media/dvb/ttpci/av7110.h b/drivers/media/dvb/ttpci/av7110.h
index 39fbf7d5cffb..e494e04eeee8 100644
--- a/drivers/media/dvb/ttpci/av7110.h
+++ b/drivers/media/dvb/ttpci/av7110.h
@@ -40,7 +40,7 @@
 extern int av7110_debug;
 
 #define dprintk(level,args...) \
-            do { if ((av7110_debug & level)) { printk("dvb-ttpci: %s(): ", __FUNCTION__); printk(args); } } while (0)
+            do { if ((av7110_debug & level)) { printk("dvb-ttpci: %s(): ", __func__); printk(args); } } while (0)
 
 #define MAXFILT 32
 
diff --git a/drivers/media/dvb/ttpci/av7110_hw.c b/drivers/media/dvb/ttpci/av7110_hw.c
index a468aa2e4854..9d81074b31df 100644
--- a/drivers/media/dvb/ttpci/av7110_hw.c
+++ b/drivers/media/dvb/ttpci/av7110_hw.c
@@ -53,11 +53,11 @@ int av7110_debiwrite(struct av7110 *av7110, u32 config,
         struct saa7146_dev *dev = av7110->dev;
 
         if (count <= 0 || count > 32764) {
-                printk("%s: invalid count %d\n", __FUNCTION__, count);
+                printk("%s: invalid count %d\n", __func__, count);
                 return -1;
         }
         if (saa7146_wait_for_debi_done(av7110->dev, 0) < 0) {
-                printk("%s: wait_for_debi_done failed\n", __FUNCTION__);
+                printk("%s: wait_for_debi_done failed\n", __func__);
                 return -1;
         }
         saa7146_write(dev, DEBI_CONFIG, config);
@@ -76,11 +76,11 @@ u32 av7110_debiread(struct av7110 *av7110, u32 config, int addr, int count)
         u32 result = 0;
 
         if (count > 32764 || count <= 0) {
-                printk("%s: invalid count %d\n", __FUNCTION__, count);
+                printk("%s: invalid count %d\n", __func__, count);
                 return 0;
         }
         if (saa7146_wait_for_debi_done(av7110->dev, 0) < 0) {
-                printk("%s: wait_for_debi_done #1 failed\n", __FUNCTION__);
+                printk("%s: wait_for_debi_done #1 failed\n", __func__);
                 return 0;
         }
         saa7146_write(dev, DEBI_AD, av7110->debi_bus);
@@ -91,7 +91,7 @@ u32 av7110_debiread(struct av7110 *av7110, u32 config, int addr, int count)
         if (count > 4)
                 return count;
         if (saa7146_wait_for_debi_done(av7110->dev, 0) < 0) {
-                printk("%s: wait_for_debi_done #2 failed\n", __FUNCTION__);
+                printk("%s: wait_for_debi_done #2 failed\n", __func__);
                 return 0;
         }
 
@@ -332,7 +332,7 @@ int av7110_wait_msgstate(struct av7110 *av7110, u16 flags)
                         break;
                 if (err) {
                         printk(KERN_ERR "%s: timeout waiting for MSGSTATE %04x\n",
-                                __FUNCTION__, stat & flags);
+                                __func__, stat & flags);
                         return -ETIMEDOUT;
                 }
                 msleep(1);
@@ -362,7 +362,7 @@ static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
                 if (rdebi(av7110, DEBINOSWAP, COMMAND, 0, 2) == 0)
                         break;
                 if (err) {
-                        printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for COMMAND idle\n", __FUNCTION__);
+                        printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for COMMAND idle\n", __func__);
                         av7110->arm_errors++;
                         return -ETIMEDOUT;
                 }
@@ -379,7 +379,7 @@ static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
                 if (rdebi(av7110, DEBINOSWAP, HANDSHAKE_REG, 0, 2) == 0)
                         break;
                 if (err) {
-                        printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for HANDSHAKE_REG\n", __FUNCTION__);
+                        printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for HANDSHAKE_REG\n", __func__);
                         return -ETIMEDOUT;
                 }
                 msleep(1);
@@ -419,14 +419,14 @@ static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
                         stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
                         if (stat & flags[0]) {
                                 printk(KERN_ERR "%s: %s QUEUE overflow\n",
-                                        __FUNCTION__, type);
+                                        __func__, type);
                                 return -1;
                         }
                         if ((stat & flags[1]) == 0)
                                 break;
                         if (err) {
                                 printk(KERN_ERR "%s: timeout waiting on busy %s QUEUE\n",
-                                        __FUNCTION__, type);
+                                        __func__, type);
                                 return -ETIMEDOUT;
                         }
                         msleep(1);
@@ -454,7 +454,7 @@ static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
                         break;
                 if (err) {
                         printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for COMMAND %d to complete\n",
-                               __FUNCTION__, (buf[0] >> 8) & 0xff);
+                               __func__, (buf[0] >> 8) & 0xff);
                         return -ETIMEDOUT;
                 }
                 msleep(1);
@@ -462,11 +462,11 @@ static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
 
         stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
         if (stat & GPMQOver) {
-                printk(KERN_ERR "dvb-ttpci: %s(): GPMQOver\n", __FUNCTION__);
+                printk(KERN_ERR "dvb-ttpci: %s(): GPMQOver\n", __func__);
                 return -ENOSPC;
         }
         else if (stat & OSDQOver) {
-                printk(KERN_ERR "dvb-ttpci: %s(): OSDQOver\n", __FUNCTION__);
+                printk(KERN_ERR "dvb-ttpci: %s(): OSDQOver\n", __func__);
                 return -ENOSPC;
         }
 #endif
@@ -491,7 +491,7 @@ static int av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
         mutex_unlock(&av7110->dcomlock);
         if (ret && ret!=-ERESTARTSYS)
                 printk(KERN_ERR "dvb-ttpci: %s(): av7110_send_fw_cmd error %d\n",
-                       __FUNCTION__, ret);
+                       __func__, ret);
         return ret;
 }
 
@@ -575,7 +575,7 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
                 if (rdebi(av7110, DEBINOSWAP, COMMAND, 0, 2) == 0)
                         break;
                 if (err) {
-                        printk(KERN_ERR "%s: timeout waiting for COMMAND to complete\n", __FUNCTION__);
+                        printk(KERN_ERR "%s: timeout waiting for COMMAND to complete\n", __func__);
                         mutex_unlock(&av7110->dcomlock);
                         return -ETIMEDOUT;
                 }
@@ -591,7 +591,7 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
                 if (rdebi(av7110, DEBINOSWAP, HANDSHAKE_REG, 0, 2) == 0)
                         break;
                 if (err) {
-                        printk(KERN_ERR "%s: timeout waiting for HANDSHAKE_REG\n", __FUNCTION__);
+                        printk(KERN_ERR "%s: timeout waiting for HANDSHAKE_REG\n", __func__);
                         mutex_unlock(&av7110->dcomlock);
                         return -ETIMEDOUT;
                 }
@@ -602,12 +602,12 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
 #ifdef COM_DEBUG
         stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
         if (stat & GPMQOver) {
-                printk(KERN_ERR "%s: GPMQOver\n", __FUNCTION__);
+                printk(KERN_ERR "%s: GPMQOver\n", __func__);
                 mutex_unlock(&av7110->dcomlock);
                 return -1;
         }
         else if (stat & OSDQOver) {
-                printk(KERN_ERR "%s: OSDQOver\n", __FUNCTION__);
+                printk(KERN_ERR "%s: OSDQOver\n", __func__);
                 mutex_unlock(&av7110->dcomlock);
                 return -1;
         }
@@ -741,7 +741,7 @@ static int FlushText(struct av7110 *av7110)
                         break;
                 if (err) {
                         printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for BUFF1_BASE == 0\n",
-                               __FUNCTION__);
+                               __func__);
                         mutex_unlock(&av7110->dcomlock);
                         return -ETIMEDOUT;
                 }
@@ -768,7 +768,7 @@ static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, char *buf)
                         break;
                 if (ret) {
                         printk(KERN_ERR "dvb-ttpci: %s: timeout waiting for BUFF1_BASE == 0\n",
-                               __FUNCTION__);
+                               __func__);
                         mutex_unlock(&av7110->dcomlock);
                         return -ETIMEDOUT;
                 }
@@ -782,7 +782,7 @@ static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, char *buf)
                         break;
                 if (ret) {
                         printk(KERN_ERR "dvb-ttpci: %s: timeout waiting for HANDSHAKE_REG\n",
-                               __FUNCTION__);
+                               __func__);
                         mutex_unlock(&av7110->dcomlock);
                         return -ETIMEDOUT;
                 }
diff --git a/drivers/media/dvb/ttpci/av7110_ir.c b/drivers/media/dvb/ttpci/av7110_ir.c
index a283e1de83fa..23a1c6380d3f 100644
--- a/drivers/media/dvb/ttpci/av7110_ir.c
+++ b/drivers/media/dvb/ttpci/av7110_ir.c
@@ -133,7 +133,7 @@ static void av7110_emit_key(unsigned long parm)
                 break;
 
         default:
-                printk("%s invalid protocol %x\n", __FUNCTION__, ir->protocol);
+                printk("%s invalid protocol %x\n", __func__, ir->protocol);
                 return;
         }
 
@@ -143,7 +143,7 @@ static void av7110_emit_key(unsigned long parm)
         keycode = ir->key_map[data];
 
         dprintk(16, "%s: code %08x -> addr %i data 0x%02x -> keycode %i\n",
-                __FUNCTION__, ircom, addr, data, keycode);
+                __func__, ircom, addr, data, keycode);
 
         /* check device address */
         if (!(ir->device_mask & (1 << addr)))
@@ -151,7 +151,7 @@ static void av7110_emit_key(unsigned long parm)
 
         if (!keycode) {
                 printk ("%s: code %08x -> addr %i data 0x%02x -> unknown key!\n",
-                        __FUNCTION__, ircom, addr, data);
+                        __func__, ircom, addr, data);
                 return;
         }
 
diff --git a/drivers/media/dvb/ttpci/av7110_v4l.c b/drivers/media/dvb/ttpci/av7110_v4l.c
index e2f066fb7967..b4a0cc5dc935 100644
--- a/drivers/media/dvb/ttpci/av7110_v4l.c
+++ b/drivers/media/dvb/ttpci/av7110_v4l.c
@@ -573,7 +573,7 @@ static int av7110_vbi_reset(struct inode *inode, struct file *file)
         struct saa7146_dev *dev = fh->dev;
         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
 
-        dprintk(2, "%s\n", __FUNCTION__);
+        dprintk(2, "%s\n", __func__);
         av7110->wssMode = 0;
         av7110->wssData = 0;
         if (FW_VERSION(av7110->arm_app) < 0x2623)
@@ -590,7 +590,7 @@ static ssize_t av7110_vbi_write(struct file *file, const char __user *data, size
         struct v4l2_sliced_vbi_data d;
         int rc;
 
-        dprintk(2, "%s\n", __FUNCTION__);
+        dprintk(2, "%s\n", __func__);
         if (FW_VERSION(av7110->arm_app) < 0x2623 || !av7110->wssMode || count != sizeof d)
                 return -EINVAL;
         if (copy_from_user(&d, data, count))
diff --git a/drivers/media/dvb/ttpci/budget-av.c b/drivers/media/dvb/ttpci/budget-av.c
index 2d64d557b977..b30a5288e484 100644
--- a/drivers/media/dvb/ttpci/budget-av.c
+++ b/drivers/media/dvb/ttpci/budget-av.c
@@ -178,7 +178,7 @@ static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 addre
         udelay(1);
 
         result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 3, 1, 0, 0);
-        if ((result == -ETIMEDOUT) || ((result == 0xff) && ((address & 3) < 2))) {
+        if (result == -ETIMEDOUT) {
                 ciintf_slot_shutdown(ca, slot);
                 printk(KERN_INFO "budget-av: cam ejected 3\n");
                 return -ETIMEDOUT;
@@ -577,7 +577,7 @@ static struct stv0299_config typhoon_config = {
         .mclk = 88000000UL,
         .invert = 0,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_1,
+        .lock_output = STV0299_LOCKOUTPUT_1,
         .volt13_op0_op1 = STV0299_VOLT13_OP0,
         .min_delay_ms = 100,
         .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
@@ -590,7 +590,7 @@ static struct stv0299_config cinergy_1200s_config = {
         .mclk = 88000000UL,
         .invert = 0,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_0,
+        .lock_output = STV0299_LOCKOUTPUT_0,
         .volt13_op0_op1 = STV0299_VOLT13_OP0,
         .min_delay_ms = 100,
         .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
@@ -602,7 +602,7 @@ static struct stv0299_config cinergy_1200s_1894_0010_config = {
         .mclk = 88000000UL,
         .invert = 1,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_1,
+        .lock_output = STV0299_LOCKOUTPUT_1,
         .volt13_op0_op1 = STV0299_VOLT13_OP0,
         .min_delay_ms = 100,
         .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
@@ -869,7 +869,7 @@ static struct stv0299_config philips_sd1878_config = {
         .mclk = 88000000UL,
         .invert = 0,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_1,
+        .lock_output = STV0299_LOCKOUTPUT_1,
         .volt13_op0_op1 = STV0299_VOLT13_OP0,
         .min_delay_ms = 100,
         .set_symbol_rate = philips_sd1878_ci_set_symbol_rate,
@@ -941,6 +941,12 @@ static void frontend_init(struct budget_av *budget_av)
         switch (saa->pci->subsystem_device) {
 
         case SUBID_DVBS_KNC1:
+                /*
+                 * maybe that setting is needed for other dvb-s cards as well,
+                 * but so far it has been only confirmed for this type
+                 */
+                budget_av->reinitialise_demod = 1;
+                /* fall through */
         case SUBID_DVBS_KNC1_PLUS:
         case SUBID_DVBS_EASYWATCH_1:
                 if (saa->pci->subsystem_vendor == 0x1894) {
diff --git a/drivers/media/dvb/ttpci/budget-ci.c b/drivers/media/dvb/ttpci/budget-ci.c
index 509349211d4f..6530323d5406 100644
--- a/drivers/media/dvb/ttpci/budget-ci.c
+++ b/drivers/media/dvb/ttpci/budget-ci.c
@@ -86,7 +86,7 @@ static int rc5_device = -1;
 module_param(rc5_device, int, 0644);
 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)");
 
-static int ir_debug = 0;
+static int ir_debug;
 module_param(ir_debug, int, 0644);
 MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding");
 
@@ -728,7 +728,7 @@ static struct stv0299_config philips_su1278_tt_config = {
         .mclk = 64000000UL,
         .invert = 0,
         .skip_reinit = 1,
-        .lock_output = STV0229_LOCKOUTPUT_1,
+        .lock_output = STV0299_LOCKOUTPUT_1,
         .volt13_op0_op1 = STV0299_VOLT13_OP1,
         .min_delay_ms = 50,
         .set_symbol_rate = philips_su1278_tt_set_symbol_rate,
@@ -1121,7 +1121,7 @@ static void frontend_init(struct budget_ci *budget_ci)
 
                         budget_ci->budget.dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
                         if (dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, LNBP21_LLC, 0) == NULL) {
-                                printk("%s: No LNBP21 found!\n", __FUNCTION__);
+                                printk("%s: No LNBP21 found!\n", __func__);
                                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
                                 budget_ci->budget.dvb_frontend = NULL;
                         }
diff --git a/drivers/media/dvb/ttpci/budget-core.c b/drivers/media/dvb/ttpci/budget-core.c
index 0252081f013c..18cac4b12ab2 100644
--- a/drivers/media/dvb/ttpci/budget-core.c
+++ b/drivers/media/dvb/ttpci/budget-core.c
@@ -57,6 +57,8 @@ module_param_named(bufsize, dma_buffer_size, int, 0444);
 MODULE_PARM_DESC(debug, "Turn on/off budget debugging (default:off).");
 MODULE_PARM_DESC(bufsize, "DMA buffer size in KB, default: 188, min: 188, max: 1410 (Activy: 564)");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 /****************************************************************************
  * TT budget / WinTV Nova
  ****************************************************************************/
@@ -223,7 +225,7 @@ static void vpeirq(unsigned long data)
 
         if (budget->buffer_warnings && time_after(jiffies, budget->buffer_warning_time)) {
                 printk("%s %s: used %d times >80%% of buffer (%u bytes now)\n",
-                        budget->dev->name, __FUNCTION__, budget->buffer_warnings, count);
+                        budget->dev->name, __func__, budget->buffer_warnings, count);
                 budget->buffer_warning_time = jiffies + BUFFER_WARNING_WAIT;
                 budget->buffer_warnings = 0;
         }
@@ -471,9 +473,10 @@ int ttpci_budget_init(struct budget *budget, struct saa7146_dev *dev,
                 budget->buffer_width, budget->buffer_height);
         printk("%s: dma buffer size %u\n", budget->dev->name, budget->buffer_size);
 
-        if ((ret = dvb_register_adapter(&budget->dvb_adapter, budget->card->name, owner, &budget->dev->pci->dev)) < 0) {
+        ret = dvb_register_adapter(&budget->dvb_adapter, budget->card->name,
+                                   owner, &budget->dev->pci->dev, adapter_nr);
+        if (ret < 0)
                 return ret;
-        }
 
         /* set dd1 stream a & b */
         saa7146_write(dev, DD1_STREAM_B, 0x00000000);
diff --git a/drivers/media/dvb/ttpci/budget.c b/drivers/media/dvb/ttpci/budget.c
index 14b00f57b5de..2293d80c6e51 100644
--- a/drivers/media/dvb/ttpci/budget.c
+++ b/drivers/media/dvb/ttpci/budget.c
@@ -45,6 +45,7 @@
 #include "tda826x.h"
 #include "lnbp21.h"
 #include "bsru6.h"
+#include "bsbe1.h"
 
 static int diseqc_method;
 module_param(diseqc_method, int, 0444);
@@ -257,11 +258,17 @@ static struct ves1820_config alps_tdbe2_config = {
 
 static int grundig_29504_401_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
 {
-        struct budget* budget = (struct budget*) fe->dvb->priv;
+        struct budget *budget = fe->dvb->priv;
+        u8 *tuner_addr = fe->tuner_priv;
         u32 div;
         u8 cfg, cpump, band_select;
         u8 data[4];
-        struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
+        struct i2c_msg msg = { .flags = 0, .buf = data, .len = sizeof(data) };
+
+        if (tuner_addr)
+                msg.addr = *tuner_addr;
+        else
+                msg.addr = 0x61;
 
         div = (36125000 + params->frequency) / 166666;
 
@@ -292,6 +299,12 @@ static struct l64781_config grundig_29504_401_config = {
         .demod_address = 0x55,
 };
 
+static struct l64781_config grundig_29504_401_config_activy = {
+        .demod_address = 0x54,
+};
+
+static u8 tuner_address_grundig_29504_401_activy = 0x60;
+
 static int grundig_29504_451_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
 {
         struct budget* budget = (struct budget*) fe->dvb->priv;
@@ -346,14 +359,48 @@ static int s5h1420_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend
 static struct s5h1420_config s5h1420_config = {
         .demod_address = 0x53,
         .invert = 1,
+        .cdclk_polarity = 1,
 };
 
 static struct tda10086_config tda10086_config = {
         .demod_address = 0x0e,
         .invert = 0,
         .diseqc_tone = 1,
+        .xtal_freq = TDA10086_XTAL_16M,
 };
 
+static struct stv0299_config alps_bsru6_config_activy = {
+        .demod_address = 0x68,
+        .inittab = alps_bsru6_inittab,
+        .mclk = 88000000UL,
+        .invert = 1,
+        .op0_off = 1,
+        .min_delay_ms = 100,
+        .set_symbol_rate = alps_bsru6_set_symbol_rate,
+};
+
+static struct stv0299_config alps_bsbe1_config_activy = {
+        .demod_address = 0x68,
+        .inittab = alps_bsbe1_inittab,
+        .mclk = 88000000UL,
+        .invert = 1,
+        .op0_off = 1,
+        .min_delay_ms = 100,
+        .set_symbol_rate = alps_bsbe1_set_symbol_rate,
+};
+
+
+static int i2c_readreg(struct i2c_adapter *i2c, u8 adr, u8 reg)
+{
+        u8 val;
+        struct i2c_msg msg[] = {
+                { .addr = adr, .flags = 0, .buf = &reg, .len = 1 },
+                { .addr = adr, .flags = I2C_M_RD, .buf = &val, .len = 1 }
+        };
+
+        return (i2c_transfer(i2c, msg, 2) != 2) ? -EIO : val;
+}
+
 static u8 read_pwm(struct budget* budget)
 {
         u8 b = 0xff;
@@ -369,6 +416,8 @@ static u8 read_pwm(struct budget* budget)
 
 static void frontend_init(struct budget *budget)
 {
+        (void)alps_bsbe1_config; /* avoid warning */
+
         switch(budget->dev->pci->subsystem_device) {
         case 0x1003: // Hauppauge/TT Nova budget (stv0299/ALPS BSRU6(tsa5059) OR ves1893/ALPS BSRV2(sp5659))
         case 0x1013:
@@ -414,15 +463,43 @@ static void frontend_init(struct budget *budget)
                 }
                 break;
 
-        case 0x4f60: // Fujitsu Siemens Activy Budget-S PCI rev AL (stv0299/ALPS BSRU6(tsa5059))
-                budget->dvb_frontend = dvb_attach(stv0299_attach, &alps_bsru6_config, &budget->i2c_adap);
-                if (budget->dvb_frontend) {
-                        budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
-                        budget->dvb_frontend->tuner_priv = &budget->i2c_adap;
-                        budget->dvb_frontend->ops.set_voltage = siemens_budget_set_voltage;
-                        budget->dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
+        case 0x4f60: /* Fujitsu Siemens Activy Budget-S PCI rev AL (stv0299/tsa5059) */
+        {
+                int subtype = i2c_readreg(&budget->i2c_adap, 0x50, 0x67);
+
+                if (subtype < 0)
+                        break;
+                /* fixme: find a better way to identify the card */
+                if (subtype < 0x36) {
+                        /* assume ALPS BSRU6 */
+                        budget->dvb_frontend = dvb_attach(stv0299_attach, &alps_bsru6_config_activy, &budget->i2c_adap);
+                        if (budget->dvb_frontend) {
+                                printk(KERN_INFO "budget: tuner ALPS BSRU6 detected\n");
+                                budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
+                                budget->dvb_frontend->tuner_priv = &budget->i2c_adap;
+                                budget->dvb_frontend->ops.set_voltage = siemens_budget_set_voltage;
+                                budget->dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
+                                break;
+                        }
+                } else {
+                        /* assume ALPS BSBE1 */
+                        /* reset tuner */
+                        saa7146_setgpio(budget->dev, 3, SAA7146_GPIO_OUTLO);
+                        msleep(50);
+                        saa7146_setgpio(budget->dev, 3, SAA7146_GPIO_OUTHI);
+                        msleep(250);
+                        budget->dvb_frontend = dvb_attach(stv0299_attach, &alps_bsbe1_config_activy, &budget->i2c_adap);
+                        if (budget->dvb_frontend) {
+                                printk(KERN_INFO "budget: tuner ALPS BSBE1 detected\n");
+                                budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
+                                budget->dvb_frontend->tuner_priv = &budget->i2c_adap;
+                                budget->dvb_frontend->ops.set_voltage = siemens_budget_set_voltage;
+                                budget->dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
+                                break;
+                        }
                 }
                 break;
+        }
 
         case 0x4f61: // Fujitsu Siemens Activy Budget-S PCI rev GR (tda8083/Grundig 29504-451(tsa5522))
                 budget->dvb_frontend = dvb_attach(tda8083_attach, &grundig_29504_451_config, &budget->i2c_adap);
@@ -433,12 +510,20 @@ static void frontend_init(struct budget *budget)
                 }
                 break;
 
+        case 0x5f61: /* Fujitsu Siemens Activy Budget-T PCI rev GR (L64781/Grundig 29504-401(tsa5060)) */
+                budget->dvb_frontend = dvb_attach(l64781_attach, &grundig_29504_401_config_activy, &budget->i2c_adap);
+                if (budget->dvb_frontend) {
+                        budget->dvb_frontend->tuner_priv = &tuner_address_grundig_29504_401_activy;
+                        budget->dvb_frontend->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
+                }
+                break;
+
         case 0x1016: // Hauppauge/TT Nova-S SE (samsung s5h1420/????(tda8260))
                 budget->dvb_frontend = dvb_attach(s5h1420_attach, &s5h1420_config, &budget->i2c_adap);
                 if (budget->dvb_frontend) {
                         budget->dvb_frontend->ops.tuner_ops.set_params = s5h1420_tuner_set_params;
                         if (dvb_attach(lnbp21_attach, budget->dvb_frontend, &budget->i2c_adap, 0, 0) == NULL) {
-                                printk("%s: No LNBP21 found!\n", __FUNCTION__);
+                                printk("%s: No LNBP21 found!\n", __func__);
                                 goto error_out;
                         }
                         break;
@@ -454,9 +539,9 @@ static void frontend_init(struct budget *budget)
                 budget->dvb_frontend = dvb_attach(tda10086_attach, &tda10086_config, &budget->i2c_adap);
                 if (budget->dvb_frontend) {
                         if (dvb_attach(tda826x_attach, budget->dvb_frontend, 0x60, &budget->i2c_adap, 0) == NULL)
-                                printk("%s: No tda826x found!\n", __FUNCTION__);
+                                printk("%s: No tda826x found!\n", __func__);
                         if (dvb_attach(lnbp21_attach, budget->dvb_frontend, &budget->i2c_adap, 0, 0) == NULL) {
-                                printk("%s: No LNBP21 found!\n", __FUNCTION__);
+                                printk("%s: No LNBP21 found!\n", __func__);
                                 goto error_out;
                         }
                         break;
@@ -537,6 +622,7 @@ MAKE_BUDGET_INFO(satel,	"SATELCO Multimedia PCI",	BUDGET_TT_HW_DISEQC);
 MAKE_BUDGET_INFO(ttbs1401, "TT-Budget-S-1401 PCI", BUDGET_TT);
 MAKE_BUDGET_INFO(fsacs0, "Fujitsu Siemens Activy Budget-S PCI (rev GR/grundig frontend)", BUDGET_FS_ACTIVY);
 MAKE_BUDGET_INFO(fsacs1, "Fujitsu Siemens Activy Budget-S PCI (rev AL/alps frontend)", BUDGET_FS_ACTIVY);
+MAKE_BUDGET_INFO(fsact,  "Fujitsu Siemens Activy Budget-T PCI (rev GR/Grundig frontend)", BUDGET_FS_ACTIVY);
 
 static struct pci_device_id pci_tbl[] = {
         MAKE_EXTENSION_PCI(ttbs,  0x13c2, 0x1003),
@@ -547,6 +633,7 @@ static struct pci_device_id pci_tbl[] = {
         MAKE_EXTENSION_PCI(ttbs1401, 0x13c2, 0x1018),
         MAKE_EXTENSION_PCI(fsacs1,0x1131, 0x4f60),
         MAKE_EXTENSION_PCI(fsacs0,0x1131, 0x4f61),
+        MAKE_EXTENSION_PCI(fsact, 0x1131, 0x5f61),
         {
                 .vendor    = 0,
         }
diff --git a/drivers/media/dvb/ttpci/budget.h b/drivers/media/dvb/ttpci/budget.h
index d764ffa728b0..dd450b739bff 100644
--- a/drivers/media/dvb/ttpci/budget.h
+++ b/drivers/media/dvb/ttpci/budget.h
@@ -1,3 +1,4 @@
+
 #ifndef __BUDGET_DVB__
 #define __BUDGET_DVB__
 
@@ -21,7 +22,7 @@ extern int budget_debug;
 #endif
 
 #define dprintk(level,args...) \
-            do { if ((budget_debug & level)) { printk("%s: %s(): ", KBUILD_MODNAME, __FUNCTION__); printk(args); } } while (0)
+            do { if ((budget_debug & level)) { printk("%s: %s(): ", KBUILD_MODNAME, __func__); printk(args); } } while (0)
 
 struct budget_info {
         char *name;
diff --git a/drivers/media/dvb/ttpci/ttpci-eeprom.c b/drivers/media/dvb/ttpci/ttpci-eeprom.c
index 1f31e91195b0..7dd54b3026a2 100644
--- a/drivers/media/dvb/ttpci/ttpci-eeprom.c
+++ b/drivers/media/dvb/ttpci/ttpci-eeprom.c
@@ -95,7 +95,7 @@ static int ttpci_eeprom_read_encodedMAC(struct i2c_adapter *adapter, u8 * encode
                 { .addr = 0x50, .flags = I2C_M_RD, .buf = encodedMAC, .len = 20 }
         };
 
-        /* dprintk("%s\n", __FUNCTION__); */
+        /* dprintk("%s\n", __func__); */
 
         ret = i2c_transfer(adapter, msg, 2);
 
diff --git a/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c b/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c
index 7902ae1d9a18..732ce4de512e 100644
--- a/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c
+++ b/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c
@@ -56,10 +56,11 @@
 */
 
 static int debug;
-
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define dprintk(x...) do { if (debug) printk(KERN_DEBUG x); } while (0)
 
 #define ISO_BUF_COUNT      4
@@ -153,12 +154,12 @@ static int ttusb_cmd(struct ttusb *ttusb,
                            (u8 *) data, len, &actual_len, 1000);
         if (err != 0) {
                 dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n",
-                        __FUNCTION__, err);
+                        __func__, err);
                 mutex_unlock(&ttusb->semusb);
                 return err;
         }
         if (actual_len != len) {
-                dprintk("%s: only wrote %d of %d bytes\n", __FUNCTION__,
+                dprintk("%s: only wrote %d of %d bytes\n", __func__,
                         actual_len, len);
                 mutex_unlock(&ttusb->semusb);
                 return -1;
@@ -168,7 +169,7 @@ static int ttusb_cmd(struct ttusb *ttusb,
                            ttusb->last_result, 32, &actual_len, 1000);
 
         if (err != 0) {
-                printk("%s: failed, receive error %d\n", __FUNCTION__,
+                printk("%s: failed, receive error %d\n", __func__,
                        err);
                 mutex_unlock(&ttusb->semusb);
                 return err;
@@ -229,7 +230,7 @@ static int ttusb_i2c_msg(struct ttusb *ttusb,
                 if (err || b[0] != 0x55 || b[1] != id) {
                         dprintk
                             ("%s: usb_bulk_msg(recv) failed, err == %i, id == %02x, b == ",
-                             __FUNCTION__, err, id);
+                             __func__, err, id);
                         return -EREMOTEIO;
                 }
 
@@ -273,7 +274,7 @@ static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num
                                     snd_buf, snd_len, rcv_buf, rcv_len);
 
                 if (err < rcv_len) {
-                        dprintk("%s: i == %i\n", __FUNCTION__, i);
+                        dprintk("%s: i == %i\n", __func__, i);
                         break;
                 }
 
@@ -327,7 +328,7 @@ static int ttusb_boot_dsp(struct ttusb *ttusb)
       done:
         if (err) {
                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
-                        __FUNCTION__, err);
+                        __func__, err);
         }
 
         return err;
@@ -427,7 +428,7 @@ static int ttusb_init_controller(struct ttusb *ttusb)
         if ((err = ttusb_result(ttusb, get_version, sizeof(get_version))))
                 return err;
 
-        dprintk("%s: stc-version: %c%c%c%c%c\n", __FUNCTION__,
+        dprintk("%s: stc-version: %c%c%c%c%c\n", __func__,
                 get_version[4], get_version[5], get_version[6],
                 get_version[7], get_version[8]);
 
@@ -437,7 +438,7 @@ static int ttusb_init_controller(struct ttusb *ttusb)
             memcmp(get_version + 4, "V 2.2", 5)) {
                 printk
                     ("%s: unknown STC version %c%c%c%c%c, please report!\n",
-                     __FUNCTION__, get_version[4], get_version[5],
+                     __func__, get_version[4], get_version[5],
                      get_version[6], get_version[7], get_version[8]);
         }
 
@@ -453,7 +454,7 @@ static int ttusb_init_controller(struct ttusb *ttusb)
             ttusb_result(ttusb, get_dsp_version, sizeof(get_dsp_version));
         if (err)
                 return err;
-        printk("%s: dsp-version: %c%c%c\n", __FUNCTION__,
+        printk("%s: dsp-version: %c%c%c\n", __func__,
                get_dsp_version[4], get_dsp_version[5], get_dsp_version[6]);
         return 0;
 }
@@ -476,7 +477,7 @@ static int ttusb_send_diseqc(struct dvb_frontend* fe,
         /* Diseqc */
         if ((err = ttusb_cmd(ttusb, b, 4 + b[3], 0))) {
                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
-                        __FUNCTION__, err);
+                        __func__, err);
         }
 
         return err;
@@ -494,7 +495,7 @@ static int ttusb_update_lnb(struct ttusb *ttusb)
         /* SetLNB */
         if ((err = ttusb_cmd(ttusb, b, sizeof(b), 0))) {
                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
-                        __FUNCTION__, err);
+                        __func__, err);
         }
 
         return err;
@@ -528,7 +529,7 @@ static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
         if (err) {
                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
-                        __FUNCTION__, err);
+                        __func__, err);
         }
 }
 #endif
@@ -542,7 +543,7 @@ static void ttusb_handle_sec_data(struct ttusb_channel *channel,
                                   const u8 * data, int len);
 #endif
 
-static int numpkt = 0, numts, numstuff, numsec, numinvalid;
+static int numpkt, numts, numstuff, numsec, numinvalid;
 static unsigned long lastj;
 
 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
@@ -554,7 +555,7 @@ static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
                 csum ^= le16_to_cpup((u16 *) (muxpack + i));
         if (csum) {
                 printk("%s: muxpack with incorrect checksum, ignoring\n",
-                       __FUNCTION__);
+                       __func__);
                 numinvalid++;
                 return;
         }
@@ -563,7 +564,7 @@ static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
         cc &= 0x7FFF;
         if ((cc != ttusb->cc) && (ttusb->cc != -1))
                 printk("%s: cc discontinuity (%d frames missing)\n",
-                       __FUNCTION__, (cc - ttusb->cc) & 0x7FFF);
+                       __func__, (cc - ttusb->cc) & 0x7FFF);
         ttusb->cc = (cc + 1) & 0x7FFF;
         if (muxpack[0] & 0x80) {
 #ifdef TTUSB_HWSECTIONS
@@ -613,7 +614,7 @@ static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
         int maxwork = 1024;
         while (len) {
                 if (!(maxwork--)) {
-                        printk("%s: too much work\n", __FUNCTION__);
+                        printk("%s: too much work\n", __func__);
                         break;
                 }
 
@@ -632,7 +633,7 @@ static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
 #else
                                 if (ttusb->insync) {
                                         printk("%s: lost sync.\n",
-                                               __FUNCTION__);
+                                               __func__);
                                         ttusb->insync = 0;
                                 }
 #endif
@@ -691,7 +692,7 @@ static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
                                         else {
                                                 dprintk
                                                     ("%s: invalid state: first byte is %x\n",
-                                                     __FUNCTION__,
+                                                     __func__,
                                                      ttusb->muxpack[0]);
                                                 ttusb->mux_state = 0;
                                         }
@@ -740,7 +741,7 @@ static void ttusb_iso_irq(struct urb *urb)
 
 #if 0
         printk("%s: status %d, errcount == %d, length == %i\n",
-               __FUNCTION__,
+               __func__,
                urb->status, urb->error_count, urb->actual_length);
 #endif
 
@@ -833,7 +834,7 @@ static int ttusb_start_iso_xfer(struct ttusb *ttusb)
         int i, j, err, buffer_offset = 0;
 
         if (ttusb->iso_streaming) {
-                printk("%s: iso xfer already running!\n", __FUNCTION__);
+                printk("%s: iso xfer already running!\n", __func__);
                 return 0;
         }
 
@@ -869,7 +870,7 @@ static int ttusb_start_iso_xfer(struct ttusb *ttusb)
                         ttusb_stop_iso_xfer(ttusb);
                         printk
                             ("%s: failed urb submission (%i: err = %i)!\n",
-                             __FUNCTION__, i, err);
+                             __func__, i, err);
                         return err;
                 }
         }
@@ -1005,7 +1006,7 @@ static int stc_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static struct file_operations stc_fops = {
+static const struct file_operations stc_fops = {
         .owner = THIS_MODULE,
         .read = stc_read,
         .open = stc_open,
@@ -1313,7 +1314,7 @@ static struct stv0299_config alps_stv0299_config = {
         .mclk = 88000000UL,
         .invert = 1,
         .skip_reinit = 0,
-        .lock_output = STV0229_LOCKOUTPUT_1,
+        .lock_output = STV0299_LOCKOUTPUT_1,
         .volt13_op0_op1 = STV0299_VOLT13_OP1,
         .min_delay_ms = 100,
         .set_symbol_rate = alps_stv0299_set_symbol_rate,
@@ -1643,7 +1644,7 @@ static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *i
         struct ttusb *ttusb;
         int result;
 
-        dprintk("%s: TTUSB DVB connected\n", __FUNCTION__);
+        dprintk("%s: TTUSB DVB connected\n", __func__);
 
         udev = interface_to_usbdev(intf);
 
@@ -1669,7 +1670,10 @@ static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *i
 
         mutex_unlock(&ttusb->semi2c);
 
-        if ((result = dvb_register_adapter(&ttusb->adapter, "Technotrend/Hauppauge Nova-USB", THIS_MODULE, &udev->dev)) < 0) {
+        result = dvb_register_adapter(&ttusb->adapter,
+                                      "Technotrend/Hauppauge Nova-USB",
+                                      THIS_MODULE, &udev->dev, adapter_nr);
+        if (result < 0) {
                 ttusb_free_iso_urbs(ttusb);
                 kfree(ttusb);
                 return result;
@@ -1773,7 +1777,7 @@ static void ttusb_disconnect(struct usb_interface *intf)
 
         kfree(ttusb);
 
-        dprintk("%s: TTUSB DVB disconnected\n", __FUNCTION__);
+        dprintk("%s: TTUSB DVB disconnected\n", __func__);
 }
 
 static struct usb_device_id ttusb_table[] = {
diff --git a/drivers/media/dvb/ttusb-dec/ttusb_dec.c b/drivers/media/dvb/ttusb-dec/ttusb_dec.c
index 1ec981d98b91..42eee04daa5d 100644
--- a/drivers/media/dvb/ttusb-dec/ttusb_dec.c
+++ b/drivers/media/dvb/ttusb-dec/ttusb_dec.c
@@ -52,6 +52,8 @@ MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
 module_param(enable_rc, int, 0644);
 MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)");
 
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
 #define dprintk if (debug) printk
 
 #define DRIVER_NAME             "TechnoTrend/Hauppauge DEC USB"
@@ -217,11 +219,11 @@ static void ttusb_dec_handle_irq( struct urb *urb)
                 case -ETIME:
                         /* this urb is dead, cleanup */
                         dprintk("%s:urb shutting down with status: %d\n",
-                                        __FUNCTION__, urb->status);
+                                        __func__, urb->status);
                         return;
                 default:
                         dprintk("%s:nonzero status received: %d\n",
-                                        __FUNCTION__,urb->status);
+                                        __func__,urb->status);
                         goto exit;
         }
 
@@ -235,7 +237,7 @@ static void ttusb_dec_handle_irq( struct urb *urb)
                  * keyrepeat signal is recieved for lets say 200ms.
                  * this should/could be added later ...
                  * for now lets report each signal as a key down and up*/
-                dprintk("%s:rc signal:%d\n", __FUNCTION__, buffer[4]);
+                dprintk("%s:rc signal:%d\n", __func__, buffer[4]);
                 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1);
                 input_sync(dec->rc_input_dev);
                 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0);
@@ -245,7 +247,7 @@ static void ttusb_dec_handle_irq( struct urb *urb)
 exit:   retval = usb_submit_urb(urb, GFP_ATOMIC);
         if(retval)
                 printk("%s - usb_commit_urb failed with result: %d\n",
-                        __FUNCTION__, retval);
+                        __func__, retval);
 }
 
 static u16 crc16(u16 crc, const u8 *buf, size_t len)
@@ -268,7 +270,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
         int result, actual_len, i;
         u8 *b;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
         if (!b)
@@ -276,7 +278,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
 
         if ((result = mutex_lock_interruptible(&dec->usb_mutex))) {
                 kfree(b);
-                printk("%s: Failed to lock usb mutex.\n", __FUNCTION__);
+                printk("%s: Failed to lock usb mutex.\n", __func__);
                 return result;
         }
 
@@ -289,7 +291,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
                 memcpy(&b[4], params, param_length);
 
         if (debug) {
-                printk("%s: command: ", __FUNCTION__);
+                printk("%s: command: ", __func__);
                 for (i = 0; i < param_length + 4; i++)
                         printk("0x%02X ", b[i]);
                 printk("\n");
@@ -300,7 +302,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
 
         if (result) {
                 printk("%s: command bulk message failed: error %d\n",
-                       __FUNCTION__, result);
+                       __func__, result);
                 mutex_unlock(&dec->usb_mutex);
                 kfree(b);
                 return result;
@@ -311,13 +313,13 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
 
         if (result) {
                 printk("%s: result bulk message failed: error %d\n",
-                       __FUNCTION__, result);
+                       __func__, result);
                 mutex_unlock(&dec->usb_mutex);
                 kfree(b);
                 return result;
         } else {
                 if (debug) {
-                        printk("%s: result: ", __FUNCTION__);
+                        printk("%s: result: ", __func__);
                         for (i = 0; i < actual_len; i++)
                                 printk("0x%02X ", b[i]);
                         printk("\n");
@@ -343,7 +345,7 @@ static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
         int result;
         unsigned int tmp;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
         if (result)
@@ -400,7 +402,7 @@ static void ttusb_dec_set_pids(struct ttusb_dec *dec)
         u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
         u16 video = htons(dec->pid[DMX_PES_VIDEO]);
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         memcpy(&b[0], &pcr, 2);
         memcpy(&b[2], &audio, 2);
@@ -419,12 +421,12 @@ static void ttusb_dec_set_pids(struct ttusb_dec *dec)
 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
 {
         if (length < 8) {
-                printk("%s: packet too short - discarding\n", __FUNCTION__);
+                printk("%s: packet too short - discarding\n", __func__);
                 return;
         }
 
         if (length > 8 + MAX_PVA_LENGTH) {
-                printk("%s: packet too long - discarding\n", __FUNCTION__);
+                printk("%s: packet too long - discarding\n", __func__);
                 return;
         }
 
@@ -507,7 +509,7 @@ static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
                 break;
 
         default:
-                printk("%s: unknown PVA type: %02x.\n", __FUNCTION__,
+                printk("%s: unknown PVA type: %02x.\n", __func__,
                        pva[2]);
                 break;
         }
@@ -546,7 +548,7 @@ static void ttusb_dec_process_packet(struct ttusb_dec *dec)
         u16 packet_id;
 
         if (dec->packet_length % 2) {
-                printk("%s: odd sized packet - discarding\n", __FUNCTION__);
+                printk("%s: odd sized packet - discarding\n", __func__);
                 return;
         }
 
@@ -554,7 +556,7 @@ static void ttusb_dec_process_packet(struct ttusb_dec *dec)
                 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
 
         if (csum) {
-                printk("%s: checksum failed - discarding\n", __FUNCTION__);
+                printk("%s: checksum failed - discarding\n", __func__);
                 return;
         }
 
@@ -563,7 +565,7 @@ static void ttusb_dec_process_packet(struct ttusb_dec *dec)
 
         if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
                 printk("%s: warning: lost packets between %u and %u\n",
-                       __FUNCTION__, dec->next_packet_id - 1, packet_id);
+                       __func__, dec->next_packet_id - 1, packet_id);
         }
 
         if (packet_id == 0xffff)
@@ -652,7 +654,7 @@ static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
                                         dec->packet_state = 7;
                                 } else {
                                         printk("%s: unknown packet type: "
-                                               "%02x%02x\n", __FUNCTION__,
+                                               "%02x%02x\n", __func__,
                                                dec->packet[0], dec->packet[1]);
                                         dec->packet_state = 0;
                                 }
@@ -724,7 +726,7 @@ static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
 
                 default:
                         printk("%s: illegal packet state encountered.\n",
-                               __FUNCTION__);
+                               __func__);
                         dec->packet_state = 0;
                 }
         }
@@ -792,7 +794,7 @@ static void ttusb_dec_process_urb(struct urb *urb)
         } else {
                  /* -ENOENT is expected when unlinking urbs */
                 if (urb->status != -ENOENT)
-                        dprintk("%s: urb error: %d\n", __FUNCTION__,
+                        dprintk("%s: urb error: %d\n", __func__,
                                 urb->status);
         }
 
@@ -804,7 +806,7 @@ static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
 {
         int i, j, buffer_offset = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         for (i = 0; i < ISO_BUF_COUNT; i++) {
                 int frame_offset = 0;
@@ -834,7 +836,7 @@ static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
 {
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (mutex_lock_interruptible(&dec->iso_mutex))
                 return;
@@ -889,7 +891,7 @@ static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
 {
         int i, result;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (mutex_lock_interruptible(&dec->iso_mutex))
                 return -EAGAIN;
@@ -905,7 +907,7 @@ static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
                         if ((result = usb_submit_urb(dec->iso_urb[i],
                                                      GFP_ATOMIC))) {
                                 printk("%s: failed urb submission %d: "
-                                       "error %d\n", __FUNCTION__, i, result);
+                                       "error %d\n", __func__, i, result);
 
                                 while (i) {
                                         usb_kill_urb(dec->iso_urb[i - 1]);
@@ -932,7 +934,7 @@ static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
         u8 b0[] = { 0x05 };
         int result = 0;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         dprintk("  ts_type:");
 
@@ -1012,7 +1014,7 @@ static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
         unsigned long flags;
         u8 x = 1;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         pid = htons(dvbdmxfeed->pid);
         memcpy(&b0[0], &pid, 2);
@@ -1052,7 +1054,7 @@ static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 {
         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (!dvbdmx->dmx.frontend)
                 return -EINVAL;
@@ -1113,7 +1115,7 @@ static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
 
 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         switch (dvbdmxfeed->type) {
         case DMX_TYPE_TS:
@@ -1132,7 +1134,7 @@ static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
 {
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         for (i = 0; i < ISO_BUF_COUNT; i++)
                 usb_free_urb(dec->iso_urb[i]);
@@ -1147,7 +1149,7 @@ static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
 {
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         dec->iso_buffer = pci_alloc_consistent(NULL,
                                                ISO_FRAME_SIZE *
@@ -1214,7 +1216,7 @@ static int ttusb_init_rc( struct ttusb_dec *dec)
 
         dec->rc_input_dev = input_dev;
         if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
-                printk("%s: usb_submit_urb failed\n",__FUNCTION__);
+                printk("%s: usb_submit_urb failed\n",__func__);
         /* enable irq pipe */
         ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
 
@@ -1223,7 +1225,7 @@ static int ttusb_init_rc( struct ttusb_dec *dec)
 
 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         dec->v_pes[0] = 0x00;
         dec->v_pes[1] = 0x00;
@@ -1233,7 +1235,7 @@ static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
 
 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         mutex_init(&dec->usb_mutex);
         mutex_init(&dec->iso_mutex);
@@ -1281,11 +1283,11 @@ static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
         u32 crc32_csum, crc32_check, tmp;
         const struct firmware *fw_entry = NULL;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
                 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
-                       __FUNCTION__, dec->firmware_name);
+                       __func__, dec->firmware_name);
                 return 1;
         }
 
@@ -1294,7 +1296,7 @@ static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
 
         if (firmware_size < 60) {
                 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
-                        __FUNCTION__, firmware_size);
+                        __func__, firmware_size);
                 release_firmware(fw_entry);
                 return -1;
         }
@@ -1308,7 +1310,7 @@ static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
         if (crc32_csum != crc32_check) {
                 printk("%s: crc32 check of DSP code failed (calculated "
                        "0x%08x != 0x%08x in file), file invalid.\n",
-                        __FUNCTION__, crc32_csum, crc32_check);
+                        __func__, crc32_csum, crc32_check);
                 release_firmware(fw_entry);
                 return -1;
         }
@@ -1376,7 +1378,7 @@ static int ttusb_dec_init_stb(struct ttusb_dec *dec)
         int result;
         unsigned int mode, model, version;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
 
@@ -1415,7 +1417,7 @@ static int ttusb_dec_init_stb(struct ttusb_dec *dec)
                         default:
                                 printk(KERN_ERR "%s: unknown model returned "
                                        "by firmware (%08x) - please report\n",
-                                       __FUNCTION__, model);
+                                       __func__, model);
                                 return -1;
                                 break;
                         }
@@ -1434,12 +1436,14 @@ static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
 {
         int result;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if ((result = dvb_register_adapter(&dec->adapter,
-                                           dec->model_name, THIS_MODULE, &dec->udev->dev)) < 0) {
+                                           dec->model_name, THIS_MODULE,
+                                           &dec->udev->dev,
+                                           adapter_nr)) < 0) {
                 printk("%s: dvb_register_adapter failed: error %d\n",
-                       __FUNCTION__, result);
+                       __func__, result);
 
                 return result;
         }
@@ -1454,7 +1458,7 @@ static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
         dec->demux.write_to_decoder = NULL;
 
         if ((result = dvb_dmx_init(&dec->demux)) < 0) {
-                printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
+                printk("%s: dvb_dmx_init failed: error %d\n", __func__,
                        result);
 
                 dvb_unregister_adapter(&dec->adapter);
@@ -1468,7 +1472,7 @@ static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
 
         if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
                 printk("%s: dvb_dmxdev_init failed: error %d\n",
-                       __FUNCTION__, result);
+                       __func__, result);
 
                 dvb_dmx_release(&dec->demux);
                 dvb_unregister_adapter(&dec->adapter);
@@ -1480,7 +1484,7 @@ static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
 
         if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
                                                   &dec->frontend)) < 0) {
-                printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
+                printk("%s: dvb_dmx_init failed: error %d\n", __func__,
                        result);
 
                 dvb_dmxdev_release(&dec->dmxdev);
@@ -1492,7 +1496,7 @@ static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
 
         if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
                                                       &dec->frontend)) < 0) {
-                printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
+                printk("%s: dvb_dmx_init failed: error %d\n", __func__,
                        result);
 
                 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
@@ -1510,7 +1514,7 @@ static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
 
 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
 {
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         dvb_net_release(&dec->dvb_net);
         dec->demux.dmx.close(&dec->demux.dmx);
@@ -1528,7 +1532,7 @@ static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
 {
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
         /* we have to check whether the irq URB is already submitted.
           * As the irq is submitted after the interface is changed,
           * this is the best method i figured out.
@@ -1552,7 +1556,7 @@ static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
 {
         int i;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         dec->iso_stream_count = 0;
 
@@ -1612,12 +1616,12 @@ static int ttusb_dec_probe(struct usb_interface *intf,
         struct usb_device *udev;
         struct ttusb_dec *dec;
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         udev = interface_to_usbdev(intf);
 
         if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
-                printk("%s: couldn't allocate memory.\n", __FUNCTION__);
+                printk("%s: couldn't allocate memory.\n", __func__);
                 return -ENOMEM;
         }
 
@@ -1692,7 +1696,7 @@ static void ttusb_dec_disconnect(struct usb_interface *intf)
 
         usb_set_intfdata(intf, NULL);
 
-        dprintk("%s\n", __FUNCTION__);
+        dprintk("%s\n", __func__);
 
         if (dec->active) {
                 ttusb_dec_exit_tasklet(dec);
@@ -1749,7 +1753,7 @@ static int __init ttusb_dec_init(void)
         int result;
 
         if ((result = usb_register(&ttusb_dec_driver)) < 0) {
-                printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
+                printk("%s: initialisation failed: error %d.\n", __func__,
                        result);
                 return result;
         }
diff --git a/drivers/media/dvb/ttusb-dec/ttusbdecfe.c b/drivers/media/dvb/ttusb-dec/ttusbdecfe.c
index a6fb1d6a7b5d..eb5eaeccd7c4 100644
--- a/drivers/media/dvb/ttusb-dec/ttusbdecfe.c
+++ b/drivers/media/dvb/ttusb-dec/ttusbdecfe.c
@@ -53,7 +53,7 @@ static int ttusbdecfe_read_status(struct dvb_frontend* fe, fe_status_t* status)
                 return ret;
 
         if(len != 4) {
-                printk(KERN_ERR "%s: unexpected reply\n", __FUNCTION__);
+                printk(KERN_ERR "%s: unexpected reply\n", __func__);
                 return -EIO;
         }
 
@@ -70,7 +70,7 @@ static int ttusbdecfe_read_status(struct dvb_frontend* fe, fe_status_t* status)
                         break;
                 default:
                         pr_info("%s: returned unknown value: %d\n",
-                                __FUNCTION__, result[3]);
+                                __func__, result[3]);
                         return -EIO;
         }